Forneci 2 implementações diferentes de segmentos de comutação ao calcular o comprimento da string. Não entendo por que estamos comutando o segmento extra e o segmento de dados ou, mais precisamente, copiando o conteúdo do segmento de dados (registro DS) para o segmento extra (registro ES). Se eu remover as linhas push dse pop eso resultado não mudar, mas quando eu substituir les di, [bp+4]pela mov di, [bp+4] mensagem é exibida na tela, mas com um monte de outros caracteres diferentes.

Por que isso está acontecendo? Sou novo em assembly.

org 0x0100
jmp start

message: db 'Hello world!', 0      ; First string to be concatenated


; Subroutine to calculate the length of a string
; Takes the segment and offset of a string as parameters
strlen:
    push bp
    mov bp, sp
    push es
    push cx
    push di
    les di, [bp+4]        ; Point es:di to string
    mov cx, 0xffff        ; Load maximum number in cx
    xor al, al            ; Load a zero in al
    repne scasb           ; Find zero in the string
    mov ax, 0xffff        ; Load maximum number in ax
    sub ax, cx            ; Find change in cx
    dec ax                ; Exclude null from length
    pop di
    pop cx
    pop es
    pop bp
    ret 4

; Subroutine to print a string
; Takes the x position, y position, attribute, and address of a null-terminated string as parameters
printstr:
    push bp
    mov bp, sp
    pusha
    push di
    push ds               ; Push segment of string
    mov ax, [bp+4]
    push ax               ; Push offset of string
    call strlen           ; Calculate string length

    cmp ax, 0             ; Is the string empty?
    jz exit               ; No printing if string is empty

    mov cx, ax            ; Save length in cx
    mov ax, 0xb800        ; Video memory base address
    mov es, ax            ; Point es to video base
    mov al, 80            ; Load al with columns per row
    mul byte [bp+8]       ; Multiply with y position
    add ax, [bp+10]       ; Add x position
    shl ax, 1             ; Turn into byte offset
    mov di, ax            ; Point di to required location
    mov si, [bp+4]        ; Point si to string
    mov ah, [bp+6]        ; Load attribute in ah
    cld                   ; Clear direction flag for auto-increment mode

 nextchar:
    lodsb                 ; Load next char in al
    stosw                 ; Print char/attribute pair
    loop nextchar         ; Repeat for the whole string

 exit:
    pop ds
    pop di
    popa
    pop bp
    ret 8

start:
    mov ax, 30
    push ax               ; Push x position
    mov ax, 20
    push ax               ; Push y position
    mov ax, 0x7           ; Blue on white attribute
    push ax               ; Push attribute
    mov ax, message
    push ax               ; Push address of message
    call printstr         ; Call the printstr subroutine

    mov ax, 0x4c00        ; Terminate program
    int 0x21

Versão alternativa:

    push bp
    mov bp, sp
    pusha

    push ds
    pop es         ; load ds in es
    mov di, [bp+4] ; point di to string
    mov cx, 0xffff ; load maximum number in cx
    xor al, al 
    repne scasb 
    mov ax, 0xffff 
    sub ax, cx 
    dec ax 
    jz done 

    mov cx, ax
    ...

org 0x0100      
jmp start  

; Declare variables
input1: db 0  
input2: db 7  
input3: db 9  
input4: db 1  
message1: db 'The value of AX, BX and CX is: '
length: dw 31

start:
    ; Push output variables with random values
    push 3       ; Random value 1
    push 5       ; Random value 2
    push 7       ; Random value 3

    call my_subroutine

    ; Retrieve output variables
    pop cx       ; Retrieve output into CX
    pop bx       ; Retrieve output into BX
    pop ax       ; Retrieve output into AX

    ;Display the output values
    call display
    
    ; Exit program
    mov ax, 0x4c00
    int 0x21

my_subroutine:
    ; Save registers
    push ax
    push bx
    push si
    push di
    push cx

    ; Local variables (initialized with random values)
    local1: dw 1
    local2: dw 2
    local3: dw 3
    local4: dw 4
    local5: dw 5

    ; Example operations (just random logic for demonstration)
    mov ax, [input1] ; Load first input
    add ax, [local1] ; Add local variable
    mov bx, [input2] ; Load second input
    sub bx, [local2] ; Subtract local variable

    ; Push results
    ;push ax          ; Push first output (AX)
    ;push bx          ; Push second output (BX)
    ;mov cx, word [input3]      
    ;push cx          ; Push third output (local variable)

    ; Restore registers
    pop cx           ; Pop last pushed value into CX
    pop bx           ; Restore BX
    pop ax           ; Restore AX
    pop di           ; Restore DI
    pop si           ; Restore SI
    ret              ; Return to the caller

cls:

  push es
  push ax
  push di

  mov ax, 0xB800
  mov es, ax
  mov di, 0

 allSpace:

 mov word [es:di], 0x0720
 add di, 2
 cmp di, 4000
 jne allSpace

 pop di
 pop ax
 pop es

 ret

convert_num_to_string:
    push bp
    mov bp, sp 
    push es
    pusha
    mov ax, 0xb800
    mov es, ax
    mov ax, [bp+4]
    mov bx, 10
    mov cx, 0

 nextdigit: 
    mov dx, 0
    div bx
    add dl, 0x30
    push dx
    inc cx
    cmp ax, 0
    jnz nextdigit


    nextpos: 
    pop dx
    mov dh, 0x07
    mov [es:di], dx
    add di, 2
    loop nextpos

    popa
    pop es
    pop bp
    ret 2

display_message:
  push bp
  mov bp, sp
  push es
  push ax
  push bx
  push cx

  mov ax, 0xb800
  mov es, ax

  mov si, [bp+6]
  mov cx, [bp+4]
  mov ah, 0x07

  printAllChar:
  
  mov al, [si]
  mov [es:di], ax
  add di, 2
  add si, 1
  loop printAllChar

  pop cx
  pop bx
  pop ax
  pop es
  pop bp
  ret 4

display:  
    call cls
    mov di, 0                  
    push message1                  
    push word [length]
    call display_message
    
    mov di, 62 
    push ax           
    call convert_num_to_string

    mov di, 66
    push bx           
    call convert_num_to_string

    mov di, 70
    push cx           
    call convert_num_to_string


    ret

Problema principal emmy_subroutine:

Na sub-rotina acima, quando eu envio meu resultado para a pilha, o controle não retorna ao início, mas sim um loop infinito é executado.

A propósito, aqui está a questão que estou tentando resolver:

Você precisa escrever uma sub-rotina em linguagem assembly que:

1. Aceita 4 variáveis ​​de entrada (que serão os dígitos do seu número de registro, ou seja, 22F-3440, 3440 são as 4 entradas).
2. Retorna 3 variáveis ​​de saída. Essas variáveis ​​de saída são empurradas (com valores aleatórios) antes das variáveis ​​de entrada no principal.
3. Cria 5 variáveis ​​locais dentro da função. Inicializado com valores aleatórios de 1 a 10.
4. Usa os registradores AX, BX, SI, DI e CX para executar operações, mas salva e restaura esses registradores antes e depois do uso para evitar sobrescrever seus valores originais.
5. As saídas devem ser inseridas em AX, BX e CX após o retorno da sub-rotina.
6. Exiba-os no console.