Hey Leute,

hat jemand die Aufgabe 36 schon gelöst?
Ich hätte ein paar Fragen…

1. Wieso benutzt er das Register %sp, wenn da gar nichts gespeichert ist?

2. Wieso werden %i Register benutzt?

3. Da keine Werte definiert sind, sind dann alle Register von vornerein 0?

Bin für jede Hilfe dankbar…. :)

1. Wieso benutzt er das Register %sp, wenn da gar nichts gespeichert ist?

In %sp ist der Stackpointer gespeichert.

2. Wieso werden %i Register benutzt?

Weil es sich um ein Unterprogramm handelt, dass von einem save und einem ret/restore umgeben ist. Das save benennt die %o-Register in %i um und stellt neue %l und %o Register bereit.

3. Da keine Werte definiert sind, sind dann alle Register von vornerein 0?

In %i stehen nach dem save die Argumente, die der Aufrufer in die (aus seiner Sicht) %o-Register abgelegt hatte.

Siehe Skript Seite 14/27 rechte Folie "Normaler Prolog und Epilog für Routinen".

Wie kann ich "and" formeltechnisch deuten?

Das normale "bitweise und".
and src1, src2, dst Jedes Bit in dst ergibt sich durch "bitweise und"-Verknüpfung der entsprechenden Bits in src1 und src2. Beispiel für 8-Bit-Zahlen:
10100101 01110110 -------- 00100100

Vielen Dank Fred… :)


Mein Versuch die Aufgabe 38 zu lösen funktioniert leider nur teilweise… Ich vermute es liegt irgendwie an dem Format (bei mir WORD), denn bis zur Zahl "9" zieht er die korrekte Wurzel!?

! Information für Binder
.global main
.global printf

! Deklaration von Daten
.select ".data"
x: .word 16
fmt: .asciz "Ergebnis: %d\n"

! ausführbares Programm
.select ".text"

main: set x,%l0 ! Die gewünschte Zahl ins das Register l1 laden
ld [%l0],%l0
mov %l0,%l1 ! x in l1
srl %l1,1,%l1 ! x / 2 in l1 XALT
mov %l1,%l2 ! x/2 in l2
udiv %l0, %l2, %l3 ! x/(x/2) in l3
add %l2,%l3,%l2 ! x/2+x/(x/2) in l2
srl %l2,1,%l2 ! (x/2+x/(x/2))/2 in l2 XNEU
cmp %l1,%l2
be ende
nop

schleife: mov %l1, %l4 ! Xalt in l4 –> wird neues Xneu
mov %l2, %l5 ! Xneu in l5–> ist jetzt neues Xalt
udiv %l0, %l5, %l6 ! x/xalt in l6
add %l4, %l6, %l4 ! xalt +x/xalt in l4
srl %l4, 1, %l4 ! (xalt+x/xalt)/2 in l4 –>neues xneu
mov %l5, %l1
mov %l4, %l2







cmp %l1, %l2
bne schleife
nop

ende: mov %l2, %o1
set fmt,%o0
call printf
set 1,%g1
ta 0


Wenn jemand lust hat, kann er ja mal schauen, wo mein Fehler liegen könnte…. :) :)

Gruß an alle!

Die Aufgabe soll mit Gleitkommazahlen gelöst werden, nicht mit Ganzzahlen:

double sroot (double x)

Ich habe irgendwie immernoch ein paar grundlegende Probleme logische Operationen richtig zu interpretieren. Ich weiss zwar, was diese bedeuten und wie sie bittechnisch funktioneren, aber ich komme irgendwie noch nicht so ganz klar, was das nun in einem bestimmen Kontext zu bedeuten hat, wo ich nicht direkt mit Bits arbeite. Konkret in dieser Aufgabe gibt es ja z.B. den sra-Befehl, welcher eine arithmetische Rechtsverschiebung angibt. Aus verschiedenen Quellen weiss ich zwar, wie diese bitweise aussieht, aber was heisst das jetzt wenn man mit Variablen und im Dezimalsystem arbeitet bzw. was geschieht da jetzt konkret in dieser Aufgabe und welchen Nutzen hat das Ganze überhaupt? Wenn das in der Vorlesung irgendwann schonmal dran war ist das irgendwie an mir vorbei gegangen.

Die and frage bezog sich auf selbiges wie vom Anonymen User über mir. Den sra Befehl kann ich ja mit x*2^n interpretieren, aber wie arbeite ich mit variablen und and? Einfach ein and in die Formel einsetzen?

ich komme irgendwie noch nicht so ganz klar, was das nun in einem bestimmen Kontext zu bedeuten hat, wo ich nicht direkt mit Bits arbeite.

Was genau meinst Du damit? Man arbeitet doch immer mit Bits. Ein Register ist nichts anderes als eine Kette von 32 Bits.

was heisst das jetzt wenn man mit Variablen und im Dezimalsystem arbeitet

Vorsicht, es gibt keine "Variablen im Dezimalsystem". Alles wird im Rechner binär gespeichert und verarbeitet.

Der Assembler (und jede mir bekannte Hochsprache) unterstützt den Programmierer aber zum Glück bei der Erzeugung von Bitketten, indem er beispielsweise aus der Sequenz der Zeichen '1', '2' und '3' (drei Zeichen, die ein Mensch in dieser Kombination auftretend für gewöhnlich als "Hundertdreiundzwanzig" bezeichnet) die Bitkette 1111011 generiert.

Probier den sra31-Befehl doch einfach mal mit ein paar Zahlen aus. Fällt Dir dabei etwas auf?

Dass ich im Endeffekt immer mit Bits arbeite ist mir natürlich schon klar, wo ich eigentlich eher drauf hinaus wollte ist, dass mir das umdenken immer ein wenig schwer fällt und ich daher nicht immer sofort weiss, was jetzt solch ein Befehl für Auswirkungen hat, wenn ich ihn benutze.

Probier den sra31-Befehl doch einfach mal mit ein paar Zahlen aus. Fällt Dir dabei etwas auf?

Also nach ein paar Testläufen mit dem sra-Befehl fällt mir auf, dass es gerade eine Division ohne Rest um 2^n ist, wobei n der Wert ist um den verschoben wird (also bei n = 3 beispielsweise eine Division durch 8).

mach dir doch erstmal klar was sra überhaupt bedeutet.. sra ist doch ein bestimmter shift nach rechts um 31 bit

Huhu, melde ich mich auch mal:
Also so wie ich das verstanden habe, ist wird beim sra das Vorzeichen behalten, was ganz vorne steht, und die frei werdenden positionen damit aufgefüllt. Dieses kann nur 0 (positiv) oder 1 (negativ) sein. Nun ist das Register aber nur 32 Bit lang, d.h. Vorzeichen +31. Schiebt man nun um 31 Stellen hat man alles rausgeschoben was darin war. Danach steht im Register entweder -1 (alle 32 Bit 1en) oder 0 (32 0en). Was das aber in dem Zusamenhang bringt is mir auch n Rätsel…

Also das hab ich so aus dem Queltext verstanden:
zuerst wird berechnet: n²
dann (n+1)²
dann beides zusammenmultipliziert. Wenn das Ergebnis negativ ist (es also einen Speicherüberlauf gegeben hat, da x² immer positiv ist, wie zb (-1)² = 1), wird 3 daraufaddiert, wenn nicht passiert nichts. Und am Ende wird das ganze durch 4 geteilt und zurückgegeben.

Hoffe das stimmt so weit, aber was das bringen soll ka, und weiss evtl jemand was mit diesem "Kompakt-Ausdruck" gemeint sein soll?

Was bedeutet "xneu hinreichend verschieden von xalt" ?

@Anonym 17:47
Ist nach meiner Auffassung alles sinnvoll und korrekt, was Du da schreibst!

durch die while schleife näherst du xneu ja immer weiter xalt an.. komplett gleich werden sie aber nie.. nun ist halt nur noch die frage welche näherung wir als gleich betrachten sollten… also ob wenn die ersten 5 nachkommastellen gleich sind es ausreichend ist…

Hmm in A36 is dann wohl diese Assembler Ausdrucksschreibweise gemeint oder?
Hab da jetzt einfach alles aneinander geklebt:
((n*n*(n+1)*(n+1))+(((n*n*(n+1)*(n+1))>>31)&3))/4

Könnte das im Sinne der Aufgabenstellung stimmen?
Und gibts für den arithmetischen Shift noch was Besonderes? Im Script steht da ja nur nen herkömmlicher Shift-Befehl in Kurzschreibweise.

Ahja und 37 läuft juhu ^^

Hätte ne kleine Frage zu 38:

Wie kann man printf vermitteln, dass es ne Gleitkommazahl ausgeben soll?
Hab gegoogelt und herausgefunden, dass dies mit %f möglich ist.
Nun die Frage: wo erwartet printf diese Gleitkommazahl, die über 2 Register geht?
Meine Vermutung ist ja:

(iv) Die Fließkommaregister %f0 und %f1 werden im
"Application Binary Interface" ABI nur zur
Rückgabe von Fließkommawerten genutzt.

Weiss das jemand zufällig?

wo erwartet printf diese Gleitkommazahl, die über 2 Register geht?

%o1 und %o2.

Warum funktioniert folgendes nicht?

fsqrtd %f6, %f6

mov %f6, %o1
mov %f7, %o2

…. printf

als fehler für die mov anweisungen bekomme ich "invalid register" geworfen

Steht im Skript auf der drittletzten Folie:

! Es existieren keine Befehle, die Inhalte von
! Ganzzahlregistern in Fließkommaregister
! und umgekehrt transportieren.

Der mov-Befehl (bzw. der darunterliegende or-Befehl) speichert seine Operanden in 5 Bit, womit zwischen 32 verschiedenen Registern unterschieden werden kann. Da ist leider kein Platz für die %f-Register. Also bleibt nur der Umweg über den Speicher.

Ahja und 37 läuft juhu ^^

Könntest du vielleicht einen kleinen Tipp geben? War leider nicht in den Vorlesungen und weiss jetzt nicht, ob es für solche Vertauschungsgeschichten extra handliche Befehle gibt oder ob ich das umständlich realisieren muss(und auch hier fragt sich, omg - wie).

Dank im vorraus.

Hat Jemand eine Ahnung warum mir folgender Code, als Ergebnis 2.837793e+04 und nicht 5 liefert?

[php]
! Aufgabe 38

       .global main                                    
     .global printf

       ! Deklaration von Daten                        
       .section ".data"            
       .align 8        
wert: .single 0r25.0                
fma:   .asciz   "Wurzel mit fsqrtd: %e\n"! - Wurzel mit Newton-Raphson: %e\n"
                                                
       ! Programm
                                            
       .section ".text"
       .align 8
      
newton:
                                                      
main:   /* Inhalt von Ganzzahlregister in Fließkommaregister transportieren */
set wert, %l1
ld [%l1], %f2

/* Wurzel mit fsqrtd berechnen */
fsqrtd %f2, %f4

std %f4, [%l1+8] ! 2 Register gespeichert.
ld [%l1+8], %o1
ld [%l1+12], %o2

/* Ausgabe */
set fma, %o0
call printf
nop

!Rückkehr
mov 1, %g1
ta 0
[/php]

weiss jetzt nicht, ob es für solche Vertauschungsgeschichten extra handliche Befehle gibt

Wir reden über RISC, da gibt es keine redundanten Befehle.
Also back to the basics. Wie isoliert man einzelne Bits aus einer Bitkette?

Hat Jemand eine Ahnung warum mir folgender Code, als Ergebnis 2.837793e+04 und nicht 5 liefert?

Ganz einfach. Du lädst einen single in %f2, interpretierst dasselbe Bitmuster dann aber als double, weil Du die Wurzel auf einem double in %f2 und %f3 berechnest (in %f3 steht auch nur Käse drin, aber das ist nicht so wild).

Die basics sind leider auch nicht so locker. Mir würde es schon sehr helfen, wenn ich wüsste, wie genau folgende Befehle funktionieren:

*btst          reg1, reg2                     !Bittest: ist reg1 in reg2?
*btst          const13, reg2                  !Bittest: ist const13 in reg2?
*bset          reg1, reg2                     !Setze Bit reg1 in reg2
*bset          const13, reg2                  !Setze Bit const13 in reg2
*bclr          reg1, reg2                     !Lösche Bit reg1 in reg2
*bclr          const13, reg2                  !Lösche Bit const13 in reg2
*btog          reg1, reg2                     !Vertausche Bit reg1 in reg2
*btog          const13, reg2                  !Vertausche Bit const13 in reg2

Das sieht alles sehr interessant und brauchbar aus, aber die Erklärung dazu will mir nicht einleuchten. Wie steuere ich das bit denn an? Nehmen wir mal btst - welche bits werden da getestet? Wie erfahre und nutze ich das Ergebnis? Mit einem Register mehr in der Syntax wäre das ganze viel toller.

Sagen wir wir haben die Bitkette  000110101. Wie nutze ich da bset? Muss das erste Register dann 010000000 beinhalten, was dann in 000110101 reingesetzt wird und zu 010110101 wird?

Die basics sind leider auch nicht so locker.

Denk erst mal nicht an die Sparc. Was hast Du bisher über bitweise Arithmetik gelernt?
Nehmen wir mal eine beliebige Bitkette der Länge 8:
abcdefgh Hast Du keine Idee, wie Du da an ein bestimmtes Bit rankommst, z.B. Bit c? Noch eine kleine Hilfe:
abcdefgh ???????? -------- 00c00000 Welche Operation wird hier durchgeführt, und wie muss der zweite Operand "????????" aufgebaut sein?

Mir würde es schon sehr helfen, wenn ich wüsste, wie genau folgende Befehle funktionieren:

Dann schau doch einfach im Manual auf Seite 86 nach. Da steht exakt, was diese synthetischen Befehle bewirken (wie kommst Du eigentlich gerade auf die?).

Hilfe:
abcdefgh ???????? -------- 00c00000 Welche Operation wird hier durchgeführt, und wie muss der zweite Operand "????????" aufgebaut sein?

Ich tippe auf "Verodern" mit einer Null-Kette.-
Wäre es evtl denkbar, die Vertauschung durch Rechenoperationen durchzuführen ?
Etwa: "ursprüngliche bitkette" - ("bit an posa" * 2 hoch a") + ("bit an pos a" * "2 hoch b")
+ ("bit an posb" * "2 hoch a") - ("bit an posb" * " 2 hoch b"), oder so ähnlich…

Verodern bringt doch nichts? "a oder 0" gibt doch a. Verodern mit einer 0-Kette hat überhaupt keinen Effekt, oder hab ich das oder falsch verstanden?

Ich würde sagen man muss eine und Operation durchführen, während die c Stelle bei der zweiten Kette eine 1 sein muss.

abcdefgh
00100000 und
——–
00c00000

wäre das richtig?

Ich tippe auf "Verodern" mit einer Null-Kette.

Ziemlich unwahrscheinlich, weil "x oder 0" immer noch x ist.

EDIT: Anonymer User hat's gecheckt.

ja stimmt natürlich, hab ich grad verwechselt

Ah, das war richtig ;D. Naja, egal. Ich habe das isolieren bereits durch shifts gelöst. Wenn das andn bzw bclear jetzt so funktioniert, wie ich mir das denke, dann habe ich die aufgabe(wahrscheinlich viel zu aufwendig) gelöst. Ein jammer, dass ich sie jetzt nicht compilieren und ausprobieren kann .-. (blöde portsperre).

so 38 naja, da der Subtraktionsbefehl fsubd, der Vergleichsbefehl fcmpd oder der Branch fbl die Quellregister zu zerschiessen scheint, lass ich das mal mit dem "hinreichend verschieden" und mach stattdessen feste 10 Durchgänge. Das reicht ja in jedem Fall, zumal printf ja auch nur 6 Nachkommastellen genau ausgeben kann…

Stimmt das wirklich? ^^

Ich bekomme bei aufgabe 37 immer den folgenden fehler:

Undefined                       first referenced symbol                             in file i0                                  aufgabe37.o ld: fatal: Symbol referencing errors. No output written to a.out Was kann das sein?

ohne die Datei gesehen zu haben…
er kennt i0 nicht. meintest du vielleicht Register _%_i0?

Tatsache - ich hatte nur ein % vergessen. Danke!

da der Subtraktionsbefehl fsubd, der Vergleichsbefehl fcmpd oder der Branch fbl die Quellregister zu zerschiessen scheint

Das ist definitiv nicht so.

zumal printf ja auch nur 6 Nachkommastellen genau ausgeben kann…

Du kannst so viele Nachkommastellen ausgeben, wie Du willst, 6 ist nur eine Voreinstellung. Z.B. liefert die Ausgabe von fsqrtd(10) mit 50 Nachkommastellen:
3.16227766016837952278706325159873813390731811523438 Der entsprechende Formatstring lautet "%.50f"

Wobei es natürlich sinnlos ist, mehr als 16 signifikante Stellen auszugeben - mehr Genauigkeit gibt double halt nicht her.

Wenn das andn bzw bclear jetzt so funktioniert, wie ich mir das denke,

Bekommt man bei Verwendung von andn micht Probleme, wenn die zu
vertauschenden bits gleich belegt sind?
Mag natürlich auch sein, das ich deine Lösungsidee falsch erahne.

Anbei meine Lösungsvorschläge für die Aufgaben 37 und 38.