PUSH e POP
Parte da seção Funções, pilha e strings do Journey de Assembly da Coddy. Lição 1 de 33.
A pilha é uma região da memória que seu programa usa para manter valores por pouco tempo. O registrador rsp (o ponteiro da pilha) guarda o endereço do valor no topo da pilha. Quando seu programa começa, rsp já aponta para dentro da pilha.
push coloca um valor de 8 bytes no topo. push rdi primeiro subtrai 8 de rsp e, em seguida, armazena rdi no novo endereço em rsp. A pilha cresce para baixo: cada operação de push move rsp para um endereço menor. Os endereços reais são números longos, por isso os exemplos usam números pequenos.
; rsp = 1000
push rdi ; rsp = 992, rdi é armazenado em 992
push rsi ; rsp = 984, rsi é armazenado em 984pop remove o valor do topo. pop rax copia os 8 bytes no endereço em rsp para rax e, em seguida, adiciona 8 a rsp.
; rsp = 984
pop rax ; rax = o valor de 984, rsp = 992
pop rbx ; rbx = o valor de 992, rsp = 1000Push e pop podem trocar dois registradores sem um terceiro. O primeiro pop retorna o último valor empilhado:
push rdi ; salva rdi
push rsi ; salva rsi no topo
pop rdi ; rdi = o valor anterior de rsi
pop rsi ; rsi = o valor anterior de rdiNesta seção, os desafios chamam seu código da mesma forma que um programa em C chama uma função. O main.asm bloqueado coloca as entradas em rdi, rsi, rdx e rcx, nessa ordem, chama seu solve e imprime o número que você deixa em rax. Cada tarefa informa quais entradas usa. O Capítulo 3 explica o motivo desses registradores.
Desafio
Fácilsolve recebe dois números: o primeiro em rdi, o segundo em rsi. Troque os dois registradores com duas instruções push e duas pop e, em seguida, retorne rdi - rsi em rax.
Exemplo: para a entrada 3 10, o programa imprime 7.
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
syscallTodas 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ígitosPratique por conta própria: Playground de Assembly