Willst du nicht gaanz lieb 
sein und mir den Frame-Pointer erklären? 
Wow - this machine is really fast - it executes an infinite loop in less than 5 seconds!
Also ich find den framepointer ganz gut erklärt im skript, wie das jetzt aba genau funktioniert weiß ich auch nimmer, is schon so lang her ;(
also ich verstehe den Sinn eines Frampointers schon, glaube ich - bin mir aber nicht ganz sicher (deswegen poste ich mal dazu noch nichts - nicht dass ich hier unwahrheiten verbreite).
Was mich aber interessiert ist folgendes:
main:
pushl %ebp
das ist jeweils die erste Zeile in nem ausführbaren Programm. Das bedeutet doch eigentlich, dass zu Beginn eines jeden Programms der Inhalt des ebp gleich dem Inhalt des esp sein muss. sonst würde doch nach diesem push ne falsche adresse aufm stack stehn. Das wiederum bedeutet doch, dass jedes terminierende Programm den ebp auf den aktuellen esp setzen muss. Oder geschieht das automatisch?
achja: gibts irgendwo Lösungen zu den alten Klausuren?
Moin!
Ähm, wie kommt man auf die 5 Bit / 13 Bit / 16 Bit in Aufgabe 2? Weiß des niemand, oder is es zu trivial?
Da WELL '4
die5 - keine Ahnung, aber die anderen sind dann
c) 5 + 8 = 13 (Weil das displacement 8 bit braucht für 256 versch. Zahlen)
und
d) 1(ka, warum, ich lerns mal auswendig :o) ) + 15 (naja, 2[sup]16[/sup]-1 = (Σ[sub]i=0[/sub][sup]n[/sup])2[sup]15[/sup], also 15 Bit wenn alles Einsen sind)
=16 Bit Schulterzuck
ich würde es auch gerne genau wisse und habe auf Antwort von jmd qualifizierten gehofft - das mit den Zahlen bekomm ich ja noch hin, aber woher soll ich wissen mit wievielen Bit die Adressierungsarten codiert werden oder ob das Flags sind oder wie auch immer…?
zur 2)
a) “Register” → Als Operand muss Register codiert sein… Es gibt 32 Stück davon. Also brauch man log2(32) = 5 bits
b) “Register Indirect” → Die Art (also “indirekt”) wird in der Instruktion und nicht im Operanden codiert. Es muss also wir in a) nur das Register codiert werden → 5 bits
c) 5 bits für Register, klar. Displacement kann (127 - (-128) + 1) = 256 Werte annehmen → log2(256) = 8 bits. Also igs. 5 + 8 = 13 bits
d) Operand muss direkt codiert werden. Es gibt (2^16 - 1 - 0 + 1) = 2 ^ 16 Möglichkeiten. log2(2^16) = 16. Also 16 Bits benötigt.
Die nächste Teilaufgabe ist aber glaub ich NICHT so trivial, wie im ersten Post zu lesen… Denn als Immediate Operand kann man ja laut d) nur Werte von 0 … 2^16 (also 2 Bytes) übergeben. D.h. man kann $0x12345678 nicht direkt übergeben. (sind ja 4 Bytes). Was denkt ihr ?!?
Danke erst mal!
aber warum rechnest du bei d) nochmal eins dazu? 15 Bits liefern ja genau die Anzahl Werte die wir brauchen?
Anm.: Ich glaub ich habe "von 0 bis 2^16 anders interpretiert - dann stimmts wieder :o)
Bei der nächsten:
Wie wärs zur Umgehung mit:
movw $0x1234 , %r1
shll $4 , %r1
addl $0x5678 , %r1
movl (%r1) , %r0
Aber gute Denke, der Einwand, richtig fieselig die Aufgabe…
Tschuldigung wenn ich mich einmische aber da weiß ich glaub ich auch was.
das geht glaubich mit sethi und setlo.
sethi $0x1234, %r1
setlo $0x5678, %r1
movl (%r1), %r0
allgemeine Formel: Anzahl = Obergrenze - Untergrenze + 1
d.h. bei Werten von 0 … 2^16 - 1 => Anzahl = (2^16 - 1) - 0 + 1 = 2^16
die Idee mit dem shiften und addieren ist gut 
sethi und setlo kam in der Vorlesung aber auch mal vor…
Aufgabe 5
21 ggt:
22 movl 8(%esp), %eax # a in %eax
23 movl 4(%esp), %ebx # b in %ebx
ich habe da:
movl 4(%esp), %eax #a ins %eax
movl 8(%esp), %ebx #b ins %eax
das b wird doch zuerst auf den stack gelegt, da der compiler doch am anfang schaun, muss wieviele parameter überhaupt da sind, oder hab ich da was falsch verstanden…?
im Allgemeinen werden die Parameter von hinten nach vorne auf den Stack gepusht. D.h. letzter Parameter zu erst. Das ist aber nur Konvention, d.h. man muss sich nicht dran halten… Macht halt die Funktion unportabel, wenn man sich nicht dran hält. Aber solange die (rekursive) Funktion das richtig handhabt, sollte es eigentlich in Ordung sein.
Der Compiler hat da denke ich weniger was mit zu tun, der hält halt die Konventionen ein, und hofft, dass der erste Parameter wirklich im Stack an den kleineren Adressen, und der letzte an den größeren Adressen zu finden ist…
Der Stack wird doch von hinten nach vorne beschrieben(also bei 80x86)
Sollten dann nicht, wenn der letzte Parameter zuerst gepusht wird, der an der größten Adresse stehen und der erste an der niedrigsten(also am nächsten am Stack-Pointer dran)?
Oder hab ich dich jetzt falsch verstanden?
hab ich doch so geschrieben, oder ?!? der erste an der kleinsten ( = niedrigsten = am Stackpointer) und der letzte an der größten Adresse
:wand:
Zuviel Lernen macht blöd im Kopf - lasst euch dass eine Warnung sein!
Du hast es tatsächlich genau so geschrieben, ich hab das nur ein bisschen im Kopf hin und her geschubst bis es umgefallen ist… Und beim wieder aufstellen hab ichs dann falschrum aufgebaut :rolleyes:
