Eine kleine einfache frage Allgemeine defi der Befehlsformate ist zb add rs1, rs2 rd
Das rd register ist doch das register wo dann das Ergebnis gespeichert wird oder?
Weil gleichzeitig ist rd doch auch der Befehl für read ?!?!?!

Das rd register ist doch das register wo dann das Ergebnis gespeichert wird oder?

Ja. Wobei "rd" nur ein Platzhalter für ein echtes Register ist, also %l5 oder %i2 oder %o4 oder…

Du heißt ja z.B. auch nicht "Dein Name" [25]

so habe ich es mir gedacht :)
http://www.informatik.uni-hamburg.de/TKRN/world/abro/RS/rsk05ws07.pdf
Seite 8 der Abschnit zu dem y register .
Da steht rd doch für read oder ?

Im Sparc V8 Manual findest Du auf S. 108 eine Beschreibung von ADD: "ADD and ADDcc compute “r[rs1] + r[rs2]” if the i field is zero, or “r[rs1] +sign_ext(simm13)” if the i field is one, and write the sum into r[rd]." Deswegen schreibt Herr Lehmann auch "add rs1, rs2/imm13, rd".

Und jo, beim y-Register musste man ja mit rd lesen, und zwar analog zu "rd, %y, rd" wobei das letzte rd für ein Register steht ;)

Zumindest habe ich mir das so gedacht….

und weiter geht es mit denn fragen:) ich habe folgenden code ausschnit
cmp %i5 ,12 /%i5 = 8
ble schleife

Meine fragen sind habe ich immer wenn ich Bedingte Sprungbefehle habe vor diese cmp?
Oder kann ich auch ohne cmp ein bedingten Sprungbefehl haben?
Mir ist nicht ganz klar was da verglichen wird also cmp vergleict doch schon 8 mit 12 und ble
und ble sagt dann was geamcht werden soll wenn es kleiner oder gleich ist oder?

Meine fragen sind habe ich immer wenn ich Bedingte Sprungbefehle habe vor diese cmp?

Macht doch Sinn, oder?

Oder kann ich auch ohne cmp ein bedingten Sprungbefehl haben?

Ich habe in diesem Fall "call" genutzt. Gibt sicher eleganteres ;)

Mir ist nicht ganz klar was da verglichen wird also cmp vergleict doch schon 8 mit 12 und ble
und ble sagt dann was geamcht werden soll wenn es kleiner oder gleich ist oder?

Genau! "cmp %i5 ,12" vergleicht den Inhalt von Register %i5 mit 12; wenn in %i5 eine 8 ist, dann ist das ganze kleiner, also wird zu schleife gegangen.

Die Angaben sind ohne Gewähr, da ich Assembler auch grad erst kennen gelernt habe und Lehmanns Skript nicht so der Hit für Neulinge ist :)

Zusatz: "call" ruft immer auf, ist also kein bedingster Sprungbefehl sondern ein Aufruf ohne wenn und aber.

Hat einer das mit denn delay slots und dem annulling verstanden?Was dei schleifen verbessern soll?
Immer noch skript 5 seite 12 ?

Oder kann ich auch ohne cmp ein bedingten Sprungbefehl haben?

Ich habe in diesem Fall "call" genutzt. Gibt sicher eleganteres ;)

soweit ich informiert bin verwendet man 'call' wenn man eine subrutine aufruft, also auch die register verschieben will (was man dann aber auch noch selbst machen muss) und branch für schleifen, und if-then-else-konstrukte.
es gibt auch einen branch-always, der keine bedingung überprüft.
ausserdem ist ein compare eigentlich nur eine subtraktion die die flags setzt und das ergebnis ignoriert.
man kann auch mit anderen operationen die flags setzen, und anschliessend zum bedingten branchen nutzen.

@Syntax: Ich denk mir das so:
rs = Register Source = Quelle
rd = Register Destination= Ziel

habe ich immer wenn ich Bedingte Sprungbefehle habe vor diese cmp?

Nein, muss nicht, sollte aber. Denn…

Oder kann ich auch ohne cmp ein bedingten Sprungbefehl haben?

Klar, der Befehl wird immer ausgeführt. Nur ist das Ergebnis dann nicht unbedingt vorhersagbar bzw. etwas schwieriger zu ermitteln.*

Mir ist nicht ganz klar was da verglichen wird also cmp vergleict doch schon 8 mit 12 und ble
und ble sagt dann was geamcht werden soll wenn es kleiner oder gleich ist oder?

Siehe Skript (die Branches-Seite). Es werden die "Flags" verglichen. Z.B: bl (Branch Less) prüft wenn ich das jetzt richtig rekonstruiere, ob das Ergebnis negativ, also N gesetzt ist. Ebenso werden Carry, Valid und Zero sowie Kobinationen davon geprüft.

*Das cmp setzt dabei das Carry-Flag, welches mit be (C=0) abgefragt wird. Alternativ lässt sich das Flag auch mit addcc o.ä. setzen! (wie T bereits erwähnte)

cmp a, b
ist nur ein synthetischer Befehl. Er wird vom Compiler zunächst übersetzt in:

subcc a, b, %g0
Also: ziehe b von a ab, verwirf das Ergebnis (schreiben in %g0 bewirkt ja nichts) und beeinflusse die Flags (wegen dem cc).

Werden alle Befehle die direkt nach einem Branch befehl stehen eigentlich vor dem Brach befehl aus gefürt?
Also
ba sende
cmp %i5 ,12

Wird erst das cmp ausgefürt?

Jein. Das ganze hängt damit zusammen, dass Befehle in modernen Prozessoren nicht alle nacheinander verarbeitet werden sondern der nächste schon angefangen wird, während der letzte noch läuft. Das resultiert auf der Sparc darin, dass der Befehl nach einem Branch/Sprung/Call-Befehl noch ausgeführt wird, bevor gesprungen wird. Aber(!) der Befehl wird tatsächlich nicht wirklich "vor" dem anderen ausgeführt. Das heißt vor allem: die Entscheidung ob gesprungen wird, wird vor dem cmp entschieden. Nun hast du hier nen ba-Befehl, also Branch Always, da ists natürlich egal. Aber prinzipiell muss der cmp-Befehl immer VOR dem dazugehörigen Branch-Befehl gekommen sein, wenn er die Entscheidung beeinflussen soll.

hab mal ne frage zu der fakultätrechnung, wann wird der smul befehl immer ausgeführt?
[img]http://img181.imageshack.us/img181/5418/assemblerur6.png[/img]

Äh… wenn der Program Counter darauf zeigt? Kannst Du Deine Frage etwas präzisieren?

hab mal ne frage zu der fakultätrechnung, wann wird der smul befehl immer ausgeführt?

wenn in den else zwei gesprungen wird wird
- in o0 die zahl (l1 - 1) gelegt; das ist einer weniger als die funktion grade selbst berechnen will
- fakultät mit eben diesem o0 rekursiv aufgerufen
- dann wird der smul befehl ausgeführt, und zu diesem zeitpunkt befindet sich in o0 schon die fakultät von (l1 - 1).
- jetzt befindet sich in i5 also die fakultät von l1 (eben l1 * fak(l1 - 1))
- und so fort, auf der anderen seite der ende-markierung

wird nicht nur der sub befehl unter dem call befehl ausgeführt? weil ja sofort wieder die fakult-funktion rekursiv aufgerufen wird und die smul-operation nicht?!?!
oder wird nach dem call noch der smul-befehl ausgeführt?

Erst wird sub aufgeführt, dann der Sprung in das Unterprogramm. Wenn das zurückkehrt, wird ganz normal beim nächsten Befehl (smul) weitergemacht.

aber in dem beispiel wird doch dann bei der rückkehr wieder der sub un der call befehl ausgeführt und nicht der smul-befehl.
oder wie ist das gemeint?

vielleicht solltest du dir Rekursion mal deutlich machen. Evtl hilft Wikipedia oder Google!

ich weiss was rekursion ist, aber mich verwirrt diese assembler-sprache.
weil mir heute gesagt wurde, dass bei dem beispiel oben, also Fukul(7) als erstes ausgeführt wird, dann weil %l1 != 0 ist, zu else gesprungen wird.
da wird ja dann Fakul(7-1) ausgeführt, aber wann wird denn bitte das smul ausgeführt, wenn er immer wieder Fakul(n-1) ausführt und dann wenn %l1 ==0 zu ende gesprungen wird?!?!

das geht so:
du sagst A, berechne mir fak(3)
A sagt zu B: berechne mir fak(2)
B sagt zu C: berechne mir fak(1)
C sagt sich: das ist einfach, das ist 1 (sprung nach ende)
C sagt zu B: das ist 1
B sagt sich: aha dann smul ich mal die 1 mit meiner 2 und
B sagt zu A: das ist 2
A sagt sich: aha dann smul ich mal die 2 mit meiner 3
A sagt dir: 6

bis zum sprung ist das der rekusionsabstieg, dort das rekursionsende, dannach der rekursionsaufstieg.
und beim aufstieg wird smul ausgeführt. für jede ebende einmal.

kann jemand nicht für das erste mal durch gehen nummern an denn code schreiben also wann welcher schritt durch gefürt wird solange bis jede code zeile einmal angefast wurde.

solange bis jede code zeile einmal angefast wurde.

Es wird eben nicht jede Codezeile einmal angefasst, sondern (abhängig vom übergebenen Parameter) sehr oft!

Ich habe das mal versucht, grafisch darzustellen, wenn man die Funktion mit dem Parameter 1 aufruft:

[img]http://img529.imageshack.us/img529/3639/assemblerjm2.png[/img]

Man startet ganz oben bei dem roten Pfeil. Da man ja 1 übergeben hat, schlägt der Vergleich mit 0 fehl, und es wird zum else-Teil gesprungen. Dort ruft sich die Funktion nun rekursiv selbst auf, mit 1-1 = 0 als Parameter (das rote Konfetti, das nach oben wandert und dann grün wird).

Jetzt sind wir beim grünen Pfeil. Da wir nun 0 übergeben haben, ist der Vergleich mit 0 erfolgreich, also findet der "bne else"-Sprung nicht statt. Also springen wir per "ba ende" zum Ende. das "jmp %i7+8" springt nun zum smul-Befehl, und das restore lässt den Pfeil wieder rot werden, wenn man so will [23]

Nun werden die letzten vier Befehle abgearbeitet, wodurch wieder zum eigentlichen Aufrufer gesprungen wird (hier nicht dargestellt).

Du kannst ja mal probieren, das ganze für den Parameter 7 durchzuführen. Aber dafür brauchst Du viel Platz und acht verschiedene Farben. Also dann viel Spaß dabei [25]

Wenn wir denn Code mit 7 durch gehen dann laufen wir erst 7 mal oben im Kreis aber es werden doch garnicht unsere zwischen ergebnisse gespeichert ich müsste ja folgende rechung erhalten 7*6*5*4*3*2*1 intuitiv weiss ich das ich ja irgendwie mein Multiplikations ergebnis in %l1 haben müsten unddann immer %o0 immer die zahl -1 dann mal dem Multiplikations ergebnis .aber das klapt irgendwie nicht wenn ich das durch gehe kriege ich immer nur 1 raus :(hahaahh aa

Man hat doch nie mals in smul was anders als 1*1=1 egal mit welcher zahl man das bsp durch geht [12]

Vielleicht hilft es ja, wenn man den Codefluss mal darstellt, das habe ich unter http://kram.triphoenix.de/fakultaet.txt mal versucht. Da wird die Funktion erstmal mit dem Wert 3 aufgerufen (mit 7 wurde mir das Bild einfach zu groß). Dann kommt der Punkt wod ie Funktion sich selbst aufruft, und zwar mit dem Wert 2 (eingerückt), genauso mit 1 und 0. An dem Punkt wo man 0 hat, wird eine 1 zurückgegeben. Die wird dann mit 1 multipliziert und das Ergebnis (1) zurückgegeben. Diese 1 wird dann mit 2 multipliziert und das Ergebnis (2) zurückgegeben. Und letztendlich wird diese 2 dann mit 3 multipliziert und das Ergebnis (6) zurückgegeben und man hat die Fakultät von 3, nämlich 3*2*1=6 berechnet. Das lässt sich genauso auf 7 erweitern.

Man hat doch nie mals in smul was anders als 1*1=1

Doch klar. Am Anfang wird ja die Eingabe n von %i0 nach %l1 gesichert (mov %i0, %l1). Und genau diese Eingabe wird ja in smul mit dem Ergebnis des rekursiven Funktionsaufrufs multipliziert (smul %l1, %o0, %i5). Das smul steht also tatsächlich für n * fak(n-1).

Man hat doch nie mals in smul was anders als 1*1=1 egal mit welcher zahl man das bsp durch geht [12]

Die zwei Parameter von smul sind immer das Ergebnis des Rekursiven aufrufes (in %o0) und der Wert aus Register %l1. In Register %l1 ist immer das drin, womit die Funktion aufgerufen wurde. Also wird fakul(7) aufgerufen wird mit 7 multipliziert, bei fakul(6) mit 6 und so weiter.

die Funktion endet mit i0 = 1, also für den Aufrufer o0 = 1
die folgende Multiplikation multipliziert diese 1 mit l1 = 2, also 2*1

Wiso ist l1=2 ? woher kommt die 2 die ist doch schon längst überschriben oder?[12]

Überschrieben? Nein. Jede Funktion hat ihre eigenen l-Register, das ist ja der Witz an der Sparc.

mm wie meinst du das also hat smul seine eigenen Lokalen register l oder wie?aber woher kommt dan die 2 weil wir smul doch noch nie aufgerufen haben .

nein nicht smul hat eigene Register. Jede Instanz von fakul hat ihre eigenen l-Register, also der äußerste Aufruf hat seine eigenen Register, dann hat der erste Selbstaufruf eigene l-Register etc. Deswegen haben die rekursiven Aufrufe jeweils ihre eigenen l-Register und überschreiben jene des Aufrufenden nicht.

mm wie meinst du das also hat smul seine eigenen Lokalen register l oder wie?

Nein. "save %sp, -104, %sp" verschiebt das Register-Fenster, d.h. die alten %o-Register sind jetzt die neuen %i-Register, und die %l und %o Register sind neue, eigene. In die %l-Register kann nie jemand anders reinpfuschen.
Durch das "restore" am Ende wird wieder zurückgeschoben, d.h. die %i werden jetzt die %o, und unsere bisherigen %l und %o verschwinden im Nirvana.

Kannst ja mal nach "sparc register window save restore" googeln, da findest Du z.B. das hier.

aber woher kommt dan die 2 weil wir smul doch noch nie aufgerufen haben .

Am Anfang steht doch "mov %i0, %l1". Die Eingabe wird also in %l1 gesichert.

mm okay das hört sich logisch an zumindest das jeder neue aufruf seine eigenen register hat.
Aber da ab arbeiten verstehe ich dann nicht wie komme ich dann auf 3*2*1
[9]

fib(3) = fib(2) * 3 = (fib(1) * 2) * 3 = (1 * 2) * 3 = 1 * 2 * 3 = 3 * 2 * 1

mm weis snicht genau was du meinst aber da sollte man die Fakultät berechen und allegemein wie Rekursion und Fakultät aus sieht haben wir verstanden
Aber nicht wie das da nun in dem Code rekursiv aufgerufen wird

Dann nochmal auf Deutsch. Es soll die Fakultät von 3 berechnet werden:

fib(3) = fib(2) * 3

Dazu ruft fib sich selbst rekursiv mit dem Parameter 2 auf:

fib(3) = fib(2) * 3

Und multipliziert das Ergebnis anschließend mit der übergebenen 3:

fib(3) = fib(2) * 3


Und fib(2) funktioniert analog:

fib(2) = fib(1) * 2

Und fib(1) funktioniert analog:

fib(1) = fib(0) * 1


Und fib(0) ist ja 1.