Unterprogramme

Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.

Unterprogramme
Álso meine Frage:
Wie geht ihr bei den Assemblerprogrammen an die Unterprogramme ran?
Also normalerweise
subl $…, %esp

addl $…, %esp

(für die lokalen Variablen)

Aber was ist wenn mehrmals das Unterprogramm aufgerufen wird?Wie macht ihr das dann, dass das mit dem Stack hinhaut? :anx:


func:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl -8(%ebp), 4(%ebp)
movl 4(%ebp), %eax
cmp $0, %eax
jle ende
decl %eax
pushl %eax
call func
ende:
movl %ebp, %esp
popl %ebp
ret

Das Beispiel ist natuerlich sinnfrei, aber so siehst du, wie man beliebig tiefe Rekursion erreichen kann bei der Benutzung lokaler Variablen


Ja du machst das mit einem Basepointer.
Was ist wenn zum Beispiel wie bei Fibonacci 2 Unterprogrammaufrufe drin sind und die ergebnisse dann miteinander addiert werden muss.
Hier mal ein Beispiel für den Ggt.Wie mach ich das mit dem ret hier?

[code]

[/code]Ggt: movl 4(%esp), %eax //%eax = a
cmpl %eax, 8(%esp)
jle else1
movl 8(%esp), %ebx
subl %eax, %ebx
pushl %ebx
pushl %eax
call Ggt
addl $8 , %esp
jmp exit

else1: cmpl 8(%esp), %eax
jle else2
mov 8(%esp), %ebx
subl %ebx, %eax
push %eax
push %ebx
call Ggt
addl $8, %esp
jmp exit

else2: mov 4(%esp) , %ecx
addl $8, %esp

exit: mov %ecx, result
ret

siehe KLausuraufgabe 3/03


Ich versteh dein Problem wohl nicht ganz. Es ist egal wie oft die Routine sich selbst aufruft, jede erstellt sich ein eigenes Stackframe und gut ist. Du musst zwischen den Aufrufen nur evtl. Rueckgabewerte, die auf den Stack gelegt wurden, sichern.

Oder missverstehe ich dich vollkommen?

Gruss,
Jonny


Naja , muss halt dann mal selber schaun wie das läuft.Des ist jetzt sch… zum erklären.
Aber merci dir!


die lokalen variablen legst du so an (bzw. reservierst platz fuer sie), wie du es geschrieben hast. und dass das unterprogramm oefter aufgerufen wird, macht nichts, das ist ja gerade der witz am stack. du kannst draufhauen, wieviel du willst, solange er nicht voll ist. und der unterprogrammaufruf funktioniert folgendermassen:

pushl $5 #erster parameter
pushl $2 #zweiter parameter
call unterprog
movl %eax, 1234 #returnwert speichern zur spaeteren weiterverarbeitung
addl $8, %esp #die beiden parameter wieder vom stack hauen

btw: swarsron und ich sind uns uneinig ueber das zurueckgeben des ergebnisses eines unterprogramms: ich behaupte, dass das bei uns (im skript und in der vorlesung) immer ueber %eax erfolgt ist und nicht ueber den stack. stimmt das?


Keine Ahnung!Aber schaut mal auf die fau-informatik-2001.de Seite.
Da haben wir den GG und Max aus den letzten Prüfungen!Schreib dir morgen hab heut keine Zeit