Ein Stack, der ausgeglichen bleiben muss
Teil des Abschnitts Funktionen, Stack und Zeichenketten der Assembly-Journey von Coddy. Lektion 9 von 33.
ret weiß nicht, woher es gekommen ist. Es entfernt das oberste Element vom Stack und springt dorthin. Eine Prozedur muss den Stack also so hinterlassen, wie sie ihn vorgefunden hat: Wenn ihr ret ausgeführt wird, muss die Rücksprungadresse oben liegen.
Ein Register innerhalb einer Hilfsfunktion zu sichern, ist in Ordnung, wenn es vor ret wiederhergestellt wird. Diese Hilfsfunktion verwendet rbx als Divisor und stellt es wieder her:
; 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
retLösche pop rbx. ret nimmt dann stattdessen den gespeicherten Wert von rbx vom Stack und springt zu ihm, als wäre er eine Adresse. Das Programm stürzt mit einem Segmentierungsfehler ab und gibt nichts aus, daher zeigt der Test eine leere Ausgabe.
Ein zusätzliches Pop bringt den Ablauf ebenfalls durcheinander: Es nimmt die Rücksprungadresse vom Stack, und ret springt zu dem, was darunterliegt. Dasselbe gilt für einen Zweig, der nach einem Pop zu ret springt. Jeder Pfad durch eine Prozedur benötigt genauso viele Pops wie Pushes.
Wenn ein Test nichts ausgibt, überprüfe jede Prozedur: Verfolge jeden Pfad bis zu seinem ret und zähle die Push- und Pop-Operationen darauf.
Aufgabe
EinfachDie Funktion add_tax im Startcode sollte rdi + rdi / 10 in rax zurückgeben (einen Preis plus 10 Prozent Steuer, abgerundet), aber das Programm stürzt ab und gibt nichts aus. Finde den Push-Befehl ohne passenden Pop-Befehl und korrigiere die Hilfsfunktion. solve erhält den Preis (0 bis 100000) in rdi und gibt add_tax(price) in rax zurück.
Beispiel: Bei der Eingabe 100 gibt das Programm 110 aus.
Schreibe deinen Code in solution.asm. Die gesperrte Datei main.asm liest die Eingabe ein, ruft solve auf und gibt die Zahl in rax aus.
Probier es selbst
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
syscallDiese Lektion enthält ein kurzes Quiz. Starte die Lektion, um es zu beantworten und deinen Fortschritt zu speichern.
Alle Lektionen in Funktionen, Stack und Zeichenketten
1Der Stack
PUSH und POPZuletzt hinein, zuerst herausEin Register sichernLesen mit [rsp]Rückblick: Rückgängig-Verlauf4Stack Frames und Rekursion
Lokale VariablenFrames mit RBPRekursionZwei rekursive AufrufeRückblick: Ziffernsumme2CALL und RET
CALL und RETEine Hilfsroutine schreibenVerschachtelte AufrufeEin Stack, der ausgeglichen bleiben mussRückblick: PreisbestimmungÜbe selbstständig: Assembly-Playground