Uma pilha que precisa estar equilibrada
Parte da seção Funções, pilha e strings do Journey de Assembly da Coddy. Lição 9 de 33.
ret não sabe de onde veio. Ele remove o que estiver no topo da pilha e salta para lá. Portanto, um procedimento deve deixar a pilha como a encontrou: quando seu ret é executado, o endereço de retorno precisa estar no topo.
Salvar um registrador dentro de uma função auxiliar é adequado quando o desempilhamento dele acontece antes de ret. Esta função auxiliar usa rbx como divisor e o devolve:
; add_tax: rax = rdi + rdi / 10
add_tax:
push rbx
mov rbx, 10
mov rax, rdi
xor edx, edx
div rbx ; rax = rdi / 10
add rax, rdi
pop rbx
retExclua o pop rbx, e ret retirará o rbx salvo da pilha e saltará para ele como se fosse um endereço. O programa trava com uma falha de segmentação e não imprime nada, então o teste mostra uma saída vazia.
Um pop extra também causa problemas: ele remove o endereço de retorno da pilha, e ret salta para o que estiver abaixo dele. O mesmo acontece com um desvio que salta para ret sem passar por um pop. Todos os caminhos por um procedimento precisam ter tantos pops quanto pushes.
Quando um teste não imprime nada, verifique cada procedimento: siga todos os caminhos até o ret e conte os pushes e pops em cada um deles.
Desafio
FácilO add_tax inicial deve retornar rdi + rdi / 10 em rax (o preço mais 10 por cento de imposto, arredondado para baixo), mas o programa trava e não imprime nada. Encontre o push que não tem um pop correspondente e corrija a função auxiliar. solve recebe o preço (de 0 a 100000) em rdi e retorna add_tax(price) em rax.
Exemplo: para a entrada 100, o programa imprime 110.
Escreva seu código em solution.asm. O main.asm bloqueado lê a entrada, chama solve e imprime o número em rax.
Experimente você mesmo
bits 64
section .bss
input_buffer resb 256
output_buffer resb 32
values resq 4
section .text
global _start
extern solve
_start:
xor eax, eax
xor edi, edi
mov rsi, input_buffer
mov edx, 255
syscall
test rax, rax
jle .loaded
mov rsi, input_buffer
lea rdi, [input_buffer + rax]
xor ecx, ecx
.scan:
cmp rsi, rdi
jae .loaded
cmp ecx, 4
jae .loaded
movzx eax, byte [rsi]
cmp al, 32
jbe .space
mov r10, 1
cmp al, '-'
jne .number
mov r10, -1
inc rsi
.number:
xor eax, eax
.digit:
cmp rsi, rdi
jae .store
movzx edx, byte [rsi]
cmp dl, '0'
jb .store
cmp dl, '9'
ja .store
imul rax, rax, 10
sub edx, '0'
add rax, rdx
inc rsi
jmp .digit
.store:
imul rax, r10
mov [values + rcx * 8], rax
inc ecx
.space:
inc rsi
jmp .scan
.loaded:
mov rdi, [values]
mov rsi, [values + 8]
mov rdx, [values + 16]
mov rcx, [values + 24]
xor eax, eax
call solve
lea rsi, [output_buffer + 31]
mov byte [rsi], 10
mov ecx, 1
xor r8d, r8d
test rax, rax
jns .positive
mov r8d, 1
neg rax
.positive:
mov r9d, 10
.convert:
xor edx, edx
div r9
add dl, '0'
dec rsi
mov [rsi], dl
inc ecx
test rax, rax
jnz .convert
test r8d, r8d
jz .write
dec rsi
mov byte [rsi], '-'
inc ecx
.write:
mov edx, ecx
mov eax, 1
mov edi, 1
syscall
.exit:
mov eax, 60
xor edi, edi
syscallEsta lição inclui um quiz rápido. Comece a lição para respondê-lo e acompanhar seu progresso.
Todas as lições de Funções, pilha e strings
1A pilha
PUSH e POPÚltimo a entrar, primeiro a sairSalvando um registradorLendo com [rsp]Revisão: histórico de desfazer4Quadros de Pilha e Recursão
Variáveis locaisQuadros com RBPRecursãoDuas chamadas recursivasRevisão: soma dos dígitos2CALL e RET
CALL e RETEscrevendo uma função auxiliarChamadas aninhadasUma pilha que precisa estar equilibradaRevisão: preço do pedidoPratique por conta própria: Playground de Assembly