Kap 5. 5 Die Maschinenprogrammebene eines Rechners. int a=1, b=2; a = a+2*b; Höhere Programmiersprache. Assembler und Maschinenprogramm

Transkript

1 5 Die Maschinenprogrammebene eines Rechners Höhere Programmiersprache Assembler und Maschinenprogramm Register und Mikroprogramm int a=1, b=2; a = a+2*b; lw $t0, a lw $t1, b add $t0, $t0, $t1 add $t0, $t0, $t1 sw $t0, a Kap 5 Gatter & & & >1 Transistoren

2 Die Maschinenprogrammebene eines Rechners Jörg Roth 271 Wir betrachten die Ebene der Maschinenprogramme am Beispiel des MIPS R2000 Prozessors. Wir behandeln: die Architektur des MIPS-Prozessors, Register, Adressierungsarten; die Befehle des MIPS-Prozessors; Assembler vs. Maschinensprache, Kodierung von Befehlen; die SPIM-Simulationsumgebung für den MIPS-Prozessor; weitere Eigenschaften der Befehle und Programmbeispiele.

3 Die Maschinenprogrammebene eines Rechners Jörg Roth ADie Komponenten des MIPS R2000 Befehlsregister rs rt rd funct shamt Direkter Operand (immediate) Adress-Offset Adresse (address) $31... lesen schreiben Speicher... Auswahl Auswahl Auswahl Quelle Auswahl Ziel (rd) $2 $1 $zero Auswahl 2.Operand (rt) Auswahl 1.Operand (rs) Adresse Offset addieren Ergebnisse MULT, DIV Hi Lo ALU & Shifter Auswahl Funktion (funct) Anzahl Shifting-Schritte (shamt) Auswahl Adress- Quelle O Z N

4 Die Maschinenprogrammebene eines Rechners Jörg Roth 273 Register des MIPS Es gibt 32 interne Register. Zwei Arten der Bezeichnung: Durchnumeriert: $0,... $31 Anhand der Eigenschaft: $zero, $s0,... $s7, $t0,... $t7 Es gibt eine 1-1-Zuordnung zwischen beiden Bezeichnungen, z.b. $0=$zero, $16=$s0, $17=$s1 Die Register haben verschiedene Bedeutungen. Einige davon: $zero: gibt immer die 0 zurück, kann nicht geschrieben werden $s0,... $s7: generelle Register für Zwischenrechungen Zwei weitere Register mit speziellen Funktionen: Hi, Lo Resultate für Multiplikation: (Hi, Lo) = op1 op2 Resultat für die Division: Hi = op1 mod op2, Lo = op1/op2

5 Die Maschinenprogrammebene eines Rechners Jörg Roth 274 Übersicht der Register: Register Symbolisch Bedeutung $0 $zero immer 0 $1 $at verwendet Assembler bei Pseudobefehlen $2 $3 $v0 $v1 Rückgabewerte von Unterprogrammen $4 $7 $a0 $a3 Parameter für Unterprogr. (Unterprogr. darf verändern) $8 $15 $t0 $t7 Register, die ein Unterprogramm nicht sichern muss $16 $23 $s0 $s7 Register, die ein Unterprogramm sichern muss $24 $25 $t8 $t9 Register, die ein Unterprogramm nicht sichern muss $26 $27 $k0 $k1 reserviert für das Betriebssystem (Interrupts) $28 $gp Zeiger auf globalen Speicherbereich $29 $sp Stackpointer (zum Retten von Registern in Unterprog.) $30 $s8/$fp Framepointer ($sp beim Start eines Unterprogramms) $31 $ra Rücksprungadresse für Unterprogramme

6 Die Maschinenprogrammebene eines Rechners Jörg Roth 275 Bemerkungen zu den Registern: Die Bedeutung der Register außer $zero und $ra ist nur eine Konvention. Logische und arithmetische Operationen sowie Shift-Funktionen werden nur auf den Registern durchgeführt, nicht auf Speicheradressen. Beispiel: add $s1, $s2, $s3 bedeutet $s1 := $s2 + $s3 Um Operationen auf Speicherinhalten durchzuführen, müssen zuerst die Inhalte in Register geladen werden und am Ende das Resultat gespeichert werden: lw $s2,1000 # Lade Inhalt von Adresse 1000 in $s2 lw $s3,2000 # Lade Inhalt von Adresse 2000 in $s3 add $s1, $s2, $s3 # Addiere sw $s1, 3000 # Speichere Resultat in Adresse 3000

7 Die Maschinenprogrammebene eines Rechners Jörg Roth BMaschinensprache und Assembler Die vom Prozessor ausführbaren Befehle liegen im Binärformat vor. Nur solche Befehle sind direkt ausführbar. So steht das Wort ( ) 16 für den symbolischen Befehl add $17, $18, $19 bzw. add $s1, $s2, $s3 Während der Befehl ( ) 16 für den Prozessor leicht "verständlich" ist, ist er für Menschen schwer lesbar. Für Menschen ist dagegen die Textzeile "add $s1, $s2, $s3" verständlicher. Das "add" im Befehl wird Mnemonic genannt. Die Registerbenennung kann in der gewünschten Form erfolgen. Zusätzlich gibt es syntaktische Kennzeichnungen für verschiedene Adressierungsarten (siehe unten).

8 Die Maschinenprogrammebene eines Rechners Jörg Roth 277 Zur Lösung dieses Problems verwendet man zur Programmierung auf Maschinenebene einen so genannten Assembler: Assembler lesen Texte zeilenweise und wandeln in der Regel jede Textzeile in einen Maschinenbefehl um. Ein typischer Befehl besteht aus einem Mnemonic (z.b. addi) und Operanden (z.b. $s1), letztere durch Kommata oder Blanks getrennt. Die Übersetzung von Assembler-Texten in Maschinenbefehle ähnelt der Compilierung bei höheren Programmiersprachen der Prozess wird Assemblierung genannt. Nicht korrekt geformte Texte können Syntaxfehler enthalten, so dass kein Maschinenprogramm generiert werden kann. Es gibt eine 1-1-Übersetzung von Assembler-Befehlen zu Maschinen- Befehlen man verfügt also bei weitem nicht über die Möglichkeiten einer höheren Programmiersprache.

9 Die Maschinenprogrammebene eines Rechners Jörg Roth 278 Weitere Funktionen eines Assemblers: Hantieren mit symbolischen Adressen: Der Entwickler kann bestimmten Speicheradressen Namen (Label) zuordnen. Der Assembler erkennt diese Namen und fügt bei der Übersetzung die Originaladressen ein. Hantieren mit symbolischen Sprungzielen: Sprungbefehle führen den Programmablauf an einer anderen Stelle des Programms fort. Diese Stellen können symbolisch benannt werden. Bei relativen Sprüngen (z.b. "springe 100 Bytes nach vorne") berechnet der Assembler die Sprungdifferenz anhand des symbolischen Namens automatisch. Komfortables Einfügen statischer Daten: Neben den Maschinenbefehlen enthält ein Programm auch statische Bereiche, z.b. feste Zeichenketten oder numerische Konstanten. Über Assembler-Befehle können solche Datenbereiche komfortabel erstellt werden. Angabe von numerischen Konstanten in verschiedenen Zahlensystemen, z.b. "100" (dezimal) "0xFF" (hexadezimal).

10 Die Maschinenprogrammebene eines Rechners Jörg Roth 279 Pseudobefehle: häufig benutzte Befehle können durch eigene Befehlskürzel abgekürzt werden. So existiert in MIPS der Pseudobefehl li (load immediate), z.b. in li $s1, 100 # Lade die Zahl 100 in das Register $s1 der allerdings bei der Assemblierung in den Befehl ori $s1, $zero, 100 # $s1 := 0 OR 100 übersetzt wird. Der zweite Befehl ist inhaltsgleich aber für Menschen schwerer lesbar. Makros sind mehrzeilige Befehlssequenzen, die bei der Assemblierung textuell eingefügt werden. Das kann die Lesbarkeit erhöhen. Markos können auch parametrisiert werden, dürfen aber nicht mit Unterprogrammen verwechselt werden, da sie zur Assemblierzeit textuell eingefügt werden und keine Verwaltung zur Laufzeit erfordern.

11 Die Maschinenprogrammebene eines Rechners Jörg Roth 280 Ein MIPS-Beispielprogramm:.text # Schlüsselwort für den Anfang des Programmtexts main: # Einstiegspunkt des Programms addi $s1, $zero, 20# Lade 20 in das Register $s1 ($s1 := ) sll $s1, $s1, 3 # Schiebe $s1 um 3 Bit nach links ($s1 := $s1 * 8) addi $s2, $s1, 10 # $s2 := $s1+10 Dieses Programm berechnet 20*8+10 und legt das Ergebnis in $s2 ab. Bemerkung: Dieses Programm soll lediglich die Wirkungsweise von Maschinenbefehlen illustrieren. In der Realität würde man das Ergebnis der Rechnung (170) direkt dem Register $s2 zuweisen.

12 Die Maschinenprogrammebene eines Rechners Jörg Roth CDie MIPS-Befehle Die MIPS-Befehle orientieren sich an folgenden vier Design-Prinzipien: Simplicity favors regularity ("Einfachheit bevorzugt Regelmäßigkeit"): Nur eine Befehlslänge von 32 Bit Nur drei Befehlsformate Innerhalb eines Befehlsformats: feste Anzahl von Operanden Smaller is faster ("Kleiner ist schneller"): Eine kleine Anzahl von Registern begünstigt eine schnelle Befehlsabarbeitung.

13 Die Maschinenprogrammebene eines Rechners Jörg Roth 282 Good design demands compromise ("Gutes Design erfordert einen Kompromiß"): Einiges ist unbequem, z.b. immer exakt drei Operanden für bestimmte Befehle zu haben. Einige wünschenswerte Befehle fehlen, z.b. Register-Kopien. Ein Teil der Unbequemlichkeit wird durch Pseudo-Befehle behoben. Make the common case fast ("Mache den üblichen Fall schnell"): Beispiel der Angabe von Konstanten: Für 16-Bit Konstanten ("der übliche Fall") kann MIPS dies in einem 32-Bit-Befehl ausdrücken. Für größere Konstanten ("der unübliche Fall") erfordert dies 2 Befehle.

14 Die Maschinenprogrammebene eines Rechners Jörg Roth 283 Bezeichnungen: Rd, Rs, Rt: Register $0...$31 bzw. $v0 $v1, $a0 $a3, $t0 $t7 etc. I: Direktoperand (immediate): Operand wird durch 16 Bit gegeben, die auf 32 Bit erweitert werden: Beispiel :1000 stellt den direkten Wert der Zahl 1000 dar. Hi, Lo: Multiplikations-, Divisionsergebnis Label: Sprungziel shamt: Feste Zahl von Schiebeschritten (vergleichbar mit I) Address(Rs): Zugriff auf die Speicherzelle Mem[Address+Rs], Beispiel 1000($s1) für Zugriff auf Mem(1000+$s1) Die Bedeutung der Spalte F (Format) wird weiter unten erklärt.

15 Die Maschinenprogrammebene eines Rechners Jörg Roth 284 Arithmetische Operationen: Befehl Beschreibung Vorzeichen F add Rd, Rs, Rt Rd := Rs + Rt mit R addu Rd, Rs, Rt Rd := Rs + Rt ohne R addi Rt, Rs, I Rt := Rs + I mit I addiu Rt, Rs, I Rt := Rs + I ohne I sub Rd, Rs, Rt Rd := Rs Rt mit R subu Rd, Rs, Rt Rd := Rs Rt ohne R div Rs, Rt Lo := Rs/Rt, Hi := Rs mod Rt mit R divu Rs, Rt Lo := Rs/Rt, Hi := Rs mod Rt ohne R mult Rs, Rt (Hi, Lo) := Rs Rt mit R Hi = oberen 32 Bits, Lo = unteren 32 Bits multu Rs, Rt (Hi, Lo) := Rs Rt Hi = oberen 32 Bits, Lo = unteren 32 Bits ohne R

16 Die Maschinenprogrammebene eines Rechners Jörg Roth 285 Bitweise logische Verknüpfungen: Befehl Beschreibung F and Rd, Rs, Rt Rd := Rs Rt R andi Rt, Rs, I Rt := Rs I I nor Rd, Rs, Rt Rd := Rs Rt R or Rd, Rs, Rt Rd := Rs Rt R ori Rt, Rs, I Rt := Rs I I xor Rd, Rs, Rt Rd := Rs Rt R xori Rt, Rs, I Rt := Rs I I

17 Die Maschinenprogrammebene eines Rechners Jörg Roth 286 Schiebeoperationen: Befehl Beschreibung F sll Rd, Rt, shamt Rd := Rt links-geschoben um shamt Bits R sllv Rd, Rt, Rs Rd := Rt links-geschoben um Rs Bits R srl Rd, Rt, shamt Rd := Rt rechts-geschoben um shamt Bits R srlv Rd, Rt, Rs Rd := Rt rechts-geschoben um Rs Bits R sra Rd, Rt, shamt Rd := Rt rechts-geschoben um shamt Bits R (arithmetisch, d.h. Erhaltung des Vorzeichens) srav Rd, Rt, Rs Rd := Rt rechts-geschoben um Rs Bits (arithmetisch, d.h. Erhaltung des Vorzeichens) R

18 Die Maschinenprogrammebene eines Rechners Jörg Roth 287 Vergleichen von Inhalten: Befehl Beschreibung Vorzeichen F slt Rd, Rs, Rt Rd := 1 wenn Rs < Rt, Rd := 0 wenn Rs Rt sltu Rd, Rs, Rt Rd := 1 wenn Rs < Rt, Rd := 0 wenn Rs Rt slti Rt, Rs, I Rt := 1 wenn Rs < I, Rt := 0 wenn Rs I sltiu Rt, Rs, I Rt := 1 wenn Rs < I, Rt := 0 wenn Rs I mit ohne mit ohne R R I I

19 Die Maschinenprogrammebene eines Rechners Jörg Roth 288 Laden und Speichern: Befehl Beschreibung F mfhi Rd Rd := Hi R mflo Rd Rd := Lo R lui Rt, I Rt := I 2 16 I (oberste 16 Bit = I, unterste 16 Bit = 0) lb Rt, Address(Rs) Rt := Byte in Mem[Address + Rs] I (Vorzeichen auf 32 Bit erweitert) lbu Rt, Address(Rs) Rt := Byte in Mem[Address + Rs] I (keine Vorzeichenerweiterung) sb Rt, Address(Rs) Byte in Mem[Address + Rs] := Rt I lw Rt, Address(Rs) Rt := Word in Mem[Address + Rs] I sw Rt, Address(Rs) Word in Mem[Address + Rs] := Rt I

20 Die Maschinenprogrammebene eines Rechners Jörg Roth 289 Relative Sprünge (Branch): Befehl Beschreibung Vorzeichen F beq Rs, Rt, Label Springe wenn Rs =Rt egal I bne Rs, Rt, Label Springe wenn Rs Rt egal I bgez Rs, Label Springe wenn Rs 0 mit I bgtz Rs, Label Springe wenn Rs > 0 mit I blez Rs, Label Springe wenn Rs 0 mit I bltz Rs, Label Springe wenn Rs < 0 mit I

21 Die Maschinenprogrammebene eines Rechners Jörg Roth 290 Absolute Sprünge (Jump): Befehl Beschreibung F j Label Springe J jal Label Unterprogrammaufruf J jr Rs Springe zur Adresse in Rs R jalr Rs Unterprogrammaufruf zur Adresse in Rs R Sonstige Befehle: Befehl Beschreibung F syscall Betriebssystemaufruf R break n Exception n aufrufen R

22 Die Maschinenprogrammebene eines Rechners Jörg Roth 291 Die wichtigsten Pseudobefehle: Befehl li Rd, I la Rd, Label move Rd, Rs Beschreibung Rd := I Rd := Adresse des Labels (Achtung: nicht den Inhalt der Speicherzelle kopieren, sondern die Adresse der Speicherzelle) Rd := Rs

23 Die Maschinenprogrammebene eines Rechners Jörg Roth 292 Adressierungsarten: Durch den Befehl wird die jeweilige Adressierungsart festgelegt, also die Art, wie auf einen Operanden zugegriffen wird, z.b. add: Registeradressierung addi: Direktoperand Nicht bei jeder Assemblersprache ist das so. Bei einigen Assemblersprachen gibt es ein einziges Mnemonic für verschiedene Adressierungsarten. Der Assembler erkennt dann syntaktisch die jeweilige Variante und fügt automatisch die verschiedenen Binärbefehle ein. Beispiel Z80-Assembler ADD A, B # Addiere A := A + B (A, B sind CPU-Register) ADD A, 100 # Addiere A := A (addiere Direktoperand 100) ADD A, (HL) # Addiere A := A + Mem(HL) (HL ist ein Zeigerregister)

24 Die Maschinenprogrammebene eines Rechners Jörg Roth 293 Adressierungsarten des MIPS: Direktwert (immediate): eine Zahl i, die direkt im Befehl steht Register: ein Register, darstellt durch eine Registernummer r, z.b. r =17 für $s1 Speicher: Speicherinhalt einer Adresse a: Mem[a] Register-indirekt: eine Registernummer r definiert ein Register, das als Zeiger auf eine Speicheradresse benutzt wird: Mem[$r] Register-indirekt mit Versatz: eine Registernummer r definiert eine Zeigerregister, zu dem eine Adresse a hinzuaddiert wird: Mem[a + $r] Bemerkung: MIPS stellt die Adressierungsarten Speicher und Registerindirekt immer als Register-indirekt mit Versatz dar: Speicher: Mem[a + $zero] Register-indirekt: Mem[0 + $r]

25 Die Maschinenprogrammebene eines Rechners Jörg Roth DKodierung von MIPS-Befehlen Es gibt drei Formate (siehe Spalte F in den Befehlstabellen) Jeder Befehl ist 32 Bit lang R-Format 6 Bit 5 Bit 5 Bit 5 Bit 5 Bit 6 Bit op rs rt rd shamt funct I-Format 6 Bit 5 Bit 5 Bit 16 Bit op rs rt address/immediate J-Format 6 Bit 26 Bit op address

26 Die Maschinenprogrammebene eines Rechners Jörg Roth 295 Anhand des Feldes op wird erkannt, welches Format verwendet wird R-Format: op = (000000) I-Format: alle op außer op = (000000), op = (00001*), op = (0100**) J-Format: op = (00001*) Ein weiteres Format ist für Co-Prozessor-Befehle reserviert (hier nicht behandelt): op = (0100**) Bedeutung der Felder: op, funct: op spezifiziert den Befehl (Opcode). Bei op = 0 wird funct hinzugenommen, um den Befehl zu identifizieren rs, rt, rd: Register: rs: 1. Operand (source), rt: 2. Operand bzw. Zielregister (target), rd: Zielregister (destination) shamt: Zahl von Schiebeschritten address/immediate: relative Sprungadresse oder 16-Bit Direktoperand address: Absolute Sprungadresse

27 Die Maschinenprogrammebene eines Rechners Jörg Roth 296 R-Format-Befehle: Befehl op rs rt rd shamt funct add Rd, Rs, Rt 0 rs rt rd 0 32 addu Rd, Rs, Rt 0 rs rt rd 0 33 sub Rd, Rs, Rt 0 rs rt rd 0 34 subu Rd, Rs, Rt 0 rs rt rd 0 35 div Rs, Rt 0 rs rt divu Rs, Rt 0 rs rt mult Rs, Rt 0 rs rt multu Rs, Rt 0 rs rt and Rd, Rs, Rt 0 rs rt rd 0 36 nor Rd, Rs, Rt 0 rs rt rd 0 39 or Rd, Rs, Rt 0 rs rt rd 0 37

28 Die Maschinenprogrammebene eines Rechners Jörg Roth 297 Befehl op rs rt rd shamt funct xor Rd, Rs, Rt 0 rs rt rd 0 38 sll Rd, Rt, shamt 0 0 rt rd shamt 0 sllv Rd, Rt, Rs 0 rs rt rd 0 4 srl Rd, Rt, shamt 0 0 rt rd shamt 2 srlv Rd, Rt, Rs 0 rs rt rd 0 6 sra Rd, Rt, shamt 0 0 rt rd shamt 3 srav Rd, Rt, Rs 0 rs rt rd 0 7 mfhi Rd rd 0 16 mflo Rd rd 0 18 slt Rd, Rs, Rt 0 rs rt rd 0 42 sltu Rd, Rs, Rt 0 rs rt rd 0 43 jr Rs 0 rs jalr Rs 0 rs

29 Die Maschinenprogrammebene eines Rechners Jörg Roth 298 Befehl op rs rt rd shamt funct syscall break n n 13

30 Die Maschinenprogrammebene eines Rechners Jörg Roth 299 I-Format-Befehle: Befehl op rs rt address/immediate addi Rt, Rs, I 8 rs rt immediate addiu Rt, Rs, I 9 rs rt immediate andi Rt, Rs, I 12 rs rt immediate ori Rt, Rs, I 13 rs rt immediate xori Rt, Rs, I 14 rs rt immediate lui Rt, I 15 0 rt immediate lb Rt, Address(Rs) 32 rs rt address lbu Rt, Address(Rs) 36 rs rt address sb Rt, Address(Rs) 40 rs rt address lw Rt, Address(Rs) 35 rs rt address sw Rt, Address(Rs) 43 rs rt address

31 Die Maschinenprogrammebene eines Rechners Jörg Roth 300 Befehl op rs rt address/immediate slti Rt, Rs, I 10 rs rt immediate sltiu Rt, Rs, I 11 rs rt immediate beq Rs, Rt, Label 4 rs rt address bne Rs, Rt, Label 5 rs rt address bgez Rs, Label 1 rs 1 address bgtz Rs, Label 7 rs 0 address blez Rs, Label 6 rs 0 address bltz Rs, Label 1 rs 0 address J-Format-Befehle: Befehl op address j Label 2 address jal Label 3 address

32 Die Maschinenprogrammebene eines Rechners Jörg Roth 301 Beispiel: Übersetzen des Beispielprogramms in Maschinensprache Befehlszeile F op rs rt rd shamt funct addi $s1,$zero,20 I sll $s1,$s1,3 R addi $s2,$s1,10 I adr/ imm Maschinenbefehl (Hex) C A

33 Die Maschinenprogrammebene eines Rechners Jörg Roth E Die SPIM-Umgebung SPIM ist ein Simulationswerkzeug für MIPS-Prozessoren Es enthält einen Assembler und eine Laufzeitumgebung Da das Wirtsystem (z.b. Windows) auf einem anderen Prozessor basiert, werden die MIPS-Maschinenbefehle zur Laufzeit auf einem virtuellen Prozessor simuliert.

34 Die Maschinenprogrammebene eines Rechners Jörg Roth 303 SPIM-Funktionen: Anzeigen von Register- und Speicherinhalten Zeigen des assemblierten Programms Durchlaufen des Codes im Einzelschrittmodus Setzen von Break-Points Über syscall kann aus dem Maschinenprogramm heraus eine rudimentäre Konsole angesprochen werden Ein/Ausgabe von Zahlen Ein/Ausgaben von Zeichenketten

35 Die Maschinenprogrammebene eines Rechners Jörg Roth 304 Direktiven des SPIM-Assemblers an einem Beispiel:.data # Schlüsselwort für den statischen Datenteil label1:.word 1000 # Anlegen des 32-Bit-Wortes mit dem Wert 1000 label2:.byte 10 # Anlegen des Bytes mit dem Wert 10 label3:.byte a # Anlegen des Bytes mit dem ASCII-Wert für a label3:.space 15 # Anlegen von 15 Bytes mit dem Wert 0 label4:.asciiz "Dies ist ein Text" # Anlegen eines 0-terminierten Strings.text # Schlüsselwort für den Programmtext main: addi... # Ein Programm muss diesen Einstiegspunkt haben # Ab hier stehen die Assemblerbefehle

36 Die Maschinenprogrammebene eines Rechners Jörg Roth 305 Die wichtigsten SPIM syscalls Nr. $v0 Beschreibung 1 32-Bit-Zahl dezimal auf die Konsole ausgeben 4 0-terminierten String auf die Konsole ausgeben 5 32-Bit-Zahl dezimal von der Konsole einlesen 8 String von der Konsole einlesen und 0-terminiert in Puffer ablegen Aufrufargument Rückgabewert $a0 = Wert der Zahl $a0 = Adresse des Strings $v0 = Wert der Zahl $a0 = Adresse des Stringpuffers $a1 = Länge des Stringpuffers 9 Dynamischen Speicher allozieren $a0 = Länge des Blocks $v0 = Adresse des Blocks 10 Programm beenden

37 Die Maschinenprogrammebene eines Rechners Jörg Roth 306 Bemerkungen zu den SPIM syscalls: Ein Programm terminiert automatisch nach der letzten Befehlszeile. syscall 10 wird nur benötigt, wenn man das Programm vorher beenden möchte. Alternativ kann man hinter den letzten Befehl springen. Die syscalls zur Zahlen-Ein/Ausgabe verwenden Register für die Zahlenspeicherung. Die syscalls zu der String-Ein/Ausgabe legen die Zeichenketten im Speicher ab (nicht in den Registern). Über das Register $a0 wird die Adresse des Strings bzw. des freien Stringpuffers angegeben.

38 Die Maschinenprogrammebene eines Rechners Jörg Roth 307 Beispiel:.data prompt:.asciiz "Bitte Zahl eingeben: " text1:.asciiz "Sie haben die Zahl " text2:.asciiz " eingegeben\n".text main: li $v0, 4 la $a0,prompt syscall li $v0, 5 syscall or $s0, $zero, $v0 # String ausgeben # "Bitte Zahl eingeben: # Zahl einlesen # $s0 := Eingabe;

39 Die Maschinenprogrammebene eines Rechners Jörg Roth 308 li $v0, 4 # String ausgeben la $a0,text1 # "Sie haben die Zahl " syscall li $v0, 1 or $a0, $zero, $s0 syscall li $v0, 4 la $a0,text2 syscall li $v0, 10 syscall # Resultat ausgeben # in $s0 stand die Zahl # String ausgeben # " eingegeben\n" # Programm beenden

40 Die Maschinenprogrammebene eines Rechners Jörg Roth F Die Maschinenbefehle im Detail 5.F.a Arithmetische Operationen Addition und Subtraktion: Befehl Beschreibung Vorzeichen add Rd, Rs, Rt Rd := Rs + Rt mit addu Rd, Rs, Rt Rd := Rs + Rt ohne addi Rt, Rs, I Rt := Rs + I mit addiu Rt, Rs, I Rt := Rs + I ohne sub Rd, Rs, Rt Rd := Rs Rt mit subu Rd, Rs, Rt Rd := Rs Rt ohne

41 Die Maschinenprogrammebene eines Rechners Jörg Roth 310 Bemerkungen: Zahlendarstellung: 32 Bit-Zweierkomplement Es gibt kein subi und subiu. Stattdessen verwendet man addi und addiu und muss den immediate-operanden von Hand negieren. Z.B. addi $s0, $s0, -1 um 1 von $s0 abzuziehen add und addu addieren intern identisch. add erzeugt aber eine Exception, wenn das Resultat das falsche Vorzeichen erhält (Overflow-Bedingung). addu produziert keine Exception, auch wenn ein Übertrag generiert wird.

42 Die Maschinenprogrammebene eines Rechners Jörg Roth 311 Beispiele: li $s0, # = 2^31-1 addiu $s1, $s0, 1 # bei unsigned addition Resultat: $s1= li $s0, addi $s1, $s0, 1 Resultat: Arithmetic Overflow # maximale positive Zahl # Resultat bekommt falsches Vorzeichen li $s0, # maximale 32-Bit-Zahl addiu $s1, $s0, 1 # Übertrag wird ignoriert Resultat: $s1=0 (Bemerkung: würde auch bei addi entstehen)

43 Die Maschinenprogrammebene eines Rechners Jörg Roth 312 Multiplikation und Division: Befehl Beschreibung Vorzeichen div Rs, Rt Lo := Rs/Rt, Hi := Rs mod Rt mit divu Rs, Rt Lo := Rs/Rt, Hi := Rs mod Rt ohne mult Rs, Rt (Hi, Lo) := Rs Rt mit Hi = oberen 32 Bits, Lo = unteren 32 Bits multu Rs, Rt (Hi, Lo) := Rs Rt Hi = oberen 32 Bits, Lo = unteren 32 Bits ohne Bemerkungen: Es gibt keine Mult-, Div-Befehle mit immediate-operand. Das Ergebnis einer 32-Bit-Multiplikation benötigt 64 Bit. Daher existieren zwei 32-Bit-Register Hi und Lo, die die Resultate aufnehmen. Diese Register können nicht explizit beschrieben werden.

44 Die Maschinenprogrammebene eines Rechners Jörg Roth 313 multu behandelt die Operanden als vorzeichenlose Zahlen, mult als Vorzeichenzahlen. Es kann kein Überlauf oder Übertrag produziert werden, also auch keine Exceptions. Im Ggs. zu add/addu werden intern unterschiedliche Operationen durchgeführt, je nachdem ob man Vorzeichenzahlen oder vorzeichenlose Zahlen verwendet. Beispiel: li $s0, # 2^32-1 entspricht -1 li $s1, # 2^32-1 entspricht -1 mult $s0, $s1 Resultat (Hi, Lo) = 1 li $s0, li $s1, # 2^32-1 (max. 32-Bit-Zahl) # 2^32-1 (max. 32-Bit-Zahl) multu $s0, $s1 Resultat (Hi, Lo) =

45 Die Maschinenprogrammebene eines Rechners Jörg Roth F.bLogische Operationen Bitweise logische Verknüpfungen Befehl and Rd, Rs, Rt andi Rt, Rs, I nor Rd, Rs, Rt or Rd, Rs, Rt ori Rt, Rs, I xor Rd, Rs, Rt xori Rt, Rs, I Beschreibung Rd := Rs Rt Rt := Rs I Rd := Rs Rt Rd := Rs Rt Rt := Rs I Rd := Rs Rt Rt := Rs I

46 Die Maschinenprogrammebene eines Rechners Jörg Roth 315 Illustration am Beispiel des and-befehls: rs... rt... & & & & rd... Bemerkungen: Es gibt keinen immediate Befehl für nor. Es gibt keine Befehle für nand und xnor.

47 Die Maschinenprogrammebene eines Rechners Jörg Roth 316 Möglichkeiten für das Komplementieren von Bits: Beispiel: $s1 := $s0 nor $s1, $s0, $s0 xori $s1, $s0, -1 # -1 = FFFF FFFF, Achtung: nur 16 Bit komplementiert Bemerkungen: Der "native" xori-befehl verwendet (wie alle immediate-befehle) nur 16- Bit-Immediate-Operanden. Damit werden nur die unteren 16 Bit komplementiert. Verwendet man xori mit einem Operanden mit mehr als 16 Bit, so erkennt der Assembler das und verwendet automatisch einen Pseudobefehl: Laden der oberen 16 Bit in das $at-register (Befehl lui) Laden der unteren 16 Bit in das $at-register (Befehl ori) Verwenden der xor-operation (nicht xori) mit Register $at

48 Die Maschinenprogrammebene eines Rechners Jörg Roth 317 Wozu benötigt man bitweise logische Verknüpfungen? Beispiel Mauszeiger: Maske: alle Bits des Bildschirms müssen auf 0 gesetzt werden Zeigerbits Maskenbits Mauszeiger: alle Bits des Bildschirms müssen auf 1 gesetzt werden Bildschirm Bildschirm UND Maske Bildschirm UND Maske ODER Maus

49 Die Maschinenprogrammebene eines Rechners Jörg Roth 318 Das zugehörige Programm: Die 64 Zeigerbits seien in $s0, $s1 gespeichert Die 64 Maskenbits seien in $s2, $s3 gespeichert Die 64 Bildschirmbits unter dem Zeiger seien schon aus dem Bildspeicher in $s4, $s5 abgelegt nor $s2, $s2, $s2 # Maskenbits invertieren nor $s3, $s3, $s3 and $s4, $s4, $s2 # Bildschirm UND Komplement der Maske and $s5, $s5, $s3 # d.h. alle Bild-Bits außerhalb der Maske =0 or $s4,$s4, $s0 # Resultat ODER Mauszeiger or $s5,$s5, $s1 # damit werden alle Bild-Bits des Zeigers =1

50 Die Maschinenprogrammebene eines Rechners Jörg Roth 319 Schiebeoperationen: Befehl Beschreibung sll Rd, Rt, shamt Rd := Rt links-geschoben um shamt Bits sllv Rd, Rt, Rs Rd := Rt links-geschoben um Rs Bits srl Rd, Rt, shamt Rd := Rt rechts-geschoben um shamt Bits srlv Rd, Rt, Rs Rd := Rt rechts-geschoben um Rs Bits sra Rd, Rt, shamt Rd := Rt rechts-geschoben um shamt Bits (arithmetisch, d.h. Erhaltung des Vorzeichens) srav Rd, Rt, Rs Rd := Rt rechts-geschoben um Rs Bits (arithmetisch, d.h. Erhaltung des Vorzeichens)

51 Die Maschinenprogrammebene eines Rechners Jörg Roth 320 Illustration der Schiebeoperationen mit shamt=1 sll srl rt... rt... rd rd... sra rt... rd... Verwendung der Schiebebefehle: Operanden multiplizieren mit 2 shamt, dividieren durch 2 shamt Umwandlung serielle Daten parallele und umgekehrt Zugriff auf Inhalte "gepackter" Strukturen

52 Die Maschinenprogrammebene eines Rechners Jörg Roth 321 Beispiel: Pixel-Information eines High-Color-Bildes (16 Bit/Pixel): Jeder Pixel enthält folgende Informationen: 5 Bit-Wert für "rot" 6 Bit-Wert für "grün" 5 Bit-Wert für "blau" rot grün blau (Es gibt eine Reihe weiterer Möglichkeiten, z.b. True-Color mit 32 Bit)

53 Die Maschinenprogrammebene eines Rechners Jörg Roth 322 Das zugehörige Programm: Der Pixelwert sei schon in $s0 Wir wollen rot in $t0, grün in $t1 und blau in $t2 speichern srl $t0, $s0, 11 andi $t1, $s0, 0x07e0 srl $t1, $t1, 5 andi $t2, $s0, 0x001f # oberen 5 Bits (rot) nach rechts schieben # mittleren 6 Bits (grün) herauskopieren # und nach rechts schieben # unteren 5 Bits (blau) herauskopieren

54 Die Maschinenprogrammebene eines Rechners Jörg Roth F.c Vergleiche Befehl Beschreibung Vorzeichen slt Rd, Rs, Rt Rd := 1 wenn Rs < Rt, Rd := 0 wenn Rs Rt sltu Rd, Rs, Rt Rd := 1 wenn Rs < Rt, Rd := 0 wenn Rs Rt slti Rt, Rs, I Rt := 1 wenn Rs < I, Rt := 0 wenn Rs I sltiu Rt, Rs, I Rt := 1 wenn Rs < I, Rt := 0 wenn Rs I mit ohne mit ohne

55 Die Maschinenprogrammebene eines Rechners Jörg Roth 324 Motivation für die slt-befehle: Es gibt (siehe weiter unten) keine bedingten Sprünge, die den Größenvergleich zweier Operanden durchführen. Vergleich und Sprung führt man daher so aus: slt $t0, $s0, $s1 # $t0 := 1 wenn $s0 <$s1 bgtz $t0, Label # Springe wenn $t0 > 0 (d.h. $s0 <$s1)

56 Die Maschinenprogrammebene eines Rechners Jörg Roth 325 Weiteres Beispiel: In den Registern $t0, $t1, $t2 sind drei Zahlen abgelegt. Zähle, wie viele dieser drei Zahlen kleiner als 100 sind. Ablage in $s0 slti $s0, $t0, 100 # $s0 := 1 wenn $t0 <100 slti $s1, $t1, 100 # $s1 := 1 wenn $t1 <100 add $s0, $s0, $s1 # $s0 := Summe der ersten beiden Ergebnisse slti $s1, $t2, 100 # $s1 := 1 wenn $t2 <100 add $s0, $s0, $s1 # $s0 := Summe alle Ergebnisse

57 Die Maschinenprogrammebene eines Rechners Jörg Roth 326 Weitere Funktion von sltu: Berechnen des Übertrags In MIPS gibt es kein Carry-Bit, wie in den meisten anderen CPUs. Man erkennt daher nicht auf einfache Weise, ob ein Übertrag bei einer Addition entstanden ist. Berechnung des Carry-Bits in $t0, $t1 seien positive Zahlen gespeichert: addu $t2, $t0, $t1 sltu $t3, $t2, $t1 # Teste, ob die Summe kleiner ist als $t1 Danach: $t2: Summe von $t0, $t1 (mod 2 32 ) $t3: 1, wenn Übertrag aufgetreten ist

58 Die Maschinenprogrammebene eines Rechners Jörg Roth F.d Laden und Speichern Befehl mfhi Rd mflo Rd Rd := Hi Rd := Lo Beschreibung lui Rt, I Rt := I 2 16 (oberste 16 Bit = I, unterste 16 Bit = 0) lb Rt, Address(Rs) Rt := Byte in Mem[Address + Rs] (Vorzeichen auf 32 Bit erweitert) lbu Rt, Address(Rs) Rt := Byte in Mem[Address + Rs] (keine Vorzeichenerweiterung) sb Rt, Address(Rs) Byte in Mem[Address + Rs] := Rt lw Rt, Address(Rs) Rt := Word in Mem[Address + Rs] sw Rt, Address(Rs) Word in Mem[Address + Rs] := Rt

59 Die Maschinenprogrammebene eines Rechners Jörg Roth 328 Bemerkungen: Es gibt keinen nativen Befehl für das Laden von immediate-operanden li ist ein Pseudobefehl, der intern auf ori...,$zero,... abgebildet wird. Um 32-Bit-Konstanten in Register zu kopieren, reichen die 16-Bit in einem Befehl (I-Format) nicht aus. Deshalb gibt es den Befehl lui, der die oberen 16 Bit eines Registers mit dem immediate-operanden füllt. Die untere Hälfte kann dann mit ori... gefüllt werden. lb, lw (bzw. sb, sw) unterscheiden sich in der Bit-Breite des Zugriffs: lb, sb: 8 Bit, lw, sw: 32 Bit Da bei lb nur 8 Bit des 32-Bit-Registers belegt werden, kann man entscheiden, wie die übrigen 24 Bit gesetzt werden: lbu: restliche 24 Bit werden auf 0 gesetzt lb: restliche 24 Bit werden auf Bit 7 (Vorzeichenbit) gesetzt Bei sb werden die Bits 8-31 des Registers beim Speichern ignoriert.

60 Die Maschinenprogrammebene eines Rechners Jörg Roth 329 Die Befehle lb, lbu, lw, sb, sw benutzen die Adressierungsart Registerindirekt mit Versatz. Da der Versatz als immediate-operator definiert wird, kann nur ein Versatz von bis ausgedrückt werden. Daher kann z.b. der Befehl lb $s0, nicht direkt übersetzt werden, da der immediate-operand größer ist als Der Assembler erkennt dies und wertet in diesem Fall lb als Pseudobefehl aus: lui $at, 1 # $at = lb $s0, ($at)# $s0 := Mem[ ] = Mem[50000] Jedes Wort belegt 4 Byte. Die Adressierung basiert auf Bytes. Sollen Worte adressiert werden, die direkt hintereinander im Speicher liegen, muss man die Adresse jeweils um 4 erhöhen.

61 Die Maschinenprogrammebene eines Rechners Jörg Roth 330 Beispiel:.data word1:.word 10 word2:.word 11.text main: la $s0,word1 lw $t0,0($s0) lw $t1,4($s0) # Zwei Worte direkt hintereinander im Speicher # Lade die Adresse des ersten Wortes # Lade erstes Wort # Lade zweites Wort

62 Die Maschinenprogrammebene eines Rechners Jörg Roth F.e Sprungbefehle Befehl Beschreibung Vorzeichen beq Rs, Rt, Label Springe wenn Rs =Rt egal bne Rs, Rt, Label Springe wenn Rs Rt egal bgez Rs, Label Springe wenn Rs 0 mit bgtz Rs, Label Springe wenn Rs > 0 mit blez Rs, Label Springe wenn Rs 0 mit bltz Rs, Label Springe wenn Rs < 0 mit j Label Springe jal Label Unterprogrammaufruf nicht jr Rs Springe zur Adresse in Rs anwendbar jalr Rs Unterprogrammaufruf zur Adresse in Rs

63 Die Maschinenprogrammebene eines Rechners Jörg Roth 332 Bemerkungen: Da jeder MIPS-Befehl 32 Bits umfasst, liegen die Befehle immer passend auf 4-Byte-Blöcken. Die Adresse des ersten Bytes eines Befehls ist damit immer durch 4 teilbar (4 byte alignment). Da die möglichen Sprungziele immer binär auf 00 enden, müssen diese Bits nicht angegeben werden und man definiert nur die Bits ab Bit2 aufwärts. Die branch-befehle (b...) verwenden relative Sprungziele. Der immediate-operand definiert den Abstand zur Adresse des aktuellen Befehls. Negative Distanz: Sprung vor den aktuellen Befehl. Positive Distanz: Sprung hinter den aktuellen Befehl. Der Bereich für immediate-operanden ist bis Dieser wird mit 4 multipliziert (wegen alignment) und zur aktuellen Befehlsadresse hinzugezählt. Es sind damit Sprungweiten von ca. +/-128k möglich

64 Die Maschinenprogrammebene eines Rechners Jörg Roth 333 Beispiele: Sprung zurück: loop: add $s0, $s1, $s2 beq $s0,$s1,loop# Sprungweite -4, kodiert als immediate-op. -1 Sprung nach vorne: beq $s0,$s1,labx # Sprungweite +8, kodiert als immediate-op. 2 add $s0, $s1, $s2 labx: add $s0, $s1, $s2 Der Assembler-Entwickler gibt auch bei relativen Sprüngen ein Label als Ziel an. Der Assembler berechnet automatisch die Distanz und meldet ggfs. einen Fehler wenn der Sprung zu weit geht.

65 Die Maschinenprogrammebene eines Rechners Jörg Roth 334 Bemerkungen zu absoluten Sprüngen: Die j...-befehle verwenden absolute Sprungadressen. Absolute Adressen in den J-Format-Befehlen haben 26 Bit. Da die letzten 2 Bits 00 lauten, sind Sprünge im Bereich 2 28 (0 256 MB) möglich. Die MIPS Architektur ermöglicht zwar einen Adressraum von 2 32 Bytes (4GB), die Adressen oberhalb von 256 MB können allerdings nicht mit den J-Format-Sprüngen erreicht werden. Die Sprungbefehle mit Registerinhalten (jr, jalr) und relative Sprünge kennen diese Grenze zwar nicht, dennoch wird nur der Bereich bis 256 MB als Text-Segment (der Code-Bereich) definiert. Die Befehle jal und jalr funktionieren wie j bzw. jr. Vor dem Sprung wird aber die aktuelle Befehlsadresse + 4 in das Register $ra geschrieben. Damit sind Unterprogramme möglich, die nach der Beendigung mit jr $ra hinter den Aufrufbefehl springen.

66 Die Maschinenprogrammebene eines Rechners Jörg Roth F.f Pseudobefehle Pseudobefehle sind nicht nativ im MIPS-Prozessor realisiert. Sie vereinfachen die Assembler-Programmierung und erhöhen die Lesbarkeit von Assembler-Programmen. Die Menge von Pseudo-Befehlen ist je nach Assembler unterschiedlich. Auch die Übersetzung von Pseudo-Befehlen in native Befehle ist unterschiedlich. Typische MIPS-Pseudobefehle werden in 1, 2 oder 3 native Befehle übersetzt.

67 Die Maschinenprogrammebene eines Rechners Jörg Roth 336 Einige Pseudobefehle: Befehl Beschreibung Realisierung li Rd, I Rd := I ori Rd, $zero, I # 16-Bit-I oder lui $at, I ( ) ori Rd, $at, I (15...0) # 32-Bit-I la Rd, Label Rd := Adresse des Labels Wie li, der Assembler verhindert aber das Auswerten von "Label" la kann ohne Hilfe des Assemblers nicht durch andere Befehle ersetzt werden! move Rd, Rs Rd := Rs or Rd, $zero, Rs nop tue nichts or $zero, $zero, $zero oder sll $zero, $zero, 0

68 Die Maschinenprogrammebene eines Rechners Jörg Roth 337 b Label Befehl Beschreibung Realisierung addi Rt, Rs, I andi Rt, Rs, I ori Rt, Rs, I... lb Rt, Addr(Rs) lbu Rt, Addr(Rs) lw Rt, Addr(Rs) sb Rt, Addr(Rs) sw Rt, Addr(Rs) Relativer Sprung...i-Befehle mit 32-Bit-I-Operand wie lb etc., nur dass Addr mit mehr als 16 Bit beq $zero, $zero, Label lui $at, I ( ) ori $at, $at, I (15...0) add Rt, Rs, $at lui $at, Hi-Addr lb $s0, Lo-Addr($at) # bzw. lbu, lw, sb, sw # bzw. and, or...

69 Die Maschinenprogrammebene eines Rechners Jörg Roth F.g Speicherorganisation Aufteilung des verfügbaren Adressraums: 0x Reserviert 4 MB 0x MB Text Segment 0x $gp = 0x Statische Daten 64 kb 0x Dynamische Daten ca. 1,8 GB $sp Stapel 0x7FFF FFFF 0x Reserviert 2 GB 0xFFFF FFFF

70 Die Maschinenprogrammebene eines Rechners Jörg Roth 339 Bemerkungen: Die Bereiche vor 0x und ab 0x sind reserviert. Der verbleibende Bereich bis 0x ist das Text Segment, in dem sich der Programmcode befindet. Sprungbefehle nach dem J-Format können keine größeren Adressen anspringen. Im Bereich statischer Daten verweist $gp auf die Mitte. Damit können Speicherzugriffe ohne Pseudobefehle mit nur einem Befehl formuliert werden. Z.B. lw $s0, -0x8000($gp) # Zugriff auf Adresse 0x Da der Bereich statischer Daten 64k umfasst, kann man mit einem 16-Bit- Offset den gesamten Bereich adressieren. Ohne $gp würde dieser Zugriff zwei Befehle erfordern: lui $at, 4096 # entspricht 0x lw $s0,0($at)

71 Die Maschinenprogrammebene eines Rechners Jörg Roth 340 Der Stapel und der Bereich dynamischer Daten wachsen in entgegengesetzer Richtung. Damit steht bei ungleicher Benutzung beiden Bereiche immer der maximale Rest zur Verfügung. Der Bereich dynamischer Daten wird vom Betriebssystem verwaltet. Es gibt keine Register im MIPS, die diese Verwaltung unterstützen. Der Stapel wächst per Konvention in die Richtung niedriger Adressen. $sp zeigt auf das zuletzt gefüllte Stapel-Element. Der Stapel muss nicht unbedingt bei 0x7FFF FFFF beginnen. Stehen weniger als 2GB Speicher zur Verfügung kann der Stapel auch bei einer kleineren Adressen beginnen.

72 Die Maschinenprogrammebene eines Rechners Jörg Roth GTypische Anwendungsfälle Wir betrachten im Folgenden typische Fälle aus dem Bereich imperativer Programmiersprachen und beschreiben, wie diese in MIPS-Assembler realisiert werden. Compiler, die höhere Programmiersprachen in Maschinensprache übersetzen, müssen über ein Regelwerk verfügen, die Programmstrukturen in Maschinensprache-Sequenzen zu übersetzen.

73 Die Maschinenprogrammebene eines Rechners Jörg Roth G.aif-then-else Höhere Programmiersprache: if (<Bedingung>) then <Anweisungen1> else <Anweisungen2> Assembler:... # Code um die Bedingung zu berechnen b... else # Bedingung, um in den Else-Zweig zu springen... # Code der Anweisungen1 j exit else:... # Code für Anweisungen2 exit: Bemerkung: Das in imperativen Sprachen verpönte "goto" ist die einzige Möglichkeit in Maschinensprache Kontrollstrukturen abzubilden.

74 Die Maschinenprogrammebene eines Rechners Jörg Roth 343 Weitere Bemerkung: Labels müssen global eindeutig sein. Verwendet man mehrere der dargestellten Strukturen, müssen die Labels "else" und "exit" z.b. durch Nummern ("else1" etc.) eindeutig gemacht werden. Konkretes Beispiel: if ($s1<$s2) then $s3:=$s3+1; else $s4:=2*$s4; Assembler: slt $t0, $s1, $s2 # $t0=1 wenn $s1<$s2 beq $t0, $zero, else # wenn $t0=0: else-zweig addi $s3,$s3,1 # then-zweig j exit # an das Ende springen else: add $s4, $s4, $s4 # else-zweig exit:

75 Die Maschinenprogrammebene eines Rechners Jörg Roth G.bswitch-case Höhere Programmiersprache: switch (<int-variable>) case 0:<Anweisungen0> case 1:<Anweisungen1>... case n:<anweisungenn> Idee: Wir legen alle möglichen Sprungziele case 0, case 1,... case n in einem Feld ab. Wir laden anhand der Variablen das richtige Sprungziel und springen mit jr.

76 Die Maschinenprogrammebene eines Rechners Jörg Roth 345 Assembler: sll $t0, $t0, 2 # $t0*4 ($t0 sei der switch-wert) la $t1, jumptable add $t0, $t0, $t1 # Berechne switch-wert*4+adr(jumptable) lw $t0, 0($t0) # Lade jumptable[<switch-wert>] jr $t0 # Springe gemäß Registerinhalt case0:... # Code der Anweisungen0 j exit case1:... # Code der Anweisungen1 j exit... casen:... # Code der Anweisungenn exit:

77 Die Maschinenprogrammebene eines Rechners Jörg Roth 346 Konkretes Beispiel: switch ($t0) case 0: $s3:=$s3+1; case 1: $s4:=2*$s4; case 2: $s5:=0; Assembler: sll $t0, $t0, 2 # $t0*4 ($t0 sei der switch-wert) la $t1, jumptable add $t0, $t0, $t1 # Berechne switch-wert*4+adr(jumptable) lw $t0, 0($t0) # Lade jumptable[<switch-wert>] jr $t0 # Springe gemäß Registerinhalt case0: addi $s3,$s3,1 # Code für case 0 j exit

78 Die Maschinenprogrammebene eines Rechners Jörg Roth 347 case1: add $s4, $s4, $s4# Code für case 1 j exit case2: li $s5,0 # Code für case 2 exit: Bemerkungen: Es wird keine Überprüfung durchgeführt, ob der switch-wert innerhalb der erwarteten Grenzen liegt. In der aktuellen Fassung sind die Ergebnisse bei einer Bereichsverletzung nicht vorhersehbar (und in der Regel katastrophal). Die Sprungtabelle muss vor der ersten Benutzung initialisiert werden:

79 Die Maschinenprogrammebene eines Rechners Jörg Roth 348.data jumptable:.space 12 # Platz für 3 Adressen.text main: la $s0, jumptable # Adresse der Sprungtabelle in $s0 la $t1, case0 sw $t1,0($s0) # Zieladresse in jumptable[0] ablegen la $t1, case1 sw $t1,4($s0) # Zieladresse in jumptable[1] ablegen la $t1, case2 sw $t1,8($s0) # Zieladresse in jumptable[2] ablegen...

80 Die Maschinenprogrammebene eines Rechners Jörg Roth 349 Bemerkung: Diese Initialisierung muss nicht zur Laufzeit erfolgen. Viel effizienter ist, die Sprungadressen schon zur Laufzeit durch den Assembler eintragen zu lassen. Die resultierende Code-Variante:.data jumptable:.word case0.word case1.word case2.text main:... # Code vor switch

81 Die Maschinenprogrammebene eines Rechners Jörg Roth 350 sll $t0, $t0, 2 # $t0*4 ($t0 sei der switch-wert) la $t1, jumptable add $t0, $t0, $t1 # Berechne switch-wert*4+adr(jumptable) lw $t0, 0($t0) # Lade jumptable[<switch-wert>] jr $t0 # Springe gemäß Registerinhalt case0: addi $s3,$s3,1 # Code für case 0 j exit case1: add $s4, $s4, $s4# Code für case 1 j exit case2: li $s5,0 # Code für case 2 exit:... # Code nach switch

82 Die Maschinenprogrammebene eines Rechners Jörg Roth G.c while- und for-schleifen Höhere Programmiersprache: while (<Bedingung>) <Anweisungen> Assembler: loop:... # Code um die Bedingung zu berechnen b... exit # Bedingung, um in die Schleife zu verlassen... # Code der Anweisungen j loop # Schleife wiederholen exit:

83 Die Maschinenprogrammebene eines Rechners Jörg Roth 352 Konkretes Beispiel: while ($s1<$s2) $s1:=$s1+1; $s3:=$s3+1; Assembler: loop: slt $t0, $s1, $s2 # $t0=1 wenn $s1<$s2 beq $t0, $zero, exit # wenn $t0=0: Schleife verlassen addi $s1,$s1,1 # Code der Anweisungen addi $s3,$s3,1 j loop # Schleife wiederholen exit:

84 Die Maschinenprogrammebene eines Rechners Jörg Roth 353 Höhere Programmiersprache: for i:=<startwert> to <endwert> do <Anweisungen> Assembler: li $t0,<startwert> # Zähler initialisieren, $t0 sei die Zählvariable li $t1,<endwert+1> # $t1 sei <endwert+1> loop: beq $t0,$t1,exit # Endwert schon abgearbeitet... # Code der Anweisungen addi $t0,$t0,1 # Zähler inkrementieren j loop # Schleife wiederholen exit: Bemerkung: diese Konstruktion überprüft nicht, ob der Endwert erreicht werden kann. Gibt man einen endwert<startwert an, rechnet die Schleife bis $t0 nach einem Überlauf den endwert erreicht.

85 Die Maschinenprogrammebene eines Rechners Jörg Roth 354 Konkretes Beispiel: for $t0:=1 to 10 do $t2:=$t2*2; Assembler: li $t0,1 li $t1,11 loop: beq $t0,$t1,exit add $t2,$t2,$t2 addi $t0,$t0,1 j loop exit: # Zähler initialisieren, $t0 sei die Zählvariable # $t1 sei <endwert+1> # Endwert schon abgearbeitet # Code der Anweisungen # Zähler inkrementieren # Schleife wiederholen

86 Die Maschinenprogrammebene eines Rechners Jörg Roth G.dZugriff auf Arrays, Strings Höhere Programmiersprache: Schreiben eines Array-Elements: array[index] := wert Lesen eines Array-Elements: variable := array[index] Bemerkung: Für die Entwicklung in Maschinensprache muss der Entwickler wissen, wie viele Bytes der zugrunde liegende Datentyp beansprucht, um auf ein bestimmtes Element zugreifen zu können. In höheren Programmiersprachen wird diese Information beim Array-Zugriff verborgen.

87 Die Maschinenprogrammebene eines Rechners Jörg Roth 356 Konkretes Beispiel: Variablen: wordarray: ARRAY [0..2] OF WORD = {1, 2, 3}; bytearray: ARRAY[0..2] OF BYTE = {7, 8, 9}; $s0 := wordarray[$t0]; $s1 := bytearray[$t1]: Assembler:.data wordarray:.word 1.word 2.word 3 bytearray:.byte 7.byte 8.byte 9

88 Die Maschinenprogrammebene eines Rechners Jörg Roth 357.text main:... la $t2, wordarray sll $t0, $t0, 2 # $t0*4 ($t0 sei der Index für wordarray) add $t0, $t0, $t2 # $t0 := wordarray+4*index lw $s0, 0($t0) # $s0 := wordarray[$t0] la $t2, bytearray add $t1, $t1, $t2 # $t1 := bytearray+1*index lb $s1, 0($t1) # $s1 := wordarray[$t1] Bemerkung: Es findet keine Erkennung auf Bereichsverletzungen statt. Damit kann man u.u. auf andere Daten oder sogar Code zugreifen. Programme, die keinen Bereichstest durchführen führen u.u. zu unmotivierten Abstürzen oder sind für bösartige Software angreifbar.

89 Die Maschinenprogrammebene eines Rechners Jörg Roth 358 Strings Strings werden wie byte-arrays flexibler Länge behandelt. Die Länge eines Strings erkennt man entweder durch ein spezielles Zeichen (in der Regel 0), wie in der Programmiersprache C oder durch eine vorangestellte Längenangabe wie in Pascal. Da man einen String häufig zeichenweise durchläuft, bietet es sich an, einen Zeiger auf das aktuelle Zeichen zu verwalten, der zeichenweise weitergeschaltet wird.

90 Die Maschinenprogrammebene eines Rechners Jörg Roth 359 Möglichkeiten des Zeichenzugriffs in Strings: Zugriff über zwei Register Speicher h a l l o 0x00 + $t0 $t1 Register adr 2 Zugriff über einen Zeiger Speicher h a l l o 0x00 Register $t0 adr+2

91 Die Maschinenprogrammebene eines Rechners Jörg Roth 360 Konkretes Beispiel: Variable text: String="halloABC"; $s0=strlen(text); // Länge des Strings bestimmen text=toupper(text); // Alle Zeichen nach "groß" konvertieren (z.b. a -> A ) Assembler:.data text:.asciiz "halloabc".text main: la $t0,text # Pointer auf String-Anfang setzen li $s0,0 # Anzahl der Zeichen auf 0 setzen loop1: lb $t1,0($t0) # Lade Zeichen beq $t1,$zero,toupper # Wenn 0: Zählen fertig addi $s0,$s0,1 # Weiterzählen addi $t0,$t0,1 # Pointer weiterschalten j loop1

92 Die Maschinenprogrammebene eines Rechners Jörg Roth 361 toupper: la $t0,text # Pointer auf String-Anfang setzen loop2: lb $t1,0($t0) # Lade Zeichen beq $t1,$zero,end # Wenn 0: Zählen fertig andi $t1, $t1, 223 # Nach UpperCase verwandeln sb $t1, 0($t0) # und Zeichen zurückspeichern addi $t0,$t0,1 # Pointer weiterschalten j loop2 end:

93 Die Maschinenprogrammebene eines Rechners Jörg Roth G.e Unterprogramme Unterprogramme können wie in höheren Programmiersprachen von verschiedenen Aufrufstellen aus aufgerufen werden. So kann man eine häufig benutzte Funktion einmal im Speicher ablegen und beliebig häufig benutzen. Im Gegensatz zu höheren Programmiersprachen muss der Entwickler aber die Organisation des Aufrufs (insb. Rücksprung, Parameterübergabe, Retten von lokalen Variablen) selbst vornehmen.

94 Die Maschinenprogrammebene eines Rechners Jörg Roth 363 Ablauf von Unterprogramm-Aufrufen: Hinterlegen der Parameter in die vorgesehenen Register ($a0 $a3). jal Unterprogramm-Label damit wird die Adresse des nächsten Befehls automatisch in $ra geschrieben. Im Unterprogramm: Wenn notwendig, Register auf Stapel sichern (insb. $s0 $s7 und $ra). Die eigentliche Funktion berechnen. Potenzielle Rückgabewerte in $v0 $v1 ablegen. Gesicherte Register zurücklesen. jr $ra damit wird in das aufrufende Programm zurückgesprungen (genau hinter den Befehl jal...).

95 Die Maschinenprogrammebene eines Rechners Jörg Roth 364 Beispiel Speicherinhalte tauschen.data word1:.word 100 word2:.word 200 word3:.word 400 word4:.word 500 swap:.text lw $t0, 0($a0) lw $t1, 0($a1) sw $t0, 0($a1) sw $t1, 0($a0) jr $ra # Unterprogramm zum Tauschen von Inhalten # 1. Wort in Register laden # 2. Wort in Register laden # umgekehrt zurückspeichern # Rücksprung ins aufrufende Programm

96 Die Maschinenprogrammebene eines Rechners Jörg Roth 365 main: # Einstiegspunkt des Programms la $a0,word1 # Tausche word1 la $a1,word2 # mit word2 jal swap # Unterprogramm "swap" aufrufen la $a0,word3 la $a1,word4 jal swap # Tausche word3 # mit word4 # Unterprogramm "swap" aufrufen Bemerkung: Da das Unterprogramm swap keine zu sicherernden Register verwendet, entfallen die Punkte "Register auf Stapel sichern" und "Gesicherte Register zurücklesen".

97 Die Maschinenprogrammebene eines Rechners Jörg Roth 366 Verschachtelte Unterprogramme: Ruft ein Unterprogramm ein weiteres Unterprogramm auf, so muss mindestens das Register $ra gesichert werden. jal UP1 Rücksprungadresse in $ra schreiben Hauptprogramm Unterprogramm UP1 jal UP2 Rücksprungadresse in $ra schreiben Unterprogramm UP2 jr $ra jr $ra

98 Die Maschinenprogrammebene eines Rechners Jörg Roth 367 Beispiel: Sortieren von exakt drei Speicherinhalten: Vorgehensweise: Ein Unterprogramm sort2 tauscht zwei Inhalte, wenn sie in der falschen Reihenfolge vorliegen. Ein Unterprogramm sort3 ruft dreimal sort 2 auf mit den Kombinationen (wort1, wort2), (wort2, wort3), (wort1, wort2). Sind diese in der Reihenfolge paarweise sortiert worden, sind alle drei Speicherinhalte sortiert worden..data word1:.word 4 word2:.word 3 word3:.word 2

99 Die Maschinenprogrammebene eines Rechners Jörg Roth 368.text sort2: # Sortieren von zwei Speicherinhalten lw $t0, 0($a0) # 1. Wort in Register laden lw $t1, 0($a1) # 2. Wort in Register laden slt $t2,$t0, $t1 # Vergleich Inhalte bne $zero,$t2,ret # $t2=1, also $t0<$t1, dann nicht tauschen sw $t0, 0($a1) # sonst umgekehrt zurückspeichern sw $t1, 0($a0) ret: jr $ra # Rücksprung ins aufrufende Programm sort3: # Sortieren von drei Speicherinhalten addi $sp,$sp,-16 # Auf dem Stapel Platz für 4 Register freimachen sw $s0,0($sp) # Register $s0, $s1, $s2, $ra auf den Stapel sw $s1,4($sp) sw $s2,8($sp) sw $ra,12($sp) # Wichtig: auch die Rücksprungadresse sichern

100 Die Maschinenprogrammebene eines Rechners Jörg Roth 369 move $s0,$a0 # Kopiere die drei Argumente in $s0, $s1, $s2 move $s1,$a1 move $s2,$a2 jal sort2 move $a0,$s1 move $a1,$s2 jal sort2 move $a0,$s0 move $a1,$s1 jal sort2 # Sortiere Wort1 und Wort2 # Sortiere Wort2 und Wort3 # Sortiere nochmal Wort1 und Wort2

101 Die Maschinenprogrammebene eines Rechners Jörg Roth 370 lw $s0,0($sp) # Register $s0, $s1, $s2, $ra von dem Stapel lw $s1,4($sp) lw $s2,8($sp) lw $ra,12($sp) addi $sp,$sp,16 # Stapelzeiger auf Wert vor dem Aufruf setzen jr $ra # Rücksprung ins aufrufende Programm main: la $a0,word1 la $a1,word2 la $a2,word3 jal sort3 # Einstiegspunkt des Programms # Sortieren von word1, # word2 # und word3 # Unterprogramm "sort3" aufrufen

102 Die Maschinenprogrammebene eines Rechners Jörg Roth 371 Bemerkung zu $fp: Bei Funktionen mit vielen Parametern reichen die Register $a0 $a3 nicht aus. Deshalb kann der Aufrufer die Parameter auch auf dem Stapel hinterlegen. Damit das Unterprogramm bequem auf die Parameter auf dem Stapel zugreifen kann, kann das Register $fp eingesetzt werden. Es zeigt dann auf das Parameter-Wort mit der höchsten Adresse. Dadurch kann mit 0($fp), -4($fp), -8($fp) etc. auf die Parameter zugegriffen werden. Die Verwendung von $fp ist nicht zwingend. Auch sind andere Konventionen denkbar, auf die Parameter auf dem Stapel zuzugreifen.

103 Die Maschinenprogrammebene eines Rechners Jörg Roth 372 Rekursive Unterprogrammaufrufe: Da die lokalen Register und die Rücksprungadressen auf dem Stapel gespeichert werden, kann ein Unterprogramm sich selbst aufrufen. Beispiel Berechnung der Fakultät: x!:=x (x-1) (x-2) Es gilt: x!= 1 wenn x 1. x ( x 1)! sonst Damit kann man die Berechnung von x! rekursiv implementieren.