Also folgende Aufgabenstellung:
Aufgabe 32:
Bestimmen Sie die Werte der folgenden Assemblerausdrücke:
186 % ~10, −186 % ~10, 186 % ~(−10), −186 % ~(−10), 0x12345678 << 12 >> 24.

Ich habe überhaupt keinen Plan wie das gehen soll, weil uns auch das ganz gut beigebracht wurde. Kann mir da einer helfen? Mein erster Versuch sieht folgendermaßen aus:

.global main
.global printf

.section ".data"
a1: .byte 0xba !186
a2: .byte 0x0a !10

.section ".text"
main: MOV AX, a1
XOR DX, DX
MOV BX, ~a2
DIV BX

call printf
nop

Ist das richtig?
Anmerkung: Dass, was hinter main steht habe ich irgendwo gefunden und wenn es mir jemand erklären könnte, wäre es auch ganz gut.

Bestimmen Sie die Werte der folgenden Assemblerausdrücke:

Ein Assemblerausdruck ist ein Ausdruck in einem Assemblerquelltext. Diese Ausdrücke sind im Gegensatz zu Hochsprachen allerdings auf Konstanten beschränkt. Du kannst also sowas schreiben wie:
mov (47*11)+(8*15), %l0Hier ist es wichtig zu verstehen, dass diese Ausdrücke während der Übersetzungszeit ausgewertet werden. Es ist dasselbe, als hätte man
mov 637, %l0geschrieben. Klar?

main:   MOV AX, a1
XOR DX, DX
MOV BX, ~a2
DIV BX

AX, DX, BX… das sieht aber gar nicht nach SPARC-Assembler aus, eher nach 16-Bit x86-Assembler.

Wenn Du nicht weißt, wie man die SPARCs von zu Hause aus benutzt, dann schau doch mal hier vorbei.

An dieser Stelle ein paar "Literaturhinweise" von mir.
Aufgabenblatt 9
Skript

Aufgabe 32 (printf benutzen)
Skript Seite 5 / 27 rechte Folie: (vii) Ganzzahlausdrücke
Skript Seite 3 / 27 rechte Folie: 5.2a Ein einfaches Assemblerprogramm
(Man braucht hier im Gegensatz zum Beispiel nur ein %d pro Ergebnis, da die eigentliche Berechnung bereits zur Übersetzungszeit stattfindet.)

Aufgabe 33 (Kontrollstrukturen)
Skript Seite 6 / 27 linke Folie: 5.4 Arithmetische Befehle
Skript Seite 10 / 27 rechte Folie: 5.7 Sprungbefehle

Aufgabe 34 (Y-Register)
Skript Seite 7 / 27 rechte Folie: Ganzzahlmultiplikation
Skript Seite 8 / 27 linke Folie: Ganzzahldivision
Skript Seite 8 / 27 rechte Folie: Lesen und Schreiben des Y-Registers

Aufgabe 35 (Zahlen einlesen)
Seite 13 / 27 linke Folie: Ladebefehle der Ganzzahleinheit
In %o0 steht die Anzahl der Kommandozeilenargumente.
In %o1 steht die Adresse eines Arrays. In diesem Array sind die Startadressen der Parameterstrings gespeichert. Der erste Parameterstring ist der Programmname, der zweite Parameterstring ist für die Aufgabenstellung relevant.
(In der C-Welt heißen diese beiden Größen "argc" und "argv".)

Ich verstehe immer noch nicht wie ich anfangen muss. Die Befehle sind ja klar, aber wie sieht ein vollständiger Quelltext aus, der das Ergebnis liefert? Kannst du es am Beispiel von 186 % ~10 zeigen?

Kannst du es am Beispiel von 186 % ~10 zeigen?

Kannst Du ein Programm schreiben, dass die Zahl 123 auf der Konsole ausgibt? Und zwar wirklich die Zahl 123 und nicht den String "123"? Dann ersetze im Quellcode einfach die 123 durch 186 % ~10 und es sollte genau so funktionieren.

Kannst Du ein Programm schreiben, dass die Zahl 123 auf der Konsole ausgibt?

Moin! Ich befasse mich auch gerade mit der Aufgabe und habe keine Ahnung wie man eine Zahl auf der Konsole ausgibt. Manual und Google helfen leider auch nicht weiter. Könntest du es bitte kurz erklären?
Danke für deine Mühe.

Ich […] habe keine Ahnung wie man eine Zahl auf der Konsole ausgibt. Manual und Google helfen leider auch nicht weiter.

In dem Sparc-Manual steht es nicht drin, weil das erst mal nichts mit dem Prozessor zu tun hat - die Ausgabe einer Zahl ist ziemlich komplex! Wir verwenden deshalb eine Bibliotheks-Funktion namens printf, wie man auch in dem Beispielprogramm im Skript sieht:
! 5.2a ! Ein einfaches Assemblerprogramm ! Informationen fuer Binder .global main .global printf ! Deklaration von Daten .section ".data" a2: .word 41 a1: .half 17 fmt: .asciz "Ergebnis: %d * %d = %d\n" ! Ausfuehrbares Programm .section ".text" main: set a1, %l1 ldsh [%l1], %l1 set a2, %l2 ld [%l2], %l2 set fmt, %o0 ! Erster Operand ! in %o0 smul %l1, %l2, %o3 ! Vierter Operand ! in %o3 mov %l1, %o1 mov %l2, %o2 call printf ! Es wird die C-Routine printf aus stdio.h ! aufgerufen. Eine äquivalente Java-Routine ! printf findet man in java.io.PrintStream. nop mov 1, %g1 ! Rueckkehr ins Betriebssytem ta 0 ! Aufruf mit cc einfach.s ! Ausfuehren mit a.out ! Ausgabe: Ergebnis: 17 * 41 = 697 Wenn Du Dir die Ausgabe anschaust, dann werden offenbar die %d im fmt-String durch konkreten Zahlen ersetzt (das d in %d steht für decimal). Diese Information findest Du in jeder Doku zu printf.

Die Übergabe der relevanten Parameter an printf ist nun wiederum sehr prozessorspezifisch und auf der Sparc zum Glück wunderbar einfach. Die Adresse des Formatstrings landet in %o0, und alle im Formatstring spezifizierten Parameter in %o1, %o2, %o3, … bis maximal %o5.

Wenn Du mehr als 5 Parameter benötigst, wird es kompliziert, aber wir brauchen für die Aufgabe zum Glück nur 5.

In Java gibt es auch seit ein paar Jahren eine statische printf-Methode, kannst ja mal damit rumspielen und die Doku lesen:
int a = 14; System.out.printf("%d und %d sind zwei Zahlen.\n", a, a*a+4);

ich habe deine "SPARC-Aufgaben von zu Hause aus"-Anleitung Punkt für Punkt befolgt, bekomme aber trotzdem wenn ich das "Einfache Assemblerprogramm" kompileren will,

[IMG]http://img243.imageshack.us/img243/3064/unbenannt1dr4.th.jpg[/IMG]

folgende Fehlermeldung :

[IMG]http://img81.imageshack.us/img81/4938/unbenanntgq3.th.jpg[/IMG]

hast du ne Idee, was ich falsch gemacht haben könnte? hello.txt funktioniert einwandfrei.

MfG

hast du ne Idee, was ich falsch gemacht haben könnte?

Wie sind denn die 0x00 Zeichen in Deine Textdatei gekommen? Hast Du den Quellcode aus dem Skript oder aus dem Forum rauskopiert? Bei mir funktioniert beides, aber man weiß ja nie…

Wie groß ist die Textdatei bei Dir? Sie sollte 724 Byte groß sein. Nach dos2unix sollte die Datei nur noch 692 Byte groß sein.

Lade Dir mal XVI32 runter und öffne die Textdatei damit. Mach einen Screenshot davon und poste ihn. Bei mir schaut's folgendermaßen aus:

[img]http://img152.imageshack.us/img152/1175/korrektqs3.th.png[/img]

Und hier kannst Du Dir die Datei genau so runterladen, wie sie bei mir aufm Rechner ist.

Notiz am Rand: Ich sehe gerade, dass beim Transfer der .txt Datei durch WinSCP offenbar die Zeilenumbrüche automatisch konvertiert werden. dos2unix ist dann gar nicht mehr notwendig, allerdings kann der Compiler natürlich nix mit der Endung .txt anfangen. Man kann also entweder .s Dateien übertragen und dann mit dos2unix konvertieren, oder .txt Dateien übertragen und einfach nach .s umbenennen, das müsste auch funktionieren.
Egal, so wie es jetzt in der Anleitung steht, geht es ja auf jeden Fall.

Wie schreibt man denn das alles auf? Muss man für jeden einzelnen Ausdruck ein neues Programm schreiben und man somit für die Aufgabe 32 insgesammt 5 Programme schreiben? Oder geht das auch schneller/anders?

Mach halt c&p

also ich hab mit %d , %d, %d, %d, %d alle in ein Programm geschrieben

Muss man für jeden einzelnen Ausdruck ein neues Programm schreiben

Auf dem Aufgabenblatt steht doch ganz klar, dass es nur ein Programm sein soll. Ruf printf notfalls mehrfach auf, für jeden Ausdruck ein Mal.

Aber wie bereits vorgeschlagen kannst Du auch mit einem einzigen printf-Aufruf schon alle fünf Zahlen auf einen Schlag ausgeben.

Hallo,

ich habe eine Frage zu Aufgabe 34, die nicht ganz klar formuliert ist:

Es sollen 10 Pseudo-Zufallszahlen berechnet/ausgegeben werden.

Welches ist der Wert, der innerhalb der Formel variiert, damit verschiedene Zufallszahlen erzeugt werden? Ist dies A, weil dort ja steht, der Startwert von A ist 1234567?
Und wenn ja, wie soll a für die weiteren Zahlen geändert werden? Z.B. einfach jeweils um 1 erhöhen?

Viele Grüße

a

ich habs so verstanden, dass der 1. Wert für A 1234567 ist.. wenn du dann das nach der Formel ausrechnest ist das Ergebnis was du rausbekommen hast wieder das neue A usw

Es steht ganz eindeutig auf dem Aufgabenblatt:

A = (A*B + C) mod M

Für die ersten vier Zufallszahlen habe ich folgende Werte raus:
1234567,1708064929,3410220300,3371980616

Kann das jemand bestätigen?

Huhu,

hab ne Frage zum Y Register.
Also ich multipliziere :
100000000 mit 10 –> das ergebnis ist 1000000000 .. das ist ja korrekt.. halt kleiner als 32bit
1000000000 mit 10 –> dann weiß ich nicht genau was ich mit der entstandenen Zahl machen soll… so wie ich das verstanden habe sind die unteren 32 bit dann normal zB im %l1, die oberen im %y.
Doch wenn ich jetzt mir nur das %y register anzeigen lasse kommt da 2 raus
und beim %l1 1410065408

Wie gebe ich das richtig aus bzw rechne damit weiter?

so wie ich das verstanden habe sind die unteren 32 bit dann normal zB im %l1, die oberen im %y.

Das ist korrekt.

Doch wenn ich jetzt mir nur das %y register anzeigen lasse kommt da 2 raus
und beim %l1 1410065408

Und das ist genau richtig, hab das z.B. gerade in Haskell mal nachgerechnet:
*Main> 2*(2^32) + 1410065408 10000000000

Wie gebe ich das richtig aus bzw rechne damit weiter?

Du brauchst es laut Aufgabe nicht ausgeben, aber falls Du es möchtest, schau mal in diesem lustig Thread nach, wie man eine 64 Bit breite Zahl ausgeben kann.

Für das Weiterrechnen musst Du Dir halt überlegen, wie Du die entsprechenden Operationen auf 64 Bit erweitern kannst. Bei der Division ist das trivial, weil die das Y-Register ja bereits automatisch mit einbezieht, aber bei der Addition ist ein bischen Gehirnschmalz gefragt.

Kann mal einer die richtigen Ergebnisse von der ersten Aufgabe hier hinschreiben? Ich würdegerne wissen, ob meine Ergebnisse richtig sind.

Ich bin alles andere als sicher, ob meine Ergebnisse richtig sind, aber zum Vergleich taugen sie allemal:
186, -186, 6, -6, 69

186, -186, 6, -6, 69

Sieht gut aus.

Eine Frage zu Aufgabe 33: Reicht es, die 19 f(x) für den angegebenen Bereich ausrechnen und -geben zu lassen oder ist tatsächlich nur das Maximum auszugeben, indem die Zwischenergebnisse in einer weiteren Schleife verglichen werden?

Reicht es, die 19 f(x) für den angegebenen Bereich ausrechnen und -geben zu lassen

Nein, aber eine solche zusätzliche Ausgabe ist natürlich ganz nett, habe ich auch implementiert.

oder ist tatsächlich nur das Maximum auszugeben, indem die Zwischenergebnisse in einer weiteren Schleife verglichen werden?

Wieso eine weitere Schleife? Kann man doch beides in derselben Schleife machen.

Wieso eine weitere Schleife?

Danke, hab's jetzt. :)

Sehr schön. Ist Dein Maximum auch ganz am Ende des Bereichs? Das ist ja langweilig…

186, -186, 6, -6, 69

Sieht gut aus.

Kannst du bitte erklären warum das richtig ist? Ich meine es würde ja heißen, dass der Rest 186 ist und damit wäre ~10 das gleiche wie 0. Oder sehe ich das falsch.

Sehr schön. Ist Dein Maximum auch ganz am Ende des Bereichs? Das ist ja langweilig…

Von -8 bis 8 wäre es spannender gewesen. ;)

es würde ja heißen, dass der Rest 186 ist

Soweit korrekt.

und damit wäre ~10 das gleiche wie 0.

Ganz sicher nicht, denn man darf nicht durch 0 dividieren.

~10 heißt doch bloß, dass Du alle Bits in
00000000 00000000 00000000 00001010 umdrehst, womit Du bei
11111111 11111111 11111111 11110101 landest.

Und das ist je nach Interpretation eine ziemlich große Zahl (4.294.967.285) oder eine kleine Zahl (-11). Der Assembler scheint es als die große Zahl zu interpretieren, anders kann ich mir das Ergebnis gerade nicht erklären.

Kann das sein, dass er es auch als -11 interpretiert? Weil bei mir kommt genau 10 raus, was für -11 sogaar stimmen müsste. Vieleicht liegt es auch daran, dass ich es anders gemacht habe und deshalb kriege ich die negativen Zahlen nicht hin.

War es nicht so, dass Divisionsreste nur für negative Divisoren negativ sind?

Zeig uns doch mal den relevanten Quellcode, dann können wir darüber reden.

Für das Weiterrechnen musst Du Dir halt überlegen, wie Du die entsprechenden Operationen auf 64 Bit erweitern kannst. Bei der Division ist das trivial, weil die das Y-Register ja bereits automatisch mit einbezieht, aber bei der Addition ist ein bischen Gehirnschmalz gefragt.

mir ist schon der erste schritt unklar, nämlich wo ich den rest herbekomme. ich habe probiert, nach der division das y-register auszulesen, aber das funktioniert nicht. im skript heißt es dazu ja: "Implementationsabhängig kann das Y-Register den Divisionsrest enthalten.".

mir ist schon der erste schritt unklar, nämlich wo ich den rest herbekomme.

Schau Dir die Definition von Quotient und Rest an:

q = floor(a / b)
a = q * b + r

Jetzt einfach r isolieren und schon hast Du eine Formel für den Rest.

Beispiel: Was ist der Divisionrest von 1234 geteilt durch 100? 1234 = 12 * 100 + 34

!Aufgabe 32
.global main
.global printf
! Deklaration von Daten
.section ".data"
a2: .word ~10
a1: .word 186
b1: .word -(186)
c1: .word ~(-10)
e1: .word 0x12345678
e2: .word 12
e3: .word 24
fmt: .asciz "Ergebnisse: %d, %d, %d, %d, %d\n"
! Ausfuehrbares Programm
.section ".text"
main:

!erstes Ergebnis
set a1, %l1
ld [%l1], %l1
set a2, %l2
ld [%l2], %l2
set fmt, %o0 !Erster Operand in %o0
sdiv %l1, %l2, %l3! Ergebnis der Division in %l3
smul %l3, %l2, %l3! Ergebnis der Multiplikation um den Rest auszurechnen in %l3
sub %l1, %l3, %o1 ! Zweiter Operand in %o1

!zweites Ergebnis
set b1, %l1
ld [%l1], %l1
set a2, %l2
ld [%l2], %l2
sdiv %l1, %l2, %l3! Ergebnis der Division in %l3
smul %l3, %l2, %l3! Ergebnis der Multiplikation um den Rest auszurechnen in %l3
sub %l1, %l3, %o2! Dritter Operand in %o2

!drittes Ergebnis
set a1, %l1
ld [%l1], %l1
set c1, %l2
ld [%l2], %l2
sdiv %l1, %l2, %l4! Ergebnis der Division in %l3
smul %l4, %l2, %l4! Ergebnis der Multiplikation um den Rest auszurechnen in %l3
sub %l1, %l4, %o3! Vierter Operand in %o3

!viertes Ergebnis
set b1, %l1
ld [%l1], %l1
set c1, %l2
ld [%l2], %l2
sdiv %l1, %l2, %l3! Ergebnis der Division in %l3
smul %l3, %l2, %l3! Ergebnis der Multiplikation um den Rest auszurechnen in %l3
sub %l1, %l3, %o4! Fünfter Operand in %o4

!fünftes Ergebnis
set e1, %l1
ld [%l1], %l1
set e2, %l2
ld [%l2], %l2
set e3, %l3
ld [%l3], %l3
sll %l1, %l2, %l5
srl %l5, %l3, %o5

call printf
! Es wird die C-Routine printf aus stdio.h
! aufgerufen. Eine äquivalente Java-Routine
! printf findet man in java.io.PrintStream.
nop
mov 1, %g1 ! Rueckkehr ins Betriebssytem
ta 0
! Ausgabe: Ergebnisse

Jetzt einfach r isolieren und schon hast Du eine Formel für den Rest.

vielen dank, das hat mich weitergebracht. nun bekomme ich auch meine zufallszahlen - die erste (nach 1234567) stimmt mit deiner von seite 1 überein, danach gehts aber mit -188546289, 21272110, -1296234933… weiter.

@Maxim
Du machst es dir viel schwerer, als es eigentlich ist. Ich zitiere einmal Fred:

Kannst Du ein Programm schreiben, dass die Zahl 123 auf der Konsole ausgibt? Und zwar wirklich die Zahl 123 und nicht den String "123"? Dann ersetze im Quellcode einfach die 123 durch 186 % ~10 und es sollte genau so funktionieren.

Mein sicher nicht optimaler Code misst z.B. 30 Zeilen.

Ich weiß aber da kommt bei mir Schwachsinn raus.

Ich weiß aber da kommt bei mir Schwachsinn raus.

Interessant ist ja an Deinem Code z.B., dass Du smul und sdiv verwendest (im Gegensatz zu umul und udiv), also Operationen für vorzeichenbehaftete Zahlen. Natürlich wird die Bitkette, die ich gepostet hatte, dann als -11 interpretiert.

Aber wie gesagt, die Ausdrücke sollen zur Übersetzungszeit ausgerechnet werden, nicht zur Laufzeit. Mein Programm ist glaube ich nicht mal 10 Befehle lang.

danach gehts aber mit -188546289, 21272110, -1296234933… weiter.

Restklassenringe sollten eigentlich keine negativen Zahlen enthalten [25] Probier mal alles unsigned zu rechnen und auszugeben.

"In %o1 steht die Adresse eines Arrays. In diesem Array sind die Startadressen der Parameterstrings gespeichert. Der erste Parameterstring ist der Programmname, der zweite Parameterstring ist für die Aufgabenstellung relevant."

wie macht man das?? meine idee war ld [%o1+x],%l1 oder so.. aber so richtig funktioniert das nicht

Huhu, ich hätte mal ne ganz andere Frage:

Was tut dieses .align genau?
Im Script steht nur, dass es ne 2er Potenz sein muss aber das hilft mir nich wirklich viel weiter

gruß

Hat überhaupt jemand schon aufgaben 33 -35 erfolgreich gelöst?

häng an 35….

Gerade erledigt also 33 doch noch geknackt hatte einen branch fehler.
OLE grosse Freude!

Fangt bloss früh an leute und mit boxsack am besten um die aggressionen loszuwerden ;)

Was tut dieses .align genau?

Das ".align n" sorgt dafür, dass der nächste Befehl oder das nächste Datum an einer ganzzahlig durch n teilbaren Adresse steht. Das ist für Bytes unwichtig, Halfwords müssen 2-aligned sein, Words (und somit auch Befehle) müssen 4-aligned sein, Doublewords müssen 8-aligned sein. Ansonsten kommt es zur Laufzeit zu einem Bus Error.

irgendwie spuckt der bei mir gar nichts mehr aus.

Was genau meinst Du damit? Bekommst Du eine Ausgabe und danach nichts mehr? Kommt einfach gar nichts? Oder hängst Du in einer Endlosschleife? printf verändert %o0, vielleicht liegt's ja daran?

Hat sich gerade erledigt, hatte einen bge gesetzt anstelle eines ble,
deswegen bekam ich nur einen Wert bei 33.

nun mal schauen ob ich noch fix die 34 knacken kann.

So schwer die Aufgaben auch sind, desto mehr freut man sich wenn der Kram dann läuft.

Sehe ich das richtig, das ein Unterprogramm einfach nur weitere register zur Verfügung stellt?

meine idee war ld [%o1+x],%l1 oder so.

Das sieht doch schon sehr gut aus! Was müssen wir für das x einsetzen, wenn wir den ersten Zeiger nicht lesen wollen (wie breit ist dieser?), sondern den zweiten?

Sehe ich das richtig, das ein Unterprogramm einfach nur weitere register zur Verfügung stellt?

Das passiert nicht automatisch, sondern nur, wenn Dein Unterprogramm die folgende Form hat:
unterprogramm:     save %sp, -96, %sp       ! 16 neue Register anfordern, %o wird zu %i     ! ... hier kommt der eigentliche Code     ret                      ! zum Aufrufer zurückkehren     restore                  ! 16 Register wegschmeißen, %i wird wieder zu %o Das besondere an einem Unterprogramm ist, dass es weiß, wer es aufgerufen hat. Diese Information ist notwendig, damit man am Ende des Unterprogramms zum Aufrufer zurückspringen kann. (Genauer gesagt zwei Befehle hinter dem call.)

Kann mir das hier jemand erklären?

Code:

.global main .global printf .section ".data" str1: .asciz "~10 = %d\n" str2: .asciz "186 mod -11 = %d\n" str3: .asciz "186 mod ~10 = %d\n" .section ".text" main: mov ~10, %o1 set str1, %o0 call printf nop mov 186 % -11, %o1 set str2, %o0 call printf nop mov 186 % ~10, %o1 set str3, %o0 call printf nop mov 1, %g1 ta 0
Ausgabe:
~10 = -11 186 mod -11 = 10 186 mod ~10 = 186
Ich kann nachvollziehen dass er einmal die 2er Komplement Darstellung benutzt und einmal die Zahl (-11) ohne Vorzeichen (= 4.294.967.285) aber warum tut er das in scheinbar dem selben Zusammenhang jeweils verschieden…?

Restklassenringe sollten eigentlich keine negativen Zahlen enthalten [25] Probier mal alles unsigned zu rechnen und auszugeben.

ich dachte, ich hätte alles vorzeichenlos gerechnet. ich stelle einmal meinen quelltext rein, weil ich wirklich nicht mehr weiter weiß:
.global main .global printf .section ".data" A: .word 1234567 B: .word 3141592621 C: .word 907526587 M: .word 4294967279 fmt: .asciz "%d\n" .section ".text" main: set A, %l0 ld [%l0], %l0 set B, %l1 ld [%l1], %l1 set C, %l2 ld [%l2], %l2 set M, %l3 ld [%l3], %l3 mov 1, %i0 ! zähler schleife: umul %l0, %l1, %l4 ! A*B add %l4, %l2, %l4 ! A*B + C udiv %l4, %l3, %l5 ! (A*B + C) : M umul %l3, %l5, %l6 ! divisor * quotient sub %l4, %l6, %l7 ! dividend - (D*Q) = rest set fmt, %o0 mov %l7, %o1 call printf mov %l7, %l0 add %i0, 1, %i0 cmp %i0, 10 ! 10x durchlaufen ble schleife nop mov 1, %g1 ta 0

Bist Du sicher das .word reicht fuer Deine Rechnung.
A ist nämlich schon 2^32 und das mal B kann sein das Deine Rechnung dadurch scheitert, zudem soll das ganze als Unterprogramm laufen laut Aufgabenstellung was die ganze Sache noch ein wenig fuchsiger macht.

Bist Du sicher das .word reicht fuer Deine Rechnung.
A ist nämlich schon 2^32 und das mal B kann sein das Deine Rechnung dadurch scheitert,

doh!, um es mit homer simpson zu sagen. danke, da hätte ich wirklich selbst drauf kommen sollen. habe die zeilen einfach nur aus einer früheren aufgabe kopiert und dort oben später nicht mehr hingeguckt. :)

zudem soll das ganze als Unterprogramm laufen laut Aufgabenstellung was die ganze Sache noch ein wenig fuchsiger macht.

ist klar, es ging mir erst mal nur um die bloße rechnerei.

ich dachte, ich hätte alles vorzeichenlos gerechnet.

Probier mal alles unsigned zu rechnen und auszugeben.

Ich hab 32-34 jetz mal zur seite gelegt…
Aufgabe 32 naja halbwegs, kann zwar nich erklären warum der jetz mal den großen mal den negativen wert nimmt.
Aufgabe 33 funktioniert yay
Aufgabe 34 gehen die Zufallszahlen gegen 0 immer egal ob ich word double oder quad nehme.. (btw können die register überhaupt 128 Bit aufnehmen…?) Ich hab das ganze über das Y Register gelöst, im script stand ja dass dort manchmal (-.-) der rest abgelegt wird.

und Aufgabe 35 weiss ich jetz echt gar nix…
Ich stell mir das so vor:
Man startet ./a.out und wird dann nach der Zahl gefagt und gibt sie dann halt als kommandozeile ein. aber wie speicher ich die dann in o1? Oder überhaupt, wie macht man so eine "geben sie bitte was ein" anfrage? Oder hab ich das völlig falsch verstanden? Andere Idee war noch dass man das direkt hinter das programm schreibt als parameter aber beim kompilieren oder beim ausführen..?
Und dann diese relative Adresse.. ist damit jetz 32 gemeint (weil Befehle ja alle 32 Bit lang sind) oder Programmnamenlänge… (wo kann ich den eig ablesen?)
Auf der Sun Homepage hab ich btw auch gelesen, dass bei ascii einlesen immer nur das erste zeichen als Zahlenwert eingelesen wird.. dh man müsste ne Schleife konstruieren, die jedes mal die nächste Stelle ausliest und in eine Binär Zahl umwandelt?
Und noch was die Umwandlung generell muss man sich da an der Ascii tabelle bedienen und so ne art switch-case konstrukt bauen? oder gibts da irgendwas einfaches?
und bei der Schleife wäre dann ja auch noch das Problem, dass man die Zahl in der Zeile als Dezimalwert hat, sodass man jedes mal die nächste Stelle mit dem davor liegenden verhackstücken muss….

uff viel zeug
gruß

Wenn ich
save%sp, -96, %sp  
und double Zahlen habe, wieso kriege ich diesen fehler ausgegeben? :

/local/SUNWspro/prod/bin/fbe: "aufgabe34.s", line 22: error: location counter not on word boundary

können die register überhaupt 128 Bit aufnehmen…?

Nein. Auf der Sparc V8 sind alle Register 32 Bit breit. Was willst Du denn mit 128 Bit, und wie versuchst Du diese zu verarbeiten (Laden, Rechnen)?

Ich hab das ganze über das Y Register gelöst, im script stand ja dass dort manchmal (-.-) der rest abgelegt wird.

Das passiert auf den Sparcs im Rechenzentrum aber offenbar nicht.

Man startet ./a.out und wird dann nach der Zahl gefagt und gibt sie dann halt als kommandozeile ein.

Ich weiß jetzt nicht genau, was Du damit meinst, aber Du musst die Zahl einfach beim Programmstart mit übergeben.
rzdspc10$ a.out 12345

Und dann diese relative Adresse.. ist damit jetz 32 gemeint (weil Befehle ja alle 32 Bit lang sind)

Welche relative Adresse? Was hat das mit der Breite von Befehlen zu tun? Adressierung im Speicher passiert übrigens byteweise, nicht bitweise.

man müsste ne Schleife konstruieren, die jedes mal die nächste Stelle ausliest und in eine Binär Zahl umwandelt?

Klingt vom Ansatz her gut.

Und noch was die Umwandlung generell muss man sich da an der Ascii tabelle bedienen und so ne art switch-case konstrukt bauen? oder gibts da irgendwas einfaches?

'0' = 48
'1' = 49
'2' = 50
…
'9' = 57

Kannst Du hier ein Muster erkennen?

location counter not on word boundary

Das bedeutet, dass Du versuchst, Code an einer nicht durch 4 teilbaren Adresse abzulegen. Hast Du Dein Unterprogramm vielleicht überhalb der .align 4 Zeile reingeschrieben?

Mehr kann ich aufgrund der dürftigen Informationen nicht dazu sagen… vielleicht ein bischen Programmkontext posten, also was steht ein paar Zeilen dadrüber und dadrunter?

Hatte vergessen .section ".text" vor meinem unterprogramm zu schreiben und nur vor dem Main stehen.

man sollte sein Unterprogramm nicht random nennen, ist scheinbar ein reserviertes Wort ;)

ld: warning: symbol `random' has differing types: (file aufgabe34.o type=NOTY; file /lib/libc.so type=FUNC);

Offenbar gibt es bereits eine Bibliotheksfunktion namens "random". Verwende einfach einen anderen Namen, am besten einen deutschen, dann sollte es klappen.

@Fred: Habe eine zufallszahl bis dato und die lautet -1708064929 sonst nur nullen.

arbeite noch daran, wolltest ja eine bestätigung Deiner Ergebnisse

Meine Pseudo-Zufallszahlen:

54309360
76826641
1020560646
819634193
…

Habe eine zufallszahl bis dato und die lautet -1708064929

Bis auf das Vorzeichen stimmt die Zahl lustigerweise. Wieso hast Du eine negative Zahl raus? Kann es sein, dass Du Minuend und Subtrahend verwechselt hast?

Bis auf das Vorzeichen stimmt die Zahl lustigerweise. Wieso hast Du eine negative Zahl raus? Kann es sein, dass Du Minuend und Subtrahend verwechselt hast?

Ich habe keine Ahnung, aber im moment prügele ich mich noch mit registern herum irgendwie überschreibt mein programm sämtlich Zahlen so dass nur noch mist heraus kommt, bin schon kurz vorn wahnsinn.

nun habe ich Zufallszahl: 1234567, aber diese nun auch zehn mal ohne eine andere, nicht gut.

nun habe ich Zufallszahl: 1234567, aber diese nun auch zehn mal ohne eine andere, nicht gut.

Erinnert mich daran [28]

Und dann diese relative Adresse.. ist damit jetz 32 gemeint (weil Befehle ja alle 32 Bit lang sind)

Welche relative Adresse? Was hat das mit der Breite von Befehlen zu tun? Adressierung im Speicher passiert übrigens byteweise, nicht bitweise.

Naja, ich will ja dann den 2. String in o1 auslesen, also den übergebenen Parameter. (Der erste ist ja der Programmname wenn ich das richtig verstanden habe)
hab da vorhin was gelesen wie:
ld [%o1+x], %l0
bei x = 0 würde das dann ja die Adresse des ersten buchstaben des Programmnamens in l0 laden oder?
Die Frage ist ja jetzt, wie lang so eine Adresse ist, damit man die richtige anzahl an Bits überspringen kann, eben mit dem +x, um an die Adresse des ersten Buchstaben des ersten Parameters zu kommen.
Meine erste Idee war 32, da ja bei der Sparc irgendwie alles auf 32 (Bit) zu basieren scheint.
Wenn man dann die Adresse in l0 hat, kann man mit der ja wiederum den ersten Buchstaben laden.
Da kam bis jetzt aber nur Murks raus…
Und byteweise..?
heisst das ich müsste bei dem +x byte statt bit einsetzen?

Und noch was die Umwandlung generell muss man sich da an der Ascii tabelle bedienen und so ne art switch-case konstrukt bauen? oder gibts da irgendwas einfaches?

'0' = 48
'1' = 49
'2' = 50
…
'9' = 57

Kannst Du hier ein Muster erkennen?

Hmm das müsste ja dann heissen, dass ich das ganze mit einem einfachen -48 austricksen könnte oder? ^^

gruß

:)
sollte wohl andere register ausser %o nehmen für meine Konstanten

bei x = 0 würde das dann ja die Adresse des ersten buchstaben des Programmnamens in l0 laden oder?

Ja.

Die Frage ist ja jetzt, wie lang so eine Adresse ist, damit man die richtige anzahl an Bits überspringen kann […] Meine erste Idee war 32, da ja bei der Sparc irgendwie alles auf 32 (Bit) zu basieren scheint.

Korrekt.

heisst das ich müsste bei dem +x byte statt bit einsetzen?

Ja.

Hmm das müsste ja dann heissen, dass ich das ganze mit einem einfachen -48 austricksen könnte oder? ^^

Korrekt.

Naja, ich will ja dann den 2. String in o1 auslesen, also den übergebenen Parameter. (Der erste ist ja der Programmname wenn ich das richtig verstanden habe)
hab da vorhin was gelesen wie:
ld [%o1+x], %l0
bei x = 0 würde das dann ja die Adresse des ersten buchstaben des Programmnamens in l0 laden oder?
Die Frage ist ja jetzt, wie lang so eine Adresse ist, damit man die richtige anzahl an Bits überspringen kann, eben mit dem +x, um an die Adresse des ersten Buchstaben des ersten Parameters zu kommen.
Meine erste Idee war 32, da ja bei der Sparc irgendwie alles auf 32 (Bit) zu basieren scheint.
Wenn man dann die Adresse in l0 hat, kann man mit der ja wiederum den ersten Buchstaben laden.
Da kam bis jetzt aber nur Murks raus…
Und byteweise..?
heisst das ich müsste bei dem +x byte statt bit einsetzen?

also eine adresse is immer 4 byte lang… in der ersten adresse steht ja der programmname.. in der 2. dann die adresse für den eingegebenen string… also +4

im script steht btw auch ein programm wie man sachen aus einer kommandozeile liest, dalls euch das hilft

im script steht btw auch ein programm wie man sachen aus einer kommandozeile liest, dalls euch das hilft

Ah, interessant, allerdings wird dort innerhalb von main ein save verwendet, weshalb die relevanten Register dann %i0 und %i1 sind anstatt %o0 und %o1. Lasst euch davon nicht verwirren.

kann man eigentl bei der ausgabe noch über das Y register hinaus kommen? weil bei zahlen über 5xxxx etwa reichen bei mir auch die 64 bit nicht mehr aus..

Ich gebe auf ich weis nicht mehr weiter.
Kann noch jemand helfen?

.global main .global printf .global zufall .align 8 .section ".data" a: .word 1234567 b: .word 3141592621 c: .word 907526587 m: .word 4294967279 fmt: .asciz "Zufallszahl: %d \n" ! wird 10 mal aufgerufen .section ".text" ! Hier geht das Hauptprogramm los ! A = (a*b+C) mod M zufall: ! Neues Registerfenster ! Anlegen eins Aufrufsatzes ! Uebernahme des Parameters save %sp, -96, %sp mov %i1, %l1 mov %i2, %l2 mov %i3, %l3 mov %i4, %l4 umul %l1, %l2, %l5 ! A*B add %l5, %l3, %l3 ! A*B + C udiv %l3, %l4, %l5 ! A*B +C / M umul %l5, %l4, %l5 ! (A*B +C / M) * M sub %l5, %l3, %i5 ! ((A*B +C / M) * M) - (A*B +C) = Rest ! Rueckgabewert in %i5 jmp %i7+8 !Ruecksprung restore main: set a, %o1 ld [%o1], %o1 set b, %o2 ld [%o2], %o2 set c, %o3 ld [%o3], %o3 set m, %o4 ld [%o4], %o4 mov 1, %l1 cmp %l1, 10 ble schleife nop schleife: call zufall nop mov %o5, %o1 set fmt, %o0 call printf nop add %l1, 1, %l1 cmp %l1, 10 ble schleife nop !da call printf etwas dauert geht ein zyklus floeten sende: mov 1, %g1 !rueckkehr zum Betriebssystem ta 0
kommt leider nur folgendes heraus:

rzdspc10$ a.out Zufallszahl: -1708064929 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634 Zufallszahl: -20634
Ich bin am ende.

sub %l5, %l3, %i5 tausch da mal beide reg…

außerdem hast du das Y register bei der addition nicht beachtet und irgendwas scheint in deienr schleife noch nicht zu stimmen…

y register wird doch bei der division berücksichtigt und die richtigen werte bekomme ich heraus.

nur mal son schnippsel: (mit save im main abschnitt) ld [%i1+4], %l1 !Schreibt Adresse des ersten Parameters in %l1 ldub [%l1], %l2 !lade das erste ASCII Zeichen im Parameter nach %l2

y register wird doch bei der division berücksichtigt und die richtigen werte bekomme ich heraus.

Aber nur bis zum 5. oder so.
y muss auch in der Addition (manuell quasi) berücksichtigt werden.

nur mal son schnippsel: (mit save im main abschnitt) ld      [%i1+4], %l1  !Schreibt Adresse des ersten Parameters in %l1 ldub    [%l1], %l2    !lade das erste ASCII Zeichen im Parameter nach %l2

omg es geht ja auch so einfach….

Ich gebe auf ich weis nicht mehr weiter.
Kann noch jemand helfen?

Das call printf zerschießt Dir deine %o-Register.

YAY, bin jetzt bei 34…

uff geschafft, 35 läuft zwar nur bis 00255 weil dann das Ergebnis 32 bit überschreitet aber egal

Danke an alle!

mit fmt "Potenz: %illu" kannst du auch das y reg ausgeben
dann einfach y nach %o1 und das andere nach %o2 und schon gehts bis 5xxxx

Ich schlage eine gemeinsame Petition für die Veröffentlichung einer Musterlösung vor…

wäre gar nicht dumm, dann könnte man mal sehen wie man es richtig macht.
Würde den Kram ganz gerne können. Im moment komme ich mir vor als ob ich
jeden Zentimeter abtaste und bei jedem cc aufgabexx.s einfach nur bete das es kompiliert,
von einer Sinnvollen Lösung will ich mal gar nicht erst sprechen. ;)

Ich kann zum ersten Mal gar nichts abgeben; vom Punktestand her bringt mich das zwar nicht um, ist aber trotzdem arg frustrierend.

problem ist halt… wenn einer seine sachen veröffentlicht vorm abgabetermin
–> alle abgeschrieben –> alle 0 pkt

außerdem glaub ich darfst du in rs auch nur einmal unter 20 % haben bei nem aufgabenzettel oder? glaub das war nochn bisschen verschärfter als in mathe… und die nächsten wochen zur klausur wirds halt noch n paar mehr assembleraufgaben geben

außerdem glaub ich darfst du in rs auch nur einmal unter 20 % haben bei nem aufgabenzettel oder?

Das wäre mir neu. Mir ist nur die Regelung bekannt, dass man sowohl im Lehmann-Teil als auch im Möller-Teil jeweils mindestens 50% erreichen muss.

Es verlangt niemand, dass ihr perfekte Musterlösungen abgebt. Selbst für Programme, die nicht kompilieren, kann man als Übungsgruppenleiter noch Punkte für einen vernünftigen Ansatz geben.

Programmieren muss man selber machen, das reine Lesen von Musterlösungen oder Beispielprogrammen hilft nur bedingt (davon gibt's ja genug im Skript). Meine eigenen Lösungen stelle ich natürlich gerne als Diskussionsgrundlage in der Übungsgruppe vor.

Bei Problemen einfach Übungsgruppen besuchen und Fragen stellen. Ein Vorklausurpaniktutorium wird bestimmt auch wieder angeboten werden.

und die nächsten wochen zur klausur wirds halt noch n paar mehr assembleraufgaben geben

Es wird bis zum Semesterende nach meinem Kenntnisstand sogar ausschließlich um Assembler gehen!

P.S. Es ist natürlich auch realitätsfremd, 12 Stunden vor Abgabetermin mit dem Bearbeiten der Aufgaben anzufangen, wenn man vorher noch nie in Assembler programmiert hat, wobei ich das natürlich niemandem direkt unterstellen möchte.

Es ist natürlich auch realitätsfremd, 12 Stunden vor Abgabetermin mit dem Bearbeiten der Aufgaben anzufangen, wenn man vorher noch nie in Assembler programmiert hat, wobei ich das natürlich niemandem direkt unterstellen möchte.

wann ist denn noch mal abgabetermin? einen tag vor dem übungstermin oder zwei?

also bei tiamat ist mittwoch abgabetermin :)
Und zwar DIESEN Mittwoch für die Aufgaben zu DIESER woche

Selbst für Programme, die nicht kompilieren, kann man als Übungsgruppenleiter noch Punkte für einen vernünftigen Ansatz geben.

Der Ansatz soll sich gerüchteweise übrigens am besten erkennen lassen, wenn das Programm gut kommentiert wurde [28]

Also ich habe die Lösung für die erste aufgabe bereits, dennoch würde ich gerne wissen, wieso folgendes nicht geht:

(…)
!Nr 32
.global main
.global printf
.section ".data"
a: .double 186%~10
(…)

Macht man selbiges im .text Teil(mov), zickt der compiler nicht rum. Aber wieso?

PS. Code natürlich über alle Maße beschnitten, zwecks Abschreib/0Punkte Gefahr und so ^^

a: .double 186%~10

Was willst Du denn an der Stelle mit einem .double? Reicht ein .word nicht völlig aus?

Ah, ja ^^. Das war schon ein vergeblicher Korrekturversuch. Ich hatte zuerst mit word, hat es aber genausowenig getan wie double.

dennoch würde ich gerne wissen, wieso folgendes nicht geht

Was heißt das genau? Was geht nicht? Was sagt der Compiler? Hast Du vielleicht einfach das .align 4 vergessen?

Ich habe das Gefühl, dass sowohl Skript als auch Sparc Manual schon einige Kenntnisse voraussetzen.
Mir fehlt eine noobgerechte Auflistung aller Assemblerbefehle in Syntax und Semantik; in der Übungsgruppe konnte man mir dafür keine Empfehlung geben, aber mehrere andere Teilnehmer hatten denselben Bedarf. Mit Google hatte ich noch kein Glück; weiss hier jemand einen passenden Link?

danke und gute Nacht,

Stefan

also wenn man nachholbedarf hat kann ich auch nur das rs tutorium empfehlen… also die letzten male waren da immer max 10.. –> ja eigentl das der rest assembler gut kann

dennoch würde ich gerne wissen, wieso folgendes nicht geht

Was heißt das genau? Was geht nicht? Was sagt der Compiler? Hast Du vielleicht einfach das .align 4 vergessen?

.align 4 habe ich garnicht benutzt o.O - bei meiner funktionierenden Lösung geht es auch sehr gut ohne. Mit funktioniert der erste Ansatz leider auch nicht.
Der compiler sagt:
ld: fatal: relocation error: R_SPARC_13: file versuch.o: symbol <unknown>: value 0x20d60 does not fit

@Stefan
Stimme dir zu, vor allem das Skript ist einfach nur grottig. Die nonplus ultra Quelle habe ich leider auch nicht, aber folgedens hat mir zumindest einbisschen gehofen: http://mandalex.manderby.com/b/befehleregister.php

ja vielleicht posten hier auch nur leute, die regelmäßig das tutorium besuchen ?

dennoch würde ich gerne wissen, wieso folgendes nicht geht

Was heißt das genau? Was geht nicht? Was sagt der Compiler? Hast Du vielleicht einfach das .align 4 vergessen?

.align 4 habe ich garnicht benutzt o.O - bei meiner funktionierenden Lösung geht es auch sehr gut ohne. Mit funktioniert der erste Ansatz leider auch nicht.
Der compiler sagt:
ld: fatal: relocation error: R_SPARC_13: file versuch.o: symbol <unknown>: value 0x20d60 does not fit

du machst dann in section test mov a,%o1 ?
dann ist klar, wenn das nicht funktioniert.. denn du legst jetzt die adresse nach o1 und das ist ein ganz anderer wert…

also wenn man nachholbedarf hat kann ich auch nur das rs tutorium empfehlen…

Wann findet denn das Tutorium statt? Bei Stine ist da kein Eintrag zu.

Es gibt nen Eintrag in Stine, das ist ne "richtige" Veranstaltung
64-044 Tutorium: Ergänzung zu Rechnerstrukturen


Kommentare/ Inhalte:
Inhaltlich werden Teile des Vorlesungsstoffs wiederholt, zusätzliche Aufgaben vorgestellt und besprochen. Die einzelnen Teilnehmer des Tutoriums verfügen über ein Vorschlagsrecht, Themen zur Vertiefung zu benennen.
Lernziel:
Das Modul Rechnerstrukturen soll von den Studierenden im ersten Semester absolviert werden. Erfahrungsgemäß sind die Kenntnisse der Erstsemester sehr breit gestreut. Diese Tutorium soll dazu beitragen, die unterschiedlichen Startkenntnisse der Studierenden auszugleichen, insbesondere auf mathematischem Gebiet.

Mittwochs 18.15 (falls es verschoben wurde schreibt das mal kurz)

Dank dir. Leider überschneidet sich das diese Woche mit einem ebenfalls wichtigen Mathe-Tutorium, aber künftig werde ich da mal reinschauen, falls die Verwirrung bis dahin nicht Erleuchtung gewichen ist. ;)

Wer hält das Tutorium?

Tutorium macht Herr Lehmann.
Ich habe hier noch ne schöne Tabelle von 6popov (Dimitri Popov) mit den ganzen Mnemonics der Sparc mal zusammengefasst, stammt wohl teilweise von der schon genannten Website.
Mit seiner Erlaubnis häng ich die mal an.

Ich habe hier noch ne schöne Tabelle von 6popov (Dimitri Popov) mit den ganzen Mnemonics der Sparc mal zusammengefasst

Die Überschrift "Pseudo-Ops" sollte eher "Direktiven" heißen (es geht hier um .section und co).
Pseudo-Befehle (auch "synthetische Befehle") sind etwas anderes (Beispiel: set, mov, cmp).

du machst dann in section test mov a,%o1 ?
dann ist klar, wenn das nicht funktioniert.. denn du legst jetzt die adresse nach o1 und das ist ein ganz anderer wert…

Ja - du hast recht :D. Mit set geht es dann ohne Fehler, aber mir der Adresse anstelle des Wertes. Wie bekomme ich denn den Inhalt und nicht die Adresse eines Registers in ein %o1 ? Stehe gerade total auf dem Schlauch und denke, dass ich das wirklich kapieren sollte.

ld [%l0], %l1 Lädt das Wort, das an der Adresse steht, die in %l0 gespeichert ist, nach %l1.

ld [%l0], %l1 Lädt das Wort, das an der Adresse steht, die in %l0 gespeichert ist, nach %l1.

Oh Mensch, natürlich ^.^ . Dankeschön Fred!

Frage: Landet der Rest bei "udiv %l1, %l4, %l5" (beliebige Register) jetzt im y Register oder nicht?

Frage: Landet der Rest bei "udiv %l1, %l4, %l5" (beliebige Register) jetzt im y Register oder nicht?

Ist implementationsabhängig, also kann man nicht davon ausgehen. Auf den Sparcs, mit denen ich bisher zu tun hatte, stand der Rest definitiv NICHT im y-Register.

Frage: Landet der Rest bei "udiv %l1, %l4, %l5" (beliebige Register) jetzt im y Register oder nicht?

Ist implementationsabhängig, also kann man nicht davon ausgehen. Auf den Sparcs, mit denen ich bisher zu tun hatte, stand der Rest definitiv NICHT im y-Register.

Hmpf, so ein Scheiss .-. .

-54309360, -4195476, 134144, -13041472, 0, 0, 1, -4195260, 0, -4195254
Es ist zum verrückt werden.

Mag vielleicht jemand diesen falschen Code zerrupfen? Vielleicht hat der ein oder andere jetzt was zum Lachen.

[php]!Nr 34
.global main
.global printf
.align 4
.section ".data"
A: .double 1234567
B: .double 3141592621
C: .double 907526587
M: .double 4294967279
e: .double 0
z: .word 0

fmt: .asciz "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n"

!Ausfuehrbares Programm
.section ".text"
main:
set fmt,%o0

schleife:

set A, %l1
ld [%l1], %l1
set B, %l2
ld [%l2], %l2
set C, %l3
ld [%l3], %l3
set M, %l4
ld [%l4], %l4
set e, %l5
ld [%l5], %l5
set z, %l6
ld [%l6], %l6

umul %l1, %l2, %l1 !unsigned A*B in A
add %l1, %l3, %l1 !(A*B)+C in A
udiv %l1, %l4, %l5 !Dividiere A durch M in Mneu
umul %l5, %l4, %l5 !Mneu * M
sub %l5, %l1, %o1 !((A*B +C / M) * M) - (A*B +C) = Rest
call printf
add %l6, 1, %l6 !Zählvariable ++1
cmp %l6, 10 ! Vergleiche Zählvariable mit Durchgängen(10)
bne schleife !wenn ungleich spring nach schleife


nop
mov 1, %g1 !Rueckkehr ins Betriebssystem
ta 0[/php]

fmt: .asciz "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n"

Du rufst printf innerhalb einer Schleife auf. Willst Du wirklich bei jedem Aufruf 10 Zahlen ausgeben? Das wären dann ja insgesamt 100.

sub %l5, %l1, %o1       !((A*B +C / M) * M) - (A*B +C) = Rest

Hier berechnest Du das neue A. Wäre es nicht sinnvoll, dieses wieder in %l1 zu speichern, damit Du bei der nächsten Iteration nicht wieder auf das alte A zugreifst?

Hallo Fred, danke für deine Antwort.

Ja, ich rufe es in der Schleife auf, nutze ich aber nur ein %d wird leider auch nur ein Ergebnis ausgegeben. So gibt das Teil 10 Zahlen aus (nicht 100), der Fehler muss also irgendwo tiefer liegen.

sub %l5, %l1, %o1       !((A*B +C / M) * M) - (A*B +C) = Rest

Oh, stimmt. Der Rest ist mein neues A, nicht das A der Vorrechnung :D. Danke !

Innerhalb deiner Schleife setzt du ja immer alles wieder neu (und lädst die startwerte aus dem speicher), wie soll da mal ne andere Zahl rauskommen.
diese zehn %d sind definitiv quatsch. Mach eins.

außerdem hast du das carrybit nicht beachtet bei der addition

und btw für die zahlen brauchst kein double.. da reicht .word

Es gibt nen Eintrag in Stine, das ist ne "richtige" Veranstaltung
64-044 Tutorium: Ergänzung zu Rechnerstrukturen

Mittwochs 18.15 (falls es verschoben wurde schreibt das mal kurz)

Wo findet die statt?

Und in Stine kann ichs nicht findet… wahrscheinlich suche ich am falschen Platz

Es gibt nen Eintrag in Stine, das ist ne "richtige" Veranstaltung
64-044 Tutorium: Ergänzung zu Rechnerstrukturen

Mittwochs 18.15 (falls es verschoben wurde schreibt das mal kurz)

Wo findet die statt?

Und in Stine kann ichs nicht findet… wahrscheinlich suche ich am falschen Platz

Findet in B-2XX (Konrad-Zuse-Hoersaal Informatikum) statt.

Aufgrund der großen Nachfrage hier meine eigenen Lösungsvorschläge.

@Stefan
Stimme dir zu, vor allem das Skript ist einfach nur grottig. Die nonplus ultra Quelle habe ich leider auch nicht, aber folgedens hat mir zumindest einbisschen gehofen: http://mandalex.manderby.com/b/befehleregister.php

danke, hatte deine Antwort leider bisher übersehen…

Guten Morgen,
im von Fred zitierten Programm aus dem Skript verstehe ich eine (vermutlich simple) Sache nicht:
In diesem Ausschnitt des Quelltextes :
1.main: set a1, %l1
2.ldsh [%l1], %l1

wird nach meinem Verständnis

1. der Wert von a1 in das Register l1 geschrieben und
2. der Wert, der in dem Register gespeichert ist,
  dessen Adresse in l1 gespeichert ist, in l1 gespeichert.

Wegen a1 = 17 würde demnach unter 2.ein (unbekannter)
Wert aus r17in l1 gespeichert werden.

Wie der weitere Programmverlauf bzw. die Ausgabe zeigt,
befindet sich in l1 aber tatsächlich wunschgemäß die Zahl 17.

Wo liegt mein Missverständnis der beiden zitierten Zeilen?

danke,

Stefan

1.main: set a1, %l1
2.ldsh [%l1], %l1

wird nach meinem Verständnis

1. der Wert von a1 in das Register l1 geschrieben und

Was ist denn der Wert von a1? Nach meinem Verständnis wird der Wert a1 in das Register %l1 geschrieben. a1 ist die Adresse des Datums, dass hinter dem Label a1 steht. %l1 wird hier mit einer Adresse befüllt.

2. der Wert, der in dem Register gespeichert ist, dessen Adresse in l1 gespeichert ist, in l1 gespeichert.

Register haben keine Adresse. Hier wird einfach das Halbwort an der Adresse a1 nach %l1 geladen.

Wegen a1 = 17

Nein, a1 ist nicht 17! a1 ist die Adresse im Arbeitsspeicher, an der das Halbwort 17 gespeichert ist.

Ich empfehle Dir dringend, das Kapitel "Arbeitsspeicher" in meinem Tutorial zu lesen.

Danke, Fred, ich hatte leider durch Krankheit einiges versäumt.
Ich glaube, deine Ausführungen decken auch noch einen weiteren ( oder sogar den grundlegenden) Irrtum meinerseits auf:

Ich hatte die  Zeile:
a1: .half 17

so verstanden, dass quasi einer Variablen a1 der Wert 17 zugeordnet wird.

Wenn ichs jetzt richtig verstehe, wird hier muBeodem Halbwort 17 die Speicheradresse a1 zugeordnet?

Wenn ichs jetzt richtig verstehe, wird hier dem Halbwort 17 die Speicheradresse a1 zugeordnet?

So kann man es sich vorstellen, ja.