Befehlssatz und Assembler -Sprache · Grundlagen der Informationsverarbeitung: Befehlssatz und Assembler -Sprache Prof. Dr. -Ing. habil. Ulrike Lucke Maximaler Raum für Titelbild

Grundlagen der Informationsverarbeitung: Befehlssatz und Assembler-Sprache Prof. Dr.-Ing. habil. Ulrike Lucke

Maximaler Raum für Titelbild (wenn kleiner dann linksbündig an Rand angesetzt)

1 UNIVERSITÄT POTSDAM | Institut für Informatik & Computational Science | Komplexe Multimediale Anwendungsarchitekturen © 2017

Durchgeführt von Prof. Dr. rer. nat. habil. Mario Schölzel

• Assembler vs. Maschinenbefehle für einfache Beispielarchitektur – Assemblerbefehl (ASCII-Text) ® Maschinenbefehl (Binärcode) – Zuordnung der Maschinenbefehle zu Speicherpositionen

Wiederholung

inc r1 dec r0 jmp 0 inc r1

Assemblerprogramm (Textdatei)

Maschinenprogramm (Binärdatei)

Assembler

0 00010001 1 00100000 2 00110000 3 00000000 4 00010001

Adresse Binärcode

Befehlssatzarchitektur (Wiederholung)

• Befehlsformat 1

• Befehlsformat 2

addr

8 Bit

opc reg

4 Bit 4 Bit

Assembler opc (binär) RT Anmerkung Takte

inc reg 0001 Rreg <= Rreg + 1; PC <= PC + 1 0 £ reg £ 2 4

dec reg 0010 Rreg <= Rreg – 1; PC <= PC + 1 0 £ reg £ 2 4

Assembler opc (binär) RT Anmerkung Takte

jmp addr 0011 PC <= addr - 6

jnz reg,addr 0100 if reg=0 then PC <= PC+2 else PC <= addr

0 £ reg £ 2 6

opc reg

4 Bit 4 Bit

Datenpfad und Controller (Wiederholung)

© 2016 4 UNIVERSITÄT POTSDAM | Institut für Informatik & Computational Science | Komplexe Multimediale Anwendungsarchitekturen

Inhalt der Vorlesung

• Binäre Modellierung • Codierung von Zahlen und Zeichen • Boolesche Funktionen • Schaltnetze • Schaltungsentwurf • Schaltwerke • Minimierungsverfahren • Grundbausteine der Computertechnik • Befehlsverarbeitung in einem Prozessor • Assembler-Ebene • Steuerwerke • Rechenwerke • Parallelität auf Instruktionsebene • Speicherhierarchie • Virtuelle Speicherverwaltung • Leistungsbewertung

UNIVERSITÄT POTSDAM | Institut für Informatik & Computational Science | Komplexe Multimediale Anwendungsarchitekturen 5 © 2017

Instruktionstypen

• Arithmetikoperationen

• Speicheradressierung und Datentransfer

• Arithmetikoperationen mit Konstanten

• Logikoperationen

• Kontrollfluss

• Instruktionscodierung

• Unterprogramme

• Adressierungsarten

© 2017 6 UNIVERSITÄT POTSDAM | Institut für Informatik & Computational Science | Komplexe Multimediale Anwendungsarchitekturen

Tipp

Vergleichen sie die genannten Instruktionstypen mit den Ihnen bekannten

Konstrukten einer Hochsprache!


Arithmetikoperationen

• Alle MIPS Arithmetik-Instruktionen haben drei Operanden: Bedeutung MIPS Instruktion a = b + c add a, b, c

a = b – c sub a, b, c

• Längere Ausdrücke müssen vom Anwender/Compiler in eine Reihe von

einfacheren Operationen gespaltet werden: a = b + c + d + e add a, b, c add a, a, d add a, a, e

• ggf. Einführung temporärer Variablen durch Entwickler/Compiler

f = (g + h) – (i + j) add t0, g, h add t1, i, j sub f, t0, t1


Arithmetik nur mit Registern

• 32 allgemeine Register, jeweils 32-Bit breit

• Ein 32-Bit Datentyp wird als Wort bezeichnet

• Konvention zur Bezeichnung und Verwendung der Register, z.B. – 8 Register für Variablen des Quellprogramms: $s0, ..., $s7 – 8 Register für temporäre Variablen: $t0, ..., $t7

• Compiler (oder auch Programmierer / Anwender) muss sich nicht unbedingt an solche Konventionen halten

• Derartige Konventionen sind aber notwendig, damit getrennt übersetzte Programmteile zusammenarbeiten können


Nutzerregister

Nummer Register Verwendung

0 $zero Konstante 0

1 $at Reserviert für Behandlung von Exceptions und Assembler

2,3 $v0, $v1 Auswertung von Ausdrücken, Ergebnisse einer Funktion

4-7 $a0 - $a3 Argumente für Unterprogramm

8-15, 24,25

$t0 - $t9 Temporäre Register (Inhalt bleibt bei Aufruf eines Unterprogramms nicht erhalten)

16-23 $s0 - $s7 Temporäre Register (Inhalt bleibt bei Aufruf eines Unterprogramms erhalten)

26,27 $k0, $k1 Reserviert für Betriebssystem (Exceptionbehandlung)

28 $gp Globaler Zeiger

29 $sp Stackpointer

30 $fp Framepointer

31 $ra Rücksprungadresse

Assembler und Befehlssatzsimulator für den MIPS Prozessor

• QTSpim (Befehlssatzsimulator + Assembler): – http://spimsimulator.sourceforge.net/ – Übersetzen von Assemblerprogrammen in Binärcode – Simulation des Binärcodes

• Assemblerprogramm enthält – Assemblerdirektiven – beginnen mit einem . – Daten (globale Konstanen und Werte), stehen in der Datensektion – Programm, steht in der Textsektion

• Hello World - Assemblerprogramm:

.data # Beginn der Datensektion msg: .asciiz "Hello World" .text # Beginn der Textsektion main: li $v0, 4 # syscall 4 (print_str) la $a0, msg # argument: string syscall # print the string jr $ra # return to caller

http://spimsimulator.sourceforge.net/

Beispiel

f = (g + h) – (i + j)

• Variable g befindet sich im Register $s1

• h im Register $s2

• i im Register $s3

• j im Register $s4

• Ergebnis f soll in Register $s0 kommen add $t0, $s1, $s2 # temp1 := g + h

add $t1, $s3, $s4 # temp2 := i + j

sub $s0, $t0, $t1 # f := temp1 – temp2

• beschränkte Anzahl von Registern reicht nicht, um die Variablen realistischer Programme aufzunehmen Variablen bzw. komplexere Datentypen im Speicher ablegen


Zeichen # leitet einen Kommentar ein (bis zum Ende der Zeile)

Tipp

Wie könnten andere arithmetische Instruktionen aussehen?


Speicherlayout (MIPS Simulator)

• Speicher wird mit Byteadressen adressiert

• Speicher ≈ großes, eindimensionales Feld von Bytes

• Adresse einer Speicherzelle entspricht dem Feld-Index

• Niedrigste Adresse ist 0

• 4 Byte werden zu einem Datenwort (32-Bit) zusammengefasst

• Daten und Programme sind in Datenworten organisiert

• MIPS verwendet typischerweise die "Big Endian" Konvention für die Anordnung der Bytes in einem Wort

• Hängt im Simulator aber von dem Rechner ab, der zur Simulation verwendet wird (d.h. Simulator, der auf Intelprozessoren läuft nutzt Little-Endian)

• Alignment beachten: Wortadressen müssen durch 4 teilbar sein Reserviert

0x00400000

Textsegment (Programm)

0x10000000

Statische Daten

Stapelspeicher

Dynamische Daten

0x7FFFFFFF

Big Endian vs. Little Endian


Byte

0 1

3 2

4 5

9

7 6

8

Byte-Adressen

Byte 3 Byte 2 Byte 1 Byte 0

Big Endian

Wort- Adressen

Byte

0 1

3 2

4 5

9

7 6

8

Byte-Adressen

Byte 0 Byte 1 Byte 2 Byte 3

Little Endian

Wort- Adressen

Byte 3 Byte 2 Byte 1 Byte 0 0 31

32-Bit Wort:

Beispiel

A = 01010101 11111111 00000000 11001100 = A3 A2 A1 A0

• Little Endian: Das Byte mit der geringsten Wertigkeit wird zuerst gespeichert. A0 A1 A2 A3

• Big Endian: Das Byte mit der höchsten Wertigkeit steht am Anfang. A3 A2 A1 A0

Transfer von einem Little-Endian-System zu einem Big-Endian-System

(oder umgekehrt):

A0 A1 A2 A3 = 11001100 00000000 11111111 01010101


Tipp

Ermitteln Sie aus der Blockdarstellung eines Speicherbereichs

die daraus resultierenden Wortadressen in Big- & Little Endian!


Datentransferoperationen

• Daten können ausschließlich mit Datentransferinstruktionen zwischen Registern und dem Speicher bewegt werden

lw (load word) sw (store word)

• Beispiel: A[12] = h + A[8] – A ist ein Array vom Datentyp Wort. – Variable h steht im Register $s2 – Basisadresse von A steht im Register $s3

lw $t0, 32($s3) # $t0 := Mem[$s3 + 32] = A[8]

add $t0, $s2, $t0 # $t0 := h + A[8]

sw $t0, 48($s3) # Mem[$s3 + 48] = A[12] := $t0


Offset Basisregister “Indexed Addressing”

Arithmetik mit Konstanten

a = a + 3

• Man kann die Konstante im Speicher ablegen und in ein Register laden

• Annahme: Die Variable a steht im Register $s1. Die Konstante 3 steht im Speicher an einer Adresse, die sich im Register $t1 befindet

lw $t0, 0($t1) // $t0 := 3

add $s1, $s1, $t0 // a := a + 3

• Da Arithmetik mit Konstanten sehr oft vorkommt, besitzt die MIPS ISA einen eigenen Befehl dafür: addi (add immediate)

addi $s1, $s1, #3 // $s1 := $s1 + 3


Konstante in ein Register laden • Laden einer 16 Bit Konstanten (I-Typ):

– Assemblersyntax: LUI $rt, imm – Verhalten: highword(rt) <= imm; lowword(rt) <= 0

• Beispiel:

– Wert von t0 vorher: 0xF1F2F3F4 – LUI $t0, 0xAB34 – Wert von t0 nachher: 0xAB340000

• Problem beim Laden einer 32 Bit Konstanten:

– Konstante selbst erfordert 32 Bit – Ein Befehl darf nur in 32 Bit kodiert werden

• Lösung: Konstante wird in zwei Teilen geladen: • Beispiel: Laden der Konstanten 0x12345678

– LUI $t0, 0x1234 – ORI $t0, $t0, 0x5678

• Pseudoinstruktion zum Laden einer 32 Bit Konstanten c:

– LI $rt, c

• Wird durch den Assembler abgebildet auf die Befehlsfolge: – LUI $at, highword(c) – ORI $rt, $at, lowword(c)

0x0f (6) 0x0 (5) rt (5) imm (16)

Adresse in ein Register laden • Pseudoinstruktion zum Laden einer Adresse

– Assemblersyntax: LA $rt, offset($rs) – Verhalten: rt <= rs + offset – Anmerkung: offset darf auch ein Label aus dem Assemblerprogramm sein

• Wird durch den Assembler abgebildet auf die Befehlsfolge: – lui $at, highword(offset) – ori $at, $at, lowword(offset) – add $rt, $rs, $at

– Anmerkung: Vereinfachungen der Befehlssequenz durch den Assembler sind möglich

• Beispiel: – Vorher: t0 = 0x100, label1 = 0x640034 – la $t1, label1($t0) – Nachher: t1 = 0x640134

Registerwerte kopieren • Pseudoinstruktion zum Kopieren von Registerwerten

– Assemblersyntax: move $rt, $rs

– Verhalten: rt <= rs

• Wird durch den Assembler abgebildet auf die Befehlsfolge: – addu $rt, $zero, $rs

• Beispiel: – t0 = 0x100, t1 = 0x640134 – move $t1, $t0

– t0 = 0x100, t1 = 0x100

Tipp

Schätzen Sie ab, mit wie vielen Variablen Sie typischerweise in einem

Hochsprach-Programm arbeiten, wie viele davon in die Register passen,

und wie viele Load-/Store-Befehle im Assembler Sie folglich bräuchten.


Logikoperationen

• Logikoperationen können nur mit Registern ausgeführt werden

• Schiebeinstruktionen sll (logical shift left) srl (logical shift right) „Es werden 0-en nachgeschoben“ … sll $t2, $s0, 4 // $t2 := $s0 << 4 = $s0 * 16

• Logikinstruktionen and (bitwise AND) andi (bitwise AND immediate) or (bitwise OR) ori (bitwise OR immediate) …


Beispiel

Annahme: $s0 enthält (00000009)HEX

sll $s1, $s0, 2 // $s1 = ... ?

or $s1, $s1, $s0 // $s1 = ... ?

andi $s1, $s1, 15 // $s1 = ... ?

andi $s2, $s2, 0 // $s2 = ... ?


Tipp

Wie könnten andere Logikoperationen aussehen?


Sprung-/Verzweigungsoperationen

• Kontrollfluss – Ein Maschinen/Assemblerprogramm besteht aus einer Folge von

Maschinen/Assembler-Instruktionen. – Normalerweise wird eine Instruktion nach der anderen abgearbeitet.

Der Program Counter (PC) wird um 4 (eine Wortadresse) erhöht. – Sprung/Verzweigungsinstruktionen können den Kontrollfluss ändern.

Dies wird für Entscheidungen und Schleifen benötigt.

• Verzweigungsinstruktionen (conditional branch) beq reg1, reg2, label (compare and branch if equal) bne reg1, reg2, label (compare and branch if not equal)

• Sprunginstruktion (unconditional branch) j label (always jump)


Beispiel: Verzweigung

C/C++-Programm: if (i == j)

{ f = g + h; }

else

{ f = g – h; }

Assembler-Programm:

Variablen f,g,h,i,j in $s0, $s1, $s2, $s3, $s4 bne $s3, $s4, Else # if (i != j) goto Else

add $s0, $s1, $s2 // f = g + h

j Exit // goto Exit

Else: sub $s0, $s1, $s2 // f = g - h

Exit: ...


Else, Exit sind Sprungmarken / Labels

Beispiel: Schleife

C/C++-Programm: while (save[i] == k) { i = i + 1; }

Assembler-Programm:

Variablen i und k in $s3 bzw. $s5, Adresse von save in $s6.

Loop: sll $t1, $s3, 2 # $t1 = 4 * i

add $t1, $t1, $s6 # $t1 = Adresse von save[i]

lw $t0, 0($t1) # $t0 = save[i]

bne $t0, $s5, Exit # if (save[i] != k) goto Exit

addi $s3, $s3, 1 # i = i + 1

j Loop # goto Loop

Exit: ...


Sprung-/Verzweigungsoperationen

• MIPS ISA hat keine Verzweigungsoperationen, die abfragen, ob ein in einem Register gespeicherter Wert kleiner/größer als ein anderer Wert ist.

• stattdessen: slt (set on less than) slti (set on less than immediate) slt $t0, $s3, $s4 # if ($s3<$s4) $t0=1 else $t0=0

• MIPS besitzt ein spezielles Register: $zero – $zero ist konstant auf 0 gesetzt. – Zuweisungen auf $zero werden ignoriert – Mit dem Register $zero und den Instruktionen beq, bne, slt und slti lassen sich

alle Verzweigungsbedingungen bilden.


Tipp

Vergleichen Sie die Realisierung einer while-Schleife in Assembler

mit der Realisierung einer for-Schleife!


Prozeduren (Unterprogramme)

prinzipieller Ablauf:

• Kontrollfluss an die aufgerufene Prozedur übergeben

• Prozedur führt Berechnungen aus

• Kontrollfluss an die aufrufende Prozedur zurückgeben

MIPS-Unterstützung für Prozeduraufrufe:

• spezielles Register für die Sicherung der Rücksprungadresse: $ra

• Sprunginstruktionen jal (jump and link) sichert die Rücksprungadresse in $ra und springt zur Adresse der Prozedur jr (jump register) springt zur Adresse, die im angegeben Register steht, d.h. jr $ra springt zurück zum aufrufenden Programm


Prozeduren (Unterprogramme)

• Prozeduren benötigen i.A. Argumente und liefern Resultate

• Konvention für eine schnelle Argument- und Resultatübergabe beim MIPS 4 Register für Argumente: $a0,...,$a3

2 Register für Resultate: $v0, $v1

... jal procA # $ra = PC + 4, goto procA ... ... procA: ... # erste Instruktion von procA ...

jr $ra # goto $ra

Tipp

Was passiert mit $ra wenn ein weiteres Unterprogramm aufgerufen wird?


Motivation Stapelspeicher

• Problem: Schachtelungstiefe für Funktionsaufrufe auf 1 beschränkt

• Lösung: Jede Funktion muss $ra sichern

... jal procA # $ra = PC + 4, goto procA ... ... procA: ... # erste Instruktion von procA jal procB # Wert in ra wird überschrieben ... jr $ra # goto $ra procB: ... jr $ra

Sichern der Rücksprungadresse • Jede Funktion erhält

– einen Prolog und – einen Epilog

... jal procA ... ... procA: ... jal procB # Wert in ra wird überschrieben ... jr $ra

Sichern von $ra

Wiederherstellenvon $ra

Prolog

Epilog

... jal procA ... ... procA: ... jal procA # retProcA wird überschrieben ... jr $ra

Sichern – aber wo? • Variante 1:

– Jede Funktion sichert $ra an eine feste Speicheradresse – Dann sind keine rekursiven Funktionsaufrufe zulässig

sw $ra, retProcA

lw $ra, retProcA

Prolog

Epilog

... jal procA ... ... procA: ... jal procA ... jr $ra

Sichern – aber wo? • Variante 2:

– $ra wird an der Spitze eines Stapelspeichers gesichert – Dann sind rekursive Funktionsaufrufe zulässig

addiu $sp, $sp, -4 sw $ra, 0($sp)

lw $ra, 0($sp) addiu $sp, $sp, 4

Prolog

Epilog

Organisation Stapelspeicher • Organisation des Stapelspeichers variiert mit

– verwendetem Betriebssystem – verwendetem Compiler

• Prinzip: – SP (Stack Pointer) zeigt auf oberstes Datenwort – FP (Frame Pointer) wird für den Zugriff

auf lokale Variablen und Argumente genutzt

– Jeder Funktionsaufruf (auch rekursiv) erzeugt einen eigenen lokalen Speicherbereich im Stapel

argn

argn-1

arg1

fpcaller

sp

fp fp

sp

argn

argn-1

arg1

fp

sp $atcaller

fpcaller

argn

argn-1

arg1

fp

sp

$atcaller

Lokale Variablen

t0

t9

…

t0

t9

…

t0

t9

…

…

…

…

Aufrufende Funktion Aufgerufene Funktion

Instruktionscodierung

Assemblersprache Maschinensprache (binäre Codierung)

• Bei MIPS sind alle Instruktionen 32 Bit lang.

• Da die verschiedenen Instruktionen unterschiedlich viele Operanden haben, werden drei Instruktionsformate unterschieden:

•

– R-Typ Instruktionen (R .. Register) – I-Typ Instruktionen (I .. Immediate) – J-Typ Instruktionen (J .. Jump)


Instruktionsformat R-Typ • Instruktionsformat R-Typ (Register-Format) wird für arithmetische und

logische Instruktionen verwendet

op Operationscode (OP-Code) rs Register des ersten Quelloperanden rt Register des zweiten Quelloperanden rd Register, in dem das Ergebnis gespeichert wird shamt Anzahl der Stellen, um die geschoben wird (shift amount) funct Funktionscode (function), Variante einer Operation

– Beispiel

add $t0, $s1, $s2

0 31 26 25 21 20 16 15 11 10 6 5

op rs rt rd shamt funct

000000 100000 10001 10010 01000 00000 op rd rs rt

Instruktionsformat I-Typ • Instruktionsformat I-Typ (Immediate-Format) wird verwendet für

– Immediate-Versionen der arithmetischen und logischen Instruktionen, – Datentransferinstruktionen und für Verzweigungsinstruktionen.

immediate Konstante oder Adresse

– Konstante ist eine 16-bit vorzeichenbehaftete Zahl im 2er-Komplement und kann Werte zwischen -215 und +215-1 annehmen.

– Beispiel:

addi $t1, $s1, 15

0 31 26 25 21 20 16 15

op rs rt immediate

001000 10001 01001 0000000000001111

Instruktionsformat J-Typ

• Instruktionsformat J-Typ (Jump-Format) wird für „unconditional Jumps“ verwendet

target Sprungadresse

– target ist eine 26-bit Zahl, die als Wortadresse interpretiert wird

– Beispiel:

j 0x0x400024

0 31 26 25

op target

000010 00 0100 0000 0000 0000 0010 0100

Erste Zusammenfassung (1)


Erste Zusammenfassung (2)


Tipp

Bilden Sie verschieden komplexe Programme einer Hochsprache

auf die vorgestellten Assembler-Befehle ab.

Für welche Konstrukte finden sie hier (noch) kein Äquivalent?


Adressierungsarten

• Operanden können sich befinden – in einem Prozessorregister: Adresse ist die Registerbezeichnung – im Speicher: Adresse ist die Speicheradresse

• Adressierung dieser Operanden – Unmittelbare Adressierung – Registeradressierung – Absolute Speicheradressierung im MIPS verwendbar – Basisadressierung – Relative Adressierung – Registerindirekte Speicheradressierung – Register-/Speicher-indirekte Adressierung

mit/ohne Displacement , Skalierung, ... – Implizite Adressierung


Unmittelbare (direkte) Adressierung

Operand ist als Konstante im Befehl codiert

Verwendung: Angabe von Konstanten

Beispiel:

LDA #imm ; A := imm


Registeradressierung

Befehl codiert die Registernummer

Verwendung: schnelle Verknüpfung von Operanden

Beispiel:

ADD R0,R2,R5 ; R0 := R2 + R5


Absolute Speicheradressierung

Befehl enthält eine Speicheradresse als Konstante

Verwendung: Zugriff auf globale Variablen (haben konstante Adresse)

Beispiel:

ADD R0, R2, (1000) ; R0 := R2 + MEM[1000]


Basis- (Offset-) Adressierung


op rs rt address

+ Register

Wort Byte Halbwort

Speicher

Relative Adressierung

in Bezug auf den Programm Counter


op rs rt address

+ PC

Wort

Speicher

address ist 16-Bit vorzeichenbehaftet → Verzweigungsinstruktionen können in einen Bereich von [-215, +215-1] um PC springen

Registerindirekte Speicheradressierung

Befehl gibt ein Register an, das eine Speicheradresse enthält

Verwendung: Zeiger (Register enthält den Wert des Zeigers)

Beispiel:

ADD R0, R2, (R5) ; R0 := R2 + MEM[1000]


Registerindirekte Speicheradressierung mit Displacement

Befehl enthält ein Register und ein Displacement (Offset),

die Speicheradresse ergibt sich aus Registerwert + Displacement

Verwendung: Zugriff auf lokale Variablen

Beispiel:

ADD R0, R2, 1(R5) ; R0 := R2 + MEM[R5 + 1]


Indexierte Speicheradressierung

Befehl enthält Register, die Speicheradresse und Displacement enthalten

Verwendung: z.B. bei Feldzugriffen

Beispiel:

ADD R0, R2, (R4 + R5) ; R0 := R2 + MEM[R4 + R5]


Speicherindirekte Adressierung

Befehl enthält ein Register, das auf eine Speicheradresse verweist,

die die Speicheradresse des Operanden enthält

Verwendung: Speicherplatz x ist ein Zeigerwert

Beispiel:

ADD R0, R2, @(R5) ; R0 := R2 + MEM[MEM[R5]]


Autoincrement/Autodecrement

wie registerindirekt, aber inkl. Weiterzählen der Adresse

Verwendung: Stapelzugriff, Schleifen über Felder

Beispiel:

ADD R0, R2, (R4+d) ; R0 := R2 + MEM[R4]; R4 := R4 + d


Registerindirekt skaliert

wie registerindirekt mit Offset, aber Registerinhalt wird vervielfacht

(in der Regel um eine kleine Zweierpotenz)

Verwendung: Zugriff auf Feldelemente

Beispiel:

ADD R0, R2, base(R5*d) ; R0 := R2 + MEM[base+R5*d]


Implizite Adressierung

Operand ist implizit im Befehl codiert

• separater Befehlscode für verschiedene Register

• Akkumulator-Architektur

Beispiel:

LDA #imm ; A := imm


Tipp

Legen sie eine willkürliche Speicherbelegung fest und bilden Sie dafür

die Adresse eines Wortes in verschiedenen Adressierungsarten ab!


Tipp

Betten Sie die vorgestellten Adressierungsarten jeweils in ein

kleines Assembler-Programm ein, das die genannten

Verwendungsbereiche aufgreift!


Systemaufrufe

• Systemaufrufe – Assemblersyntax: syscall – Code für gewünschte Funktion wird in Register $v0 übergeben – Weitere Argumente können in Registern übergeben werden (vgl. Tabelle) – Ergebnisse werden in $v0 oder $f0 zurückgegeben (vgl. Tabelle)

Documents

Befehlssatz und Assembler -Sprache · Grundlagen der Informationsverarbeitung: Befehlssatz und Assembler -Sprache Prof. Dr. -Ing. habil. Ulrike Lucke Maximaler Raum für Titelbild