Befehlssätze und Assemblersprache

Ein Prozessor führt Befehle aus, die durch Bits dargestellt werden. Eine Befehlssatzarchitektur (ISA) gibt diesen Bits eine gemeinsame Bedeutung, sodass Software dieselben Operationen auf unterschiedlichen Implementierungen anfordern kann.

Was die ISA festlegt

Die ISA legt Befehle, sichtbare Register, Datengrößen, das Speicherverhalten und Befehlskodierungen fest. Ein Befehl wie add a0, a1, a2 muss auf jedem Prozessor, der ihn unterstützt, das festgelegte Ergebnis liefern. Die internen Schaltungen und die zeitliche Planung gehören zur Mikroarchitektur. Zwei Chips können sich stark in Geschwindigkeit und Energieverbrauch unterscheiden und dennoch dieselbe ISA implementieren.

Für Binärkompatibilität muss auch die Softwareumgebung übereinstimmen. Ein Programm, das einen Betriebssystemdienst oder eine Bibliothek aufruft, hängt von mehr ab als der Bedeutung von Befehlen. Registerkonventionen und Datenlayouts sind Teil der Binärschnittstelle, kurz ABI.

Von lesbarem Code zu Bits

Für C wählt ein Compiler Assemblerbefehle aus; ein Assembler kodiert sie als Maschinencode. Assemblersprache ist Text mit Befehlsnamen, Registern, Kommentaren und Labels. Maschinencode ist die Binärdarstellung, die der Prozessor holt. Ein Label wie Start: bezeichnet eine Befehlsadresse; es ist kein Befehl, der zur Laufzeit ausgeführt wird. Ein Kommentar beginnt mit #.

Start:
    add a0, a1, a2   # a0 receives a1 + a2

Das erste Register ist das Ziel. Enthält a1 den Wert 14 und a2 den Wert 5, schreibt der Befehl 19 nach a0; die Quellen bleiben unverändert. Komplexere Ausdrücke benötigen mehrere Operationen. Die Addition von vier Registerwerten benötigt drei Additionen, wobei Zwischenergebnisse in Registern gehalten werden.

Die meisten Befehlsnamen entsprechen einem Maschinenbefehl. Ein Pseudobefehl ist eine Kurzform des Assemblers: mv fordert eine Registerkopie an und li eine Konstante. Ein Pseudobefehl kann zu einem oder mehreren echten Befehlen erweitert werden, sodass das Zählen von Assemblerzeilen nicht immer die Codegröße ergibt.

Im Speicher abgelegte Befehle

Nach dem Speicherprogrammkonzept werden sowohl Befehle als auch Daten als Zahlen im Speicher dargestellt. Der Befehlszähler pc bezeichnet den zu holenden Befehl. Bei einer Folge von 32-Bit-Befehlen wird er bei der normalen Ausführung um 4 Bytes weitergesetzt. Bedingte und unbedingte Sprünge wählen eine andere nächste Adresse. Der Prozessor führt die Kodierung aus, nicht die ursprüngliche Schreibweise in Assemblersprache, aus der sie entstand.

RISC-V-Basisbefehlssätze und -Erweiterungen

RISC-V ist ein offener, lizenzgebührenfreier ISA-Standard, der von RISC-V International gepflegt wird. RV32I stellt 40 Basisbefehle für ganze Zahlen und 32-Bit-Ganzzahlregister bereit; RV64I verwendet 64-Bit-Ganzzahlregister. Beide bieten 32 Ganzzahlregister. Optionale Erweiterungen ergänzen Funktionen: M bietet Multiplikation und Division ganzer Zahlen, A atomare Operationen, F und D Gleitkommaarithmetik, C komprimierte Befehle und V Vektoren. Die Beispiele verwenden RV32I und M dort, wo mul vorkommt.

RISC-V-Assemblersprache ist an RISC-V gebunden. Ein C-Programm kann für x86 oder ARM neu kompiliert werden, aber sein RISC-V-Maschinencode kann nicht direkt als Code dieser ISAs ausgeführt werden. Ein Simulator kann RISC-V-Befehle auf einem Host mit einer anderen ISA ausführen und Änderungen an Registern und Speicher Schritt für Schritt sichtbar machen.

Register halten die Werte, die ein Befehl unmittelbar verwenden kann. In RV32I enthält jedes Ganzzahlregister 32 Bits, und ein Registername bezeichnet einen Speicherplatz, keine C-Variable und keinen Datentyp.

Registernamen und Rollen

Es gibt 32 Ganzzahlregister, x0 bis x31. Der Befehlszähler ist separat. Fünf Bits bezeichnen ein Ganzzahlregister, denn es gibt 32 mögliche 5-Bit-Muster. Ein kleiner Registersatz begrenzt außerdem den Zugriffsaufwand und den Platz, den Registerfelder in Befehlen belegen.

Register s0 kann auch als fp, der Framepointer, dienen. Schreibzugriffe auf zero werden verworfen, sodass es einen Nulloperanden liefern kann, ohne vorher eine Konstante zu laden. Beispielsweise kopiert add a0, a1, zero den Wert aus a1.

Diese Namen drücken eine Softwarevereinbarung aus. Insbesondere erhält die Hardware ein s-Register nicht automatisch. Eine Prozedur, die es verändert, muss dafür sorgen, dass sein Eingangswert wiederhergestellt wird. Die Standard-ABI reserviert gp und tp außerdem für ihre Aufgaben in der Umgebung; sie sind keine gewöhnlichen Arbeitsregister.

Einen Ausdruck in Operationen zerlegen

Übersetze f = (g + h) - (i + j); mit g, h, i, j in s1–s4 und dem Ergebnis in s0:

add t0, s1, s2
add t1, s3, s4
sub s0, t0, t1

Bei den Werten 9, 4, 6 und 1 hinterlässt der erste Befehl 13 in t0. Der zweite hinterlässt 7 in t1. Die Subtraktion schreibt 6 nach s0. Jedes temporäre Register hält ein Ergebnis, bis der nächste Befehl es benötigt.

Bei der Subtraktion ist die Reihenfolge der beiden Quelloperanden wichtig: sub s0, t1, t0 würde −6 ergeben. Das Ziel steht immer zuerst, sodass sub t0, s0, t1 stattdessen ein temporäres Register überschreiben und den alten Wert von s0 lesen würde. Notiere beim Nachverfolgen nach jeder Zeile das Ziel; aktualisiere nicht beide Quellregister.

Bits erhalten durch ihre Verwendung Bedeutung

Ein Register trägt keine Kennzeichnung als vorzeichenbehaftet oder vorzeichenlos. Das Muster 0xFFFFFFFF kann vorzeichenbehaftet −1 oder vorzeichenlos 4.294.967.295 bedeuten. Ein vorzeichenbehafteter und ein vorzeichenloser Vergleich können daher für dieselben gespeicherten Bits unterschiedliche Ergebnisse liefern. Auch Adressen sind Bitmuster in Registern; ein Ladebefehl interpretiert seine Basis als Adresse.

Werte so lange wie nötig verfügbar halten

Ein Compiler weist häufig verwendete Werte Registern zu. Benötigt er mehr gleichzeitig verfügbare Werte, als Register aufnehmen können, speichert er einige im Speicher und lädt sie später erneut. Dieser Vorgang heißt Spilling. Dabei entstehen tatsächlich Kosten durch Speicher- und Ladezugriffe.

Aufrufe bilden eine weitere Grenze. Eine aufgerufene Prozedur darf t0–t6 und a0–a7 überschreiben. Halte einen nach dem Aufruf benötigten Wert in einem ordnungsgemäß erhaltenen s-Register oder sichere ihn vor dem Aufruf auf dem Stack. Nur weil t0 frei war, überdauert sein Wert den Aufruf nicht automatisch.

Speicheradressen bezeichnen Bytes. Ladebefehle bringen Daten in Register, und Speicherbefehle kopieren Registerbits zurück in den Speicher. In einer Load-Store-Architektur liest die Arithmetik ihre Operanden nicht direkt aus dem Speicher.

Größen und Byteversätze

Ein Byte belegt eine Adresse, ein Halbwort zwei und ein 32-Bit-Wort vier. RV32 hat einen 32-Bit-Adressraum von bis zu 4 GiB. In der C-ABI ILP32 belegt char 1 Byte, short 2 und int, long und Zeiger 4.

Die Befehle lw und sw übertragen Wörter. Ladebefehle für Halbwörter sind lh und lhu, für Bytes lb und lbu. Speicherbefehle verwenden sh und sb für die kleineren Größen. Ein Speicherbefehl kopiert die unteren Bits seiner Quelle; sb schreibt nur die unteren 8 Bits.

Eine Adresse ergibt sich aus einem Basisregister plus einem vorzeichenbehafteten 12-Bit-Byteversatz:

lw t0, 32(s3)
sw t0, 48(s3)

Der Ladebefehl liest das Wort an der Adresse in s3 plus 32. Er addiert nicht 32 zum geladenen Wert und verändert s3 nicht. Der Speicherbefehl schreibt diesen Wert an die Basisadresse plus 48. Der Versatzbereich reicht von −2048 bis 2047.

Einen Arrayzugriff übersetzen

Bei einem int-Array mit der Basisadresse in s3 beginnt das Element A[i] an der Basisadresse plus dem 4-Fachen des Index. Um A[12] = h + A[8]; mit h in s1 zu implementieren:

lw t0, 32(s3)      # A[8]
add t0, s1, t0
sw t0, 48(s3)      # A[12]

Ist A[8] gleich 80 und h gleich 3, wird A[12] zu 83. Ein Versatz von 8 würde A[2] auswählen, da die Adresse Bytes zählt. Bilde bei einem variablen Index in s4 zuerst die Adresse:

slli t1, s4, 2
add t1, s3, t1
lw t0, 0(t1)

Die Skalierung richtet sich nach der Elementgröße, nicht nach dem Prozessornamen. Ein Zeiger oder long in RV64 LP64 belegt 8 Bytes und verwendet ld/sd; ein int in RV64 belegt weiterhin 4.

Einen kleinen geladenen Wert erweitern

Ein Register muss 32 Bits enthalten, auch wenn ein Ladebefehl nur 8 liest. lb kopiert das Vorzeichenbit des Bytes in jedes höherwertige Bit; lbu füllt die höherwertigen Bits mit Nullen. So wird das Byte 0xF0 mit lb zu 0xFFFFFFF0 (−16), mit lbu dagegen zu 240. Derselbe Unterschied gilt für lh und lhu. Für vorzeichenlose Bytes, einschließlich Bytes von Zeichenketten, wird lbu verwendet.

Die Byte-Reihenfolge lesen

Im Little-Endian-Speicher belegt das niederwertigste Byte die niedrigste Adresse. Wird 0x12345678 bei 0x1000 gespeichert, liegen 0x78, 0x56, 0x34, 0x12 an den Adressen 0x1000 bis 0x1003. Ein Byte-Ladebefehl von der ersten Adresse liest 0x78. Bei Big-Endian steht 0x12 zuerst; RISC-V-Systeme können beide Reihenfolgen festlegen, während die üblichen Lehrsysteme Little-Endian verwenden.

Eine natürlich ausgerichtete Adresse ist ein Vielfaches der Zugriffsgröße: 4 für ein Wort und 2 für ein Halbwort. Natürlich ausgerichtete Zugriffe werden von der Architektur unterstützt. Ein nicht ausgerichteter Zugriff kann je nach Ausführungsumgebung funktionieren, länger dauern oder eine Ausnahme auslösen. Platziere Wörter an 4-Byte-Grenzen und gehe um 4 weiter, um das nächste Wort zu erreichen.

Ein Direktoperand ist eine Konstante, die innerhalb eines Befehls kodiert ist. Er ermöglicht bei einer häufigen Operation wie dem Erhöhen eines Zählers, einen separaten Ladezugriff zu vermeiden.

Kleine Konstanten

addi t0, t0, 1 addiert 1 zu t0. Sein Direktoperand ist eine vorzeichenbehaftete 12-Bit-Zahl im Zweierkomplement von −2048 bis 2047. Der Prozessor erweitert sie vor der Addition mit Vorzeichen auf 32 Bits. Subtrahiere eine kleine Konstante mit einem negativen Direktoperanden, wie in addi t0, t0, -5; RV32I hat keinen Subtraktionsbefehl mit Direktoperand.

Auch Ladebefehle, jalr und gewöhnliche arithmetische und logische Befehle mit Direktoperand verwenden vorzeichenbehaftete 12-Bit-Direktoperanden. Insbesondere erweitern andi, ori und xori ihre Konstanten nicht mit Nullen. Schiebebefehle mit Direktoperand kodieren in RV32 stattdessen eine Verschiebungsweite von 0 bis 31.

Nützliche Kurzformen des Assemblers sind:

Die Konstante −1 besteht nach der Vorzeichenerweiterung nur aus Einsen, weshalb xori mit −1 jedes Bit umkehrt.

Alle 32 Bits aufbauen

lui setzt ein 20-Bit-Feld in die Bits 31–12 und löscht die unteren 12 Bits. Für 0x12345678:

lui t0, 0x12345
addi t0, t0, 0x678

Der Zwischenwert ist 0x12345000; die Addition von 1.656 ergänzt den unteren Teil. Bei einem unteren Teil mit gesetztem Bit 11 musst du genauer aufpassen. Sein 12-Bit-Muster stellt einen negativen Summanden dar, erhöhe also den oberen Teil, bevor du ihn addierst.

Für 0x00001800 bedeutet das untere Muster 0x800 den Wert −2048. Verwende:

lui t0, 0x2
addi t0, t0, -2048

Das erste Ergebnis ist 0x2000. Die Subtraktion von 0x800 ergibt 0x1800. Mit dem oberen Feld 0x1 entstünde 0x800, also ein Block von 4096 zu wenig.

Lies bei jeder 32-Bit-Konstante die unteren 12 Bits als vorzeichenbehafteten Wert. Subtrahiere diesen vorzeichenbehafteten Wert von der gewünschten Konstante, dividiere durch 4096 und behalte die unteren 20 Bits für lui. Bei 0xDEADBEEF ist der vorzeichenbehaftete untere Teil −273. Verwende also das obere Feld 0xDEADC und danach addi mit −273. Assembler führen diese Aufteilung für li aus.

Konstanten, Adressen und Inhalte

li t0, 100 schreibt die Zahl 100 in ein Register. lw t0, 100(zero) liest den Speicherinhalt an Adresse 100. Eine Adresse kann selbst als Wert geladen werden: la t0, Item fordert vom Assembler die durch Item bezeichnete Adresse an.

auipc addiert einen um 12 Bits nach links verschobenen oberen Direktoperanden zur Adresse dieses Befehls. In Kombination mit einer Operation mit Direktoperand oder einem Ladebefehl ermöglicht es PC-relativen Zugriff über etwa ±2 GiB. Ein lokales la verwendet häufig auipc und addi; andere Erweiterungen unterstützen den Zugriff auf gemeinsam genutzte Bibliotheken.

Eine Konstante wie 5.000 kann kein Operand von addi sein. Lade sie mit li in ein zweites Register und verwende dann add. Ein größerer Wert erhält keinen breiteren Direktoperanden, nur weil er hexadezimal geschrieben wird.

Ein arithmetischer Befehl liest Registerbits und schreibt ein neues Bitmuster. Um dieses Muster zu verstehen, musst du sowohl die Operation als auch die beabsichtigte vorzeichenbehaftete oder vorzeichenlose Interpretation berücksichtigen.

Addition, Subtraktion und Überlauf

In RV32I behalten add, sub und addi die unteren 32 Ergebnisbits. Die Addition von 1 zu 0x7FFFFFFF ergibt 0x80000000, was als vorzeichenbehaftete ganze Zahl −2.147.483.648 darstellt. Der Befehl löst keine Überlaufausnahme aus.

Bei vorzeichenloser Addition kann Software einen Überlauf erkennen:

add t0, a0, a1
bltu t0, a0, Overflow

Eine vorzeichenlose Summe nach einem Überlauf ist kleiner als ein Eingabewert. Dieser vorzeichenlose Test ist nicht die Regel für vorzeichenbehafteten Überlauf, bei dem die Vorzeichen von Eingaben und Ergebnis entscheidend sind.

Die M-Erweiterung stellt mul, mulh, mulhu, div, divu, rem und remu bereit. mul behält die unteren Produktbits; die Befehle für die obere Produkthälfte unterscheiden vorzeichenbehaftete und vorzeichenlose Eingaben. Eine Division durch null liefert einen Quotienten, der nur aus Einsen besteht, und den ursprünglichen Dividenden als Rest, ohne eine Divisionsausnahme auszulösen.

Bits auswählen, setzen und umkehren

and, or und xor arbeiten unabhängig auf jedem Bit. UND mit 1 erhält ein Bit; UND mit 0 löscht es. ODER mit 1 setzt ein Bit, und exklusives ODER mit 1 kehrt es um.

srli t0, a0, 4
andi t0, t0, 0xF

Bei a0 = 0xABCD ergibt das Verschieben nach rechts 0xABC. Die Maskierung mit 0xF lässt 0xC übrig, die ursprünglichen Bits 7–4. Die Verschiebung setzt das Feld an das untere Ende; die Maske entfernt alles darüber. Um Bit 4 zu setzen, ohne die anderen zu verändern, verwende ori a0, a0, 0x10. xori mit −1 kehrt alle 32 Bits um.

Eine Verschiebung nach ihrer Auffüllregel wählen

Eine Linksverschiebung mit sll oder slli füllt niederwertige Stellen mit Nullen auf. Eine logische Rechtsverschiebung mit srl oder srli füllt höherwertige Stellen mit Nullen auf. Eine arithmetische Rechtsverschiebung mit sra oder srai kopiert das Vorzeichenbit in die höherwertigen Stellen. Registerverschiebungen in RV32 verwenden nur die unteren 5 Bits des Registers mit der Verschiebungsweite.

Wird 13 um 3 nach links verschoben, ergibt sich 104. Das entspricht einer Multiplikation mit 8, weil keine benötigten Bits verloren gehen. Bei Linksverschiebungen, die signifikante Bits verwerfen, bleibt dagegen nur der Teil des Ergebnisses erhalten, der ins Register passt.

Bei vorzeichenlosen Werten dividiert eine Rechtsverschiebung durch eine Potenz von 2 und rundet ab. Bei vorzeichenbehafteten Werten rundet die arithmetische Rechtsverschiebung gegen minus unendlich: Wird −7 um 1 nach rechts verschoben, ergibt sich −4. Die vorzeichenbehaftete Division in C rundet gegen null und ergibt für -7 / 2 den Wert −3. Ein Compiler benötigt eine Korrektur, bevor er diese vorzeichenbehaftete Division durch eine Verschiebung ersetzt. Eine logische Verschiebung desselben negativen Musters füllt mit Nullen auf und ergibt ein großes positives Ergebnis.

Vergleichen, um einen Wert zu erzeugen

slt schreibt 1, wenn seine erste Quelle bei vorzeichenbehafteter Interpretation kleiner ist, und sonst 0. sltu interpretiert die Werte vorzeichenlos. Mit 0xFFFFFFFF und 1 als Eingaben schreibt slt den Wert 1, sltu dagegen 0. Die Versionen mit Direktoperand sind slti und sltiu; auch Letzterer erweitert seinen Direktoperanden vor dem vorzeichenlosen Vergleich mit Vorzeichen.

Das bitweise UND unterscheidet sich von && in C. Ein bitweises Ergebnis kann viele gesetzte Bits enthalten; das logische UND liefert 0 oder 1 und kann die Auswertung des zweiten Ausdrucks überspringen.

Ein bedingter Sprung vergleicht zwei Register und ändert den Befehlszähler, wenn seine Prüfung erfolgreich ist. Andernfalls wird der nächste Befehl ausgeführt.

Den Vergleich wählen

RISC-V kombiniert Vergleich und Sprung in einem Befehl. Es gibt keine Ganzzahl-Statusflags, die zuerst gesetzt werden müssten. Um gegen null zu prüfen, verwende zero als eine Quelle. beqz a0, L wird zu beq a0, zero, L erweitert.

Formen für „größer als“ und „kleiner oder gleich“ sind Kurzformen des Assemblers mit vertauschten Quellen. bgt a0, a1, L wird zu blt a1, a0, L erweitert. Die Reihenfolge der Quellen richtig zu tauschen ist ebenso wichtig wie die Wahl des richtigen Befehlsnamens.

Vorzeichenbehafteter und vorzeichenloser Kontrollfluss

Enthält a0 den Wert 0xFFFFFFFF und a1 den Wert 1, führt blt a0, a1, L den Sprung aus, weil die vorzeichenbehaftete Zahl −1 kleiner als 1 ist. bltu tut das nicht, weil das erste Muster einen großen vorzeichenlosen Wert darstellt. Verwende Vergleiche, die zur Bedeutung der Daten passen, darunter vorzeichenlose Vergleiche für Adressen.

Eine vorzeichenlose Bereichsprüfung kann sowohl negative vorzeichenbehaftete Indizes als auch Indizes ab einer kleinen nicht negativen Länge zurückweisen:

bgeu a0, a1, OutOfBounds

Bei einer Länge von 20 erscheint der Index −1 vorzeichenlos als 4.294.967.295 und löst den Sprung aus. Der Index 19 tut das nicht, der Index 20 dagegen schon. Die Länge muss die tatsächliche nicht negative Länge des Arrays darstellen.

Unbedingte Sprünge und Rückadressen

jal ra, f schreibt die Adresse des nächsten Befehls, pc + 4, nach ra und springt dann zu f. Ein einfaches j L wird zu jal zero, L erweitert; der Rückadresswert wird verworfen. Das eignet sich für einen Rücksprung in einer Schleife, legt aber keine Rückadresse für einen Aufruf an.

jalr rd, offset(rs1) addiert einen vorzeichenbehafteten 12-Bit-Versatz zu einem Registerwert, löscht Bit 0 des Ziels und schreibt sein eigenes pc + 4 nach rd. ret wird zu jalr zero, 0(ra) erweitert und kehrt zur gesicherten Adresse zurück, ohne eine neue Rückadresse zu behalten.

Bedingte Sprünge und jal speichern Versätze relativ zu ihrer eigenen Befehlsadresse. Ihre Reichweite beträgt etwa ±4 KiB beziehungsweise ±1 MiB. jalr verwendet ein registerbasiertes Ziel und kann den gesamten Adressraum erreichen. Für einen entfernten bedingten Sprung kann die Prüfung umgekehrt werden, um einen weiter reichenden Sprung zu überspringen:

bne a0, a1, Skip
jal zero, Far
Skip:

Hier liegt Far in der Reichweite von jal. Bei Gleichheit wird der kurze bedingte Sprung nicht ausgeführt und die Ausführung läuft in den unbedingten Sprung weiter; andernfalls wird dieser übersprungen.

Einen Basisblock erkennen

Ein Basisblock hat einen einzigen Eintritt an seinem Anfang und keine Kontrollflussübertragung vor seinem Ende. Innerhalb des Blocks werden Befehle der Reihe nach ausgeführt. Sprungziele beginnen neue Blöcke; bedingte und unbedingte Sprünge beenden sie. So lässt sich untersuchen, welche Zuweisungen vor einer bestimmten Prüfung oder einem Austritt immer ausgeführt werden.

Assemblersprache macht jeden Pfad durch eine Verzweigung oder Schleife ausdrücklich sichtbar. Labels markieren Ziele, bedingte Sprünge wählen Pfade, und unbedingte Sprünge verhindern unerwünschtes Weiterlaufen.

Eine if-else-Anweisung braucht einen Austrittspfad

Übersetze if (i == j) f = g + h; else f = g - h; mit f, g, h, i, j in s0–s4:

bne s3, s4, Else
add s0, s1, s2
j Exit
Else:
sub s0, s1, s2
Exit:

Der erste Sprung prüft das Gegenteil der C-Bedingung, sodass die Ausführung bei Gleichheit in die Addition weiterläuft. Der Sprung nach der Addition verhindert die Ausführung der Subtraktion. Bei g = 10 und h = 3 ergeben gleiche Indizes 13; ungleiche Indizes ergeben 7. Wird j Exit entfernt, läuft die Subtraktion auch nach der Addition.

Bei a < b && b < c springst du zum else-Teil, sobald einer der Vergleiche fehlschlägt. Bei a < b || b < c springst du zum then-Teil, sobald einer erfolgreich ist. Das implementiert die Kurzschlussauswertung und überspringt auch einen zweiten Ausdruck, dessen Wert nicht benötigt wird.

Eine while-Schleife prüft vor ihrem Rumpf

Für while (save[i] == k) i++; halte i in s3, k in s5 und die Arraybasis in s6:

Loop:
slli t1, s3, 2
add t1, t1, s6
lw t0, 0(t1)
bne t0, s5, Exit
addi s3, s3, 1
j Loop
Exit:

Bei jedem Durchlauf wird die Adresse des aktuellen Elements gebildet, das Element geladen und geprüft. Beim Array {7, 7, 7, 2, 7}, dem Anfangsindex 0 und k = 7 endet die Schleife mit Index 3. Die fehlgeschlagene Prüfung erhöht den Index nicht. Das Array muss innerhalb seines gültigen Bereichs ein Element enthalten, das die Schleife beendet.

Ein Array mit bekannter Elementanzahl summieren

Für eine nicht negative Elementanzahl in a1 und die Arraybasis in a0:

li t1, 0
li t0, 0
Loop:
bge t0, a1, Done
slli t2, t0, 2
add t2, a0, t2
lw t3, 0(t2)
add t1, t1, t3
addi t0, t0, 1
j Loop
Done:
mv a0, t1
ret

Die Prüfung am Anfang behandelt eine Länge von null, ohne etwas zu laden. Bei vier Elementen {5, -2, 10, 7} beträgt die laufende Summe zunächst 5, dann 3, 13 und schließlich 20. Die Folge führt 33 Befehle aus: 2 zur Vorbereitung, 7 für jeden der vier erfolgreichen Durchläufe, eine fehlgeschlagene Prüfung und 2 zum Abschluss.

Eine Zeigervariante bildet einmal eine Endadresse und erhöht die aktuelle Adresse um 4. Für einen gültigen Arraybereich, dessen Endadresse keinen Überlauf aufweist, kann sie vorzeichenlose Adressvergleiche verwenden:

li t1, 0
slli t0, a1, 2
add t0, a0, t0
bgeu a0, t0, Done
Loop:
lw t3, 0(a0)
add t1, t1, t3
addi a0, a0, 4
bltu a0, t0, Loop
Done:
mv a0, t1
ret

Es gibt 4 Befehle zur Vorbereitung, 4 pro Durchlauf und 2 zum Abschluss, insgesamt 22 für vier Elemente. Der erste Sprung überspringt den Rumpf bei einem leeren Bereich; der Zeiger wird nach jedem Laden um ein Element weitergesetzt.

Mehrfachverzweigungen

Ein switch kann wiederholte Vergleiche oder bei dicht beieinanderliegenden Fallwerten eine Sprungtabelle verwenden. Der Sprung über die Tabelle prüft den Fallbereich, multipliziert einen Index mit der Eintragsgröße von 4 Bytes, lädt die Falladresse und springt mit jalr zero, 0(t0) dorthin. Die Bereichsprüfung muss vor dem Laden aus der Tabelle erfolgen, damit ein ungültiger Fall keine fremde Adresse auswählen kann.

Ein Maschinenbefehl ist ein 32-Bit-Wort, das in Felder aufgeteilt ist. Kodieren bedeutet, die richtige Anordnung zu wählen, jeden Operanden einem Feld zuzuweisen und jedes Feld in seiner vollen Breite zu schreiben.

Feste Positionen vereinfachen die Dekodierung

Die unteren 7 Bits, 6–0, enthalten den Operationscode. Wo vorhanden, belegt rd die Bits 11–7, funct3 die Bits 14–12, rs1 die Bits 19–15 und rs2 die Bits 24–20. Fünf Bit breite Registerfelder bezeichnen x0 bis x31. Funktionsfelder unterscheiden Operationen mit demselben Operationscode.

RV32I verwendet die Formate R, I, S, B, U und J. Sie bringen unterschiedliche Operanden in denselben 32 Bits unter und halten dabei die Registerpositionen fest. Bei vorzeichenbehafteten Direktoperanden trägt Bit 31 das Vorzeichen.

R-Format: zwei Quellen und ein Ziel

Von Bit 31 abwärts bis Bit 0 lautet die R-Anordnung:

funct7 | rs2 | rs1 | funct3 | rd | opcode
   7      5     5       3     5       7 bits

Für add s0, a0, a1 gilt rd = 8, rs1 = 10, rs2 = 11. ADD verwendet den Operationscode 0110011, funct3 = 000, funct7 = 0000000:

0000000 | 01011 | 01010 | 000 | 01000 | 0110011
0000 0000 1011 0101 0000 0100 0011 0011

Das Hexadezimalwort ist 0x00B50433. SUB ändert nur funct7 zu 0100000 und ergibt für sub s0, a0, a1 den Wert 0x40B50433. Die Quellfelder stehen in einer anderen Reihenfolge als die Assembleroperanden. Hänge daher nicht einfach die ausgegebenen Registernamen aneinander.

I-Format: eine Quelle und ein Direktoperand

Die I-Anordnung lautet imm[11:0] | rs1 | funct3 | rd | opcode. addi verwendet den Operationscode 0010011 und funct3 = 000. In addi sp, sp, -16 enthalten beide Registerfelder 00010. Der 12-Bit-Direktoperand ist 111111110000 (0xFF0) und ergibt 0xFF010113.

Auch ein Ladebefehl verwendet das I-Format, mit der Adressbasis als rs1 und dem geladenen Register als rd. lw t0, 32(s3) hat den Direktoperanden 32, die Basis x19, das Ziel x5, den Operationscode 0000011 und funct3 = 010; das ergibt 0x0209A283.

Schiebeoperationen mit Direktoperand verwenden die unteren 5 Bits des Direktoperandenbereichs als Verschiebungsweite. Die oberen Steuerbits unterscheiden die Verschiebungen: srli t0, t1, 3 ist 0x00335293, während srai t0, t1, 3 gleich 0x40335293 ist. Bit 30 wählt die arithmetische Auffüllregel.

S-Format: einen Quellwert speichern

Ein Speicherbefehl hat kein Register als Ziel. Die S-Anordnung verwendet diesen Platz für einen Teil ihres Direktoperanden:

imm[11:5] | rs2 | rs1 | funct3 | imm[4:0] | opcode

Bei sw t0, 48(s3) liefert rs2 = 5 den gespeicherten Wert und rs1 = 19 die Basis. Der 12-Bit-Direktoperand 48 wird in 0000001 und 10000 aufgeteilt. Mit funct3 = 010 und dem Operationscode 0100011 ergibt sich 0x0259A823. Es gibt kein rd, das mit t0 zu füllen wäre.

Gruppiere nach dem Zusammenfügen der Felder die vollständige 32-Bit-Folge in acht 4-Bit-Nibbles und wandle jedes in eine Hexadezimalziffer um. Dekodiere dann das Ergebnis und prüfe Operationscode, Registernummern und vorzeichenbehafteten Direktoperanden. Ein Registerfeld auf 5 Bits aufzufüllen ist unerlässlich; das Weglassen einer führenden Null verändert die Positionen späterer Felder.

Kodierungen für bedingte und unbedingte Sprünge sparen Platz, indem sie ein Versatzbit weglassen, das immer null ist. Ihre Felder stellen weiterhin Abstände in Bytes dar, und das Vorzeichen muss vor der Berechnung des Ziels rekonstruiert werden.

Sprungversätze im B-Format

Berechne den Versatz als Zieladresse minus Adresse des Sprungbefehls selbst. Ein bne bei 0x1010 mit dem Ziel 0x1000 verwendet −16 Bytes, nicht −20 und nicht −4 Befehle.

Das B-Format verwendet den Operationscode 1100011. Sein vorzeichenbehafteter Versatz hat 13 Bits, einschließlich eines nicht gespeicherten Bits 0 mit dem Wert null. Der Bereich reicht von −4096 bis +4094 Bytes in Schritten von 2. Die Anordnung lautet:

Die Quellfelder bleiben an ihren gewohnten Positionen. Die funct3-Werte sind 000 für beq, 001 für bne, 100 für blt, 101 für bge, 110 für bltu und 111 für bgeu.

Für bne t0, t1, -16 lautet der 13-Bit-Versatz 1 1111 1111 0000. Seine verstreuten Teile sind in der Reihenfolge der Tabelle 1, 111111, 1000 und 1. Mit rs1 = 5 und rs2 = 6 lautet der Befehl 0xFE6298E3. Ersetzt du den Versatz durch +12, ergibt sich 0x00629663.

Versätze unterstützen 2-Byte-Schritte, weil komprimierte Befehle 2 Bytes lang sein können. Ein angesprungenes Ziel muss dennoch die geltende Befehlsausrichtung erfüllen: RV32I ohne komprimierte Befehle verlangt eine Ausrichtung auf 4-Byte-Grenzen.

J-Format und U-Format

jal verwendet den Operationscode 1101111. Sein vorzeichenbehafteter 21-Bit-Byteversatz lässt Bit 0 weg und ordnet die Bits in der Reihenfolge imm[20|10:1|11|19:12] über die Befehlsbits 31–12 an. Der Bereich reicht von −1.048.576 bis +1.048.574 Bytes. jal ra, 192 wird zu 0x0C0000EF.

Das U-Format setzt seinen oberen 20-Bit-Wert direkt in die Befehlsbits 31–12, gefolgt von rd und dem Operationscode. lui verwendet 0110111; auipc verwendet 0010111. Daher ist lui t0, 0x12345 gleich 0x123452B7.

Zuerst anhand des Operationscodes dekodieren

Bei 0x00A12423 lauten die unteren 7 Bits 0100011: ein Speicherbefehl. funct3 = 010 wählt sw. Die Quellfelder ergeben die Basis x2 (sp) und den Wert x10 (a0). Die beiden Teile des Direktoperanden ergeben zusammen 8, also lautet der Assemblerbefehl sw a0, 8(sp).

Setze bei einem bedingten Sprung die verstreuten Teile in der Reihenfolge der Versatzbits zusammen, hänge die implizite Null an und erweitere das vollständige 13-Bit-Ergebnis mit Vorzeichen. Werden die 12 gespeicherten Bits wie ein gewöhnlicher Direktoperand des I-Formats behandelt, gehen sowohl die richtige Anordnung als auch die Skalierung verloren. Die feste Position des Vorzeichenbits und die Wiederverwendung anderer Feldpositionen verringern den Aufwand für den Dekodierer, obwohl die dargestellte Anordnung von Hand weniger bequem zu lesen ist.

Relokation erhält Beziehungen

Werden ein Sprung und sein Ziel beide um denselben Abstand verschoben, ergibt die Subtraktion ihrer neuen Adressen den alten Versatz. Ein Verweis in einen anderen Abschnitt kann sich ändern, wenn Abschnitte getrennt angeordnet werden. Ein Linker kann daher einen internen relativen Sprung erhalten und zugleich einen Verweis auf ein externes Symbol anpassen.

Ein Prozeduraufruf überträgt Steuerung und Daten zwischen unabhängig geschriebenen Codeteilen. Die Aufrufkonvention legt für beide Seiten fest, wohin Argumente und Ergebnisse gehören und welche Registerwerte erhalten bleiben müssen.

Die Aufruf- und Rückkehrfolge

Der Aufrufer legt die ersten acht Ganzzahlargumente in a0–a7 ab; weitere Argumente kommen auf den Stack. Die Prozedur gibt ein ganzzahliges Ergebnis in a0 zurück und verwendet bei einem 64-Bit-Ergebnis in RV32 zusätzlich a1.

jal ra, f speichert seine eigene Adresse plus 4 in ra und springt dann zu f. jal f ist die Kurzschreibweise. Der Pseudobefehl call f wird für größere Reichweite normalerweise zu auipc und jalr erweitert; der Linker kann ihn zu einem jal verkürzen. In beiden Fällen folgt die Rückadresse auf die tatsächliche Aufruffolge.

ret entspricht jalr zero, 0(ra). Der Befehl springt über die gesicherte Adresse zurück und verwirft eine neue Rückadresse. Auch ein einfaches j f verwirft seine Rückadresse und richtet daher keinen gewöhnlichen Aufruf mit Rückkehr ein.

Entscheiden, wer einen Wert sichert

Zu den Caller-saved-Registern gehören t0–t6, a0–a7 und ra. Die aufgerufene Prozedur darf sie verändern. Benötigt der Aufrufer einen ihrer aktuellen Werte später, sichert er diesen vor dem Aufruf.

Zu den Callee-saved-Registern gehören s0–s11 und sp. Eine aufgerufene Prozedur, die ein s-Register verändert, muss den Eingangswert sichern und vor der Rückkehr wiederherstellen. Durch das Wiederherstellen von sp gelangt der Aufrufer zu seinem eigenen Frame zurück. Der Prozessor erzwingt diese Zusagen nicht; kompilierte Module arbeiten zusammen, weil ihre Software die ABI einhält.

Angenommen, ein Aufrufer hat einen Schleifenzähler in t0 und ruft eine Hilfsprozedur auf. Diese darf t0 für ihre eigene Berechnung verwenden. Wird der Zähler nach s1 verschoben, kann er Hilfsaufrufe überdauern. Die umgebende Prozedur muss dann aber den s1-Wert erhalten, den sie von ihrem eigenen Aufrufer erhalten hat.

Eine Blattprozedur benötigt möglicherweise keinen Frame

Eine Blattprozedur ruft keine andere Prozedur auf. Diese Funktion berechnet (g + h) - (i + j) aus Argumenten in a0–a3:

leaf:
add t0, a0, a1
add t1, a2, a3
sub a0, t0, t1
ret

Sie verwendet nur Caller-saved-Arbeitsregister und lässt ra unverändert. Für die Eingaben 9, 4, 6 und 1 gibt sie 6 zurück. Sie benötigt keinen Stackframe.

Verwendet die Berechnung stattdessen s0, muss sie dieses Register erhalten:

addi sp, sp, -16
sw s0, 12(sp)
add t0, a0, a1
add t1, a2, a3
sub s0, t0, t1
mv a0, s0
lw s0, 12(sp)
addi sp, sp, 16
ret

Das Ergebnis wird nach a0 verschoben, bevor das alte s0 wiederhergestellt wird. War der Eingangswert von s0 gleich 1234, ist er danach noch immer 1234. Der reservierte Frame ist 16 Bytes groß, um die standardmäßige Stackausrichtung einzuhalten, obwohl das gesicherte Wort nur 4 Bytes belegt.

Ein Aufruf lässt sich als sechs Handlungen lesen: Argumente ablegen, Steuerung übertragen, Speicher beschaffen, Aufgabe ausführen, Ergebnis ablegen und zurückkehren. Unterscheide an jeder Grenze den zurückgegebenen Wert von den älteren Werten, die die Prozedur nach der Konvention erhalten muss.

Verschachtelte Aufrufe brauchen einen Platz für die Daten des äußeren Aufrufs. Der Stack speichert nach dem Prinzip „zuletzt hinein, zuerst heraus“: Der jüngste Aufruf endet zuerst und gibt seinen eigenen Frame frei.

Unterhalb des alten Stackpointers reservieren

Der Stack wächst zu niedrigeren Adressen hin. addi sp, sp, -16 reserviert 16 Bytes; addi sp, sp, 16 gibt sie frei. Die Standard-ABI hält sp während der gesamten Ausführung auf einem Vielfachen von 16. Ein Frame kann gesicherte Register, die Rückadresse, ausgelagerte Werte, lokale Objekte und Platz für ausgehende Stackargumente enthalten.

Ein häufiges Muster für eine Prozedur, die weitere Prozeduren aufruft, ist:

addi sp, sp, -16
sw ra, 12(sp)
sw s0, 8(sp)
# body, including calls
lw s0, 8(sp)
lw ra, 12(sp)
addi sp, sp, 16
ret

Die Versätze beziehen sich auf das neue sp. Ist es 0x2000, belegt das gesicherte ra die Adressen 0x200C bis 0x200F. Der zugehörige Epilog stellt Werte wieder her, solange der Frame noch existiert, und gibt ihn dann frei. Jeder Rückkehrpfad muss die Reservierung ausgleichen.

Ein Framepointer, üblicherweise s0, kann lokalen Objekten feste Versätze geben, wenn sich sp innerhalb einer Prozedur ändert. Sein Eingangswert muss wie bei jeder anderen Verwendung von s0 erhalten bleiben.

Rekursion hält getrennte Kopien

Die Fakultät benötigt das ursprüngliche n, nachdem fact(n - 1) berechnet wurde. Außerdem benötigt sie ihre eigene Rückadresse, nachdem das rekursive jal den Wert in ra überschrieben hat:

fact:
addi sp, sp, -16
sw ra, 12(sp)
sw a0, 8(sp)
li t0, 2
blt a0, t0, Base
addi a0, a0, -1
jal ra, fact
lw t1, 8(sp)
mul a0, t1, a0
j Done
Base:
li a0, 1
Done:
lw ra, 12(sp)
addi sp, sp, 16
ret

Der Befehl mul aus der M-Erweiterung multipliziert das zurückgegebene innere Ergebnis mit dem ursprünglichen n. Bei fact(3) existieren Frames für 3, 2 und 1 gleichzeitig. Der Basisaufruf gibt 1 zurück; der nächste gibt 2 zurück; der äußere Aufruf gibt 6 zurück. Bei anfänglich sp = 0x7FFFFF00 senken drei Frames den Wert um 48 Bytes auf 0x7FFFFED0. Bei der Rückkehr werden sie in umgekehrter Reihenfolge freigegeben.

Die Basisprüfung behandelt die nicht negativen Werte 0 und 1. Für dieses 32-Bit-Ergebnis ist die Fakultät bis einschließlich 12! exakt: 479.001.600. Bei 13!, also 6.227.020.800, stellen die unteren Produktbits nicht mehr das vollständige Ergebnis dar.

Den Stack im Programmspeicher einordnen

Eine typische Aufteilung enthält Code im Textsegment, globale Daten in den statischen Daten, dynamisch reservierte Objekte im Heap und Aufrufframes im Stack. Der Heap wächst oft nach oben und der Stack nach unten. Die tatsächliche Platzierung bestimmt die Ausführungsumgebung.

Ein Zeiger auf ein lokales Stackobjekt wird ungültig, wenn die Lebensdauer dieses Objekts bei der Rückkehr endet. Das Wiederherstellen von sp löscht die alten Bytes nicht, aber spätere Aufrufe können sie erneut verwenden. Ebenso kann das Verändern von sp bei weiterer Verwendung alter Sicherungsversätze dazu führen, dass Bytes aus dem falschen Frame gelesen werden.

Ein Zeiger ist ein Adresswert. Assemblersprache implementiert eine Dereferenzierung, indem sie diese Adresse als Basis für einen Lade- oder Speicherzugriff verwendet, und Zeigerarithmetik durch Addition eines Byteabstands.

Dem Zeiger folgen und dann auf den Wert zugreifen

Mit int *p in a0 liest lw t0, 0(a0) den Wert von *p, während sw t0, 0(a0) ihn schreibt. Das Register enthält die Adresse; der Speicher an dieser Adresse enthält die ganze Zahl. Ist eine Zeigervariable selbst im Speicher abgelegt, lade zuerst diesen Zeigerwert und verwende ihn dann als Basis für einen zweiten Ladezugriff.

Um die Adresse eines lokalen C-Objekts zu ermitteln, wird adressierbarer Speicher benötigt, normalerweise ein Stackplatz. Ein Hardwareregister hat keine Speicheradresse, die als &x übergeben werden kann.

C-Zeigerarithmetik skaliert automatisch. Bei RV32 ILP32 addiert das Erhöhen von int *p den Wert 4 Bytes, während das Erhöhen von char *p 1 addiert. Assemblersprache hat keinen Zeigertyp, der die Skalierung vorgibt:

addi a0, a0, 4    # next int
addi a1, a1, 1    # next char

Ein Arrayargument ist seine Basisadresse, keine Kopie seiner Elemente. Übergib die Elementanzahl separat, wenn eine Prozedur sie benötigt; der Zeiger allein kodiert die Arraylänge nicht.

Strukturfelder haben Byteversätze

Für struct item { int id; int score; }; belegt id die Bytes 0–3 und score die Bytes 4–7. Mit der Adresse des Objekts in a0 liest lw t0, 4(a0) den Punktwert. Im Allgemeinen folgen Feldversätze den Layout- und Padding-Regeln der ABI. Leite nicht jeden Feldversatz allein durch Zählen der Quelldeklarationen ab.

Bei einem Array dieser 8-Byte-Strukturen beginnt das nächste Element 8 Bytes später. Innerhalb jedes Elements bleibt der Punktwert 4 Bytes vom Beginn dieses Elements entfernt. Elementabstand und Feldversatz sind getrennte Teile der Adressberechnung.

Eine nullterminierte Zeichenkette kopieren

Eine C-Bytezeichenkette endet mit einem Nullbyte. Um sie zu kopieren, lies und speichere ein Byte, bevor du entscheidest, ob der Kopiervorgang abgeschlossen ist:

Loop:
lbu t0, 0(a1)
sb t0, 0(a0)
addi a0, a0, 1
addi a1, a1, 1
bnez t0, Loop
ret

Hier ist a1 die Quelle und a0 das Ziel. Das Ziel muss genügend Platz haben. lbu liest ein vorzeichenloses Byte; sb speichert nur dessen untere 8 Bits. Beide Zeiger werden um 1 weitergesetzt, auch im letzten Durchlauf. Der bedingte Sprung prüft das kopierte Byte, sodass auch die abschließende Null gespeichert wird.

Das Kopieren von „RISC“ benötigt fünf Durchläufe für vier Buchstaben und das Nullbyte. Bei fünf Befehlen pro Durchlauf plus ret werden 26 Befehle ausgeführt. Eine leere Zeichenkette benötigt dennoch einen Durchlauf, um ihren Nullterminator zu kopieren. Ein Ladebefehl für Wörter würde vier Bytes auf einmal lesen und diesen byteweisen Algorithmus nicht implementieren.

UTF-8 kann ein Zeichen in mehreren Bytes kodieren. Diese Schleife kopiert diese Bytes unverändert; sie zählt keine angezeigten Zeichen. Zeigerbasierte Arrayschleifen können entsprechend um den Elementabstand weitergehen, ohne jedes Mal einen skalierten Index neu zu berechnen. Optimierende Compiler können diese Umwandlung auch vornehmen, wenn das C-Programm gewöhnliche Arrayindizes verwendet.

Eine Quelldatei wird durch mehrere Übersetzungsphasen zu ausführbaren Befehlen. Jede Phase hat eine andere Aufgabe, und Zwischendateien enthalten Informationen, die spätere Phasen benötigen.

Der Compiler wählt Befehle

Für C führt der übliche Weg vom Quellcode über Assemblersprache, Objektdatei und ausführbare Datei zu einem laufenden Prozess. Ein Compiler analysiert Quellcode, optimiert ihn, weist Register zu und wählt Befehle für eine Ziel-ISA. Ein Compiler-Treiber kann mehrere Phasen mit einem Befehl ausführen.

gcc -S program.c stoppt nach dem Erzeugen von Assemblercode. gcc -c program.c erzeugt eine Objektdatei, ohne zu linken. Der Zielcompiler bestimmt, welche ISA der Assemblercode verwendet; ein RISC-V-Programm benötigt eine auf RISC-V ausgerichtete Werkzeugkette.

Bei -O0 laufen Werte häufig über Stackplätze, und der Assemblercode folgt den einzelnen Quellanweisungen eng. Bei -O2 können Registerallokation, entfernte Arbeitsschritte und umstrukturierte Schleifen diese Entsprechung verschleiern. Eine C-Anweisung hat keine einzelne feste Übersetzung in Assemblersprache.

Der Assembler kodiert und erfasst

Der Assembler wandelt Befehls- und Registernamen in Bits um, erweitert Pseudobefehle und löst Labels auf, deren Position er bestimmen kann. Ein Vorwärtssprung verweist auf ein später auftretendes Label. Ein Assembler kann zuerst Positionen sammeln und dann Verweise kodieren oder Stellen vormerken, die ausgefüllt werden, sobald das Ziel bekannt ist.

Direktiven teilen dem Assembler mit, wie er die Ausgabe organisieren soll; der Prozessor führt sie nicht aus:

.data
.align 2
count:
.word 5
message:
.string "hi"
.text
.globl main
main:
# instructions follow

.word 5 gibt einen 4-Byte-Datenwert aus. .string "hi" gibt die Zeichenbytes und eine abschließende Null aus. Beim GNU-RISC-V-Assembler richtet .align 2 das nächste Element an einer 4-Byte-Grenze aus. .globl macht ein Symbol für andere Objektdateien sichtbar. Labels bezeichnen Positionen; sie reservieren selbst keine Bytes.

Was eine Objektdatei enthält

Eine relokierbare Objektdatei enthält typischerweise einen Header, Code in Textabschnitten, statische Daten, eine Symboltabelle und Relokationsinformationen. Die Symboltabelle unterscheidet hier definierte Namen von Verweisen, die anderswo definiert sind. Optionale Debuginformationen verbinden Befehle mit Quellcodezeilen; -g fordert sie an.

Zu den üblichen Objektformaten gehören ELF, Mach-O und PE/COFF. Das Format organisiert Maschinencode und Metadaten; es unterscheidet sich von der ISA, die die Bits jedes Befehls festlegt.

Für call printf kann der Assembler eine auipc/jalr-Folge ausgeben, ohne die endgültige Funktionsadresse zu kennen. Er erfasst ein undefiniertes Symbol und Relokationseinträge, damit der Linker den Verweis vervollständigen kann. Der Abstand eines lokalen Sprungs kann bereits bekannt sein, wenn sich sein Ziel mit demselben Abschnitt bewegt; spätere Layoutänderungen wie eine Verkürzung können dennoch eine Anpassung erfordern.

Andere Ausführungswege

Ein Interpreter führt Operationen durch ein anderes laufendes Programm aus. Ein Just-in-time-Compiler erzeugt während der Ausführung Maschinencode, häufig nachdem er oft verwendeten Code erkannt hat. Java verwendet gewöhnlich Bytecode mit anschließender Interpretation und JIT-Kompilierung; Python verwendet gewöhnlich einen Interpreter. Ein JIT-Compiler nimmt Kompilieraufwand während der Ausführung in Kauf, um wiederholte Ausführungen zu beschleunigen.

Eine Objektdatei ist also mehr als eine reine Befehlsliste, aber noch kein vollständiger laufender Prozess. Nicht aufgelöste Symbole und die endgültige Anordnung müssen noch von Linker und Lader bearbeitet werden.

Ein Linker erstellt aus Objektmodulen und Bibliotheken eine ausführbare Datei. Ein Lader verwendet diese Datei, um einen laufenden Prozess zu erzeugen. Wenn du weißt, welche Phase für eine Adresse zuständig ist, kannst du sowohl Relokations- als auch Startfehler erklären.

Module anordnen und Verweise anpassen

Der Linker platziert Eingabeabschnitte im Adressraum der ausführbaren Datei, löst Symboldefinitionen auf und passt Verweise anhand von Relokationseinträgen an. Ein Name, den kein gelinktes Modul definiert, erzeugt einen Fehler „undefined reference“.

Angenommen, Text beginnt bei 0x00010000 und Daten bei 0x10000000. Objekt A steuert 0x100 Textbytes und 0x20 Datenbytes bei; B folgt unmittelbar. Der Text von B beginnt bei 0x00010100 und seine Daten bei 0x10000020.

Ein jal in A beim Textversatz 0x40 hat die Adresse 0x00010040. Beginnt procB am Textanfang von B, beträgt der Versatz des Aufrufs 0xC0 oder 192 Bytes, mit ra kodiert als 0x0C0000EF. Eine Variable beim Versatz 0x10 in den Daten von B landet bei 0x10000030. Bei gp = 0x10000800 beträgt ihr Versatz −2000, was in einen vorzeichenbehafteten 12-Bit-Ladeversatz passt. Dies sind getrennte Berechnungen für Text und Daten.

Wählen, wie Bibliothekscode bereitgestellt wird

Statisches Linken kopiert benötigten Bibliotheks-Objektcode in die ausführbare Datei. Das Programm führt diesen Code mit sich, wodurch die Datei größer wird; um eine Bibliothekskorrektur zu übernehmen, muss es erneut gelinkt werden. Statische Bibliotheken beseitigen nicht die Abhängigkeit des Programms von seiner Betriebssystemschnittstelle.

Dynamisches Linken hält Bibliothekscode in gemeinsam genutzten Dateien wie .so, .dll oder .dylib. Kompatible Bibliothekscodeseiten können von Prozessen gemeinsam genutzt werden. Eine kompatible aktualisierte Bibliothek kann Programme bedienen, ohne jede ausführbare Datei erneut zu linken; die benötigte Version muss aber verfügbar sein, wenn sie gebraucht wird.

Bei verzögerter Bindung in ELF führt der erste Aufruf über ein Verbindungsstück der Prozedurverknüpfungstabelle (PLT). Der dynamische Linker löst das Ziel auf und erfasst es in der globalen Versatztabelle (GOT); spätere Aufrufe verwenden diese erfasste Adresse. Andere Konfigurationen lösen Symbole beim Laden auf.

Positionsunabhängiger Code erreicht lokale Ziele über relative Adressierung, einschließlich auipc-Folgen, und verwendet für externe Ziele Indirektion. Die eigenen relativen Abstände einer Bibliothek bleiben gültig, wenn sie als Einheit verschoben wird. Das Binden externer Verweise kann weiterhin Relokationsarbeit erfordern.

Der Lader erzeugt den laufenden Zustand

Der Lader liest Metadaten der ausführbaren Datei, erstellt einen Adressraum, bildet Code und Daten ab oder kopiert sie, richtet Argumente und den anfänglichen Stack ein, initialisiert den erforderlichen Registerzustand und überträgt die Steuerung an den Startcode. Der Startcode ruft main auf; nach dessen Rückkehr fordert der Laufzeitcode das Beenden des Prozesses an. Moderne Systeme können Dateiseiten abbilden und bei Bedarf in den Speicher laden.

ecall fordert einen Dienst der Umgebung an. Unter RISC-V-Linux enthält a7 die Systemaufrufnummer und a0–a5 enthalten Argumente. li a7, 93, li a0, 0, ecall fordert die Beendigung mit Status 0 an; Dienst 64 ist write. Die Dienstnummern eines Simulators stammen aus dessen eigener Schnittstelle.

Eine beim Linken fehlende Bibliothek verursacht einen Linkfehler. Eine benötigte gemeinsam genutzte Bibliothek, die nach dem Linken entfernt wird, kann dagegen das Laden verhindern oder einen Fehler bei der Bindung zur Laufzeit verursachen. Die ausführbare Datei kann erfolgreich erstellt worden sein, obwohl sie jetzt nicht starten kann.

RISC und CISC bezeichnen allgemeine Ansätze zum Befehlssatzentwurf. Ein sinnvoller Vergleich betrachtet, wie jeder Ansatz Arbeit darstellt: durch Operandenpositionen, Befehlslänge, Adressberechnung und Kontrollfluss.

Einheitliche Operationen oder umfangreichere Befehle

RISC-Entwürfe bevorzugen einfache Operationen, viele Register und Load-Store-Zugriffe. Der Ansatz entstand aus der Arbeit am IBM-Projekt 801 Mitte der 1970er-Jahre sowie an Berkeley RISC und Stanford MIPS Anfang der 1980er-Jahre. RISC-V, ARM AArch64, MIPS und Power folgen dieser allgemeinen Tradition.

CISC-Entwürfe bieten Befehle variabler Länge, vielfältigere Adressierung und Operationen, die mehrere Schritte verbinden können. x86 entstand aus dem 1978 eingeführten 8086; zu früheren CISC-Familien gehören VAX und Motorola 68000.

In der Intel-x86-Syntax liest add eax, [ebx+8] einen 32-Bit-Wert aus dem Speicher und addiert ihn zu eax. Die entsprechende RISC-V-Operation benötigt einen Ladebefehl mit anschließender Addition:

lw t0, 8(s1)
add a0, a0, t0

Der x86-Befehl verbindet einen Speicherzugriff mit einer Addition. RISC-V stellt sie als separate Befehle dar. x86 nennt einen 32-Bit-Wert Doppelwort; sein Wort ist 16 Bit breit. Ein Wort in den RV32-Beispielen ist 32 Bit breit.

Kodierung und Adressierung

Ein x86-Befehl ist 1 bis 15 Bytes lang. RISC-V-Basisbefehle belegen 4 Bytes; über C sind komprimierte Formen mit 2 Bytes verfügbar. Einheitliche Feldpositionen vereinfachen die Dekodierung. Variable Längen können Platz sparen, indem sie kurze Kodierungen für häufige Operationen verwenden.

RISC-V verwendet Registeroperanden, Direktoperanden, Basisadressen mit Versatz und PC-relative Adressen. jalr gehört zur registerbasierten Adressierung, während bedingte Sprünge, jal und auipc den pc verwenden.

x86 kombiniert außerdem Basis, skalierten Index und Versatz. mov eax, [ebx + esi*4 + 8] liest ein indiziertes 4-Byte-Element mit einem zusätzlichen Versatz in einem Befehl. RISC-V bildet vor dem Laden den skalierten Index und die effektive Adresse mit separaten Befehlen. Die Arbeit muss in beiden Prozessoren intern dennoch stattfinden.

Register und Vergleiche

RISC-V hat 32 Ganzzahlregister einschließlich seines fest auf null gesetzten Registers. Herkömmliches x86-64 hat 16 Allzweckregister; 32-Bit-x86 hat 8. Viele arithmetische x86-Befehle verwenden ein Ziel, das zugleich Quelle ist: add eax, ebx verändert eax. Das add mit drei Operanden von RISC-V kann beide Quellwerte erhalten und zugleich in ein drittes Register schreiben.

Arithmetische x86-Befehle und cmp setzen Flags; ein späterer bedingter Sprung wie jl prüft diese Flags. RISC-V verwendet blt, um direkt zu vergleichen und zu springen. ARM AArch64 verwendet ebenfalls Flags, daher lässt sich eine ISA allein anhand vorhandener Flags nicht als CISC einordnen.

Was „reduziert“ bedeutet

RISC bedeutet nicht, dass eine moderne ISA insgesamt sehr wenige Befehle haben muss. RV32I hat 40 Basisbefehle, aber optionale Erweiterungen ergänzen viele weitere. Die zentrale Idee sind einheitliche, relativ einfache Operationen und Kodierungen. Komprimierte Kodierungen zeigen außerdem, dass eine feste Befehlslänge eine Entwurfstendenz ist und keine Definition, die jeder RISC-Befehl erfüllen muss.

Ein Befehlssatz prägt die Arbeit, die ein Programm ausdrückt, doch die Ausführungsgeschwindigkeit hängt auch vom Prozessor ab, der ihn implementiert. Vergleiche das gemessene oder modellierte Verhalten eines Programms, nicht die Anzahl der Operationen, die ein einzelner Befehl verspricht.

Alle drei Leistungsfaktoren verbinden

Die CPU-Zeit entspricht der Befehlsanzahl mal den mittleren Taktzyklen pro Befehl (CPI) mal der Taktperiode. Gleichwertig kannst du die Befehlsanzahl mal CPI durch die Taktfrequenz dividieren. Eine geringere Befehlsanzahl kann durch einen höheren CPI-Wert oder einen langsameren Takt aufgewogen werden.

Bei 2 GHz dauert jeder Taktzyklus 0,5 ns. Eine Version mit 1,0 Milliarden Befehlen und einem CPI-Wert von 2,0 benötigt 2,0 Milliarden Taktzyklen und dauert 1,0 s. Eine andere mit 1,3 Milliarden Befehlen und einem CPI-Wert von 1,2 benötigt 1,56 Milliarden Taktzyklen und dauert 0,78 s. Die zweite führt 30 % mehr Befehle aus, ist aber etwa 1,28-mal so schnell. Der CPI-Wert ist ein Durchschnitt für dieses Programm auf dieser Implementierung, keine allgemeingültige Eigenschaft einer ISA.

Komplexe Befehle benötigen weiterhin interne Arbeit

Viele moderne x86-Prozessoren übersetzen die meisten Befehle in einfachere interne Mikrooperationen. Diese können anschließend Ausführungstechniken nutzen, die denen moderner RISC-Kerne ähneln. Die externe ISA bleibt für Kodierung, Dekodierung und Kompatibilität wichtig, selbst wenn die internen Operationen ähnlich aussehen.

Ein komplexer Befehl garantiert keine feste Anzahl von Taktzyklen. Ein Befehl zum Kopieren eines Blocks und eine einfache Kopierschleife können je nach Prozessor und Arbeitslast unterschiedlich schnell sein. Prozessormodell, Datengröße und Speicherverhalten sind wichtig; eine Auflistung mit nur einem Quellbefehl kann das Ergebnis nicht entscheiden.

Codedichte ist ein eigener Kennwert

Kürzere Maschinencodefolgen können Speicherplatz sparen und den Befehlscache entlasten. Variable CISC-Befehlslängen erhöhen oft die Dichte. Die RISC-V-Erweiterung C bietet neben 32-Bit-Befehlen 16-Bit-Kodierungen für häufige Operationen. Die Spezifikation nennt eine typische Nutzung für 50–60 % der Befehle, wodurch der Code ungefähr 25–30 % kleiner wird.

Von 100 Befehlen, von denen die Hälfte komprimiert ist, verwenden 50 je 2 Bytes und 50 je 4: insgesamt 300 statt 400 Bytes. Die Anzahl der ausgeführten Befehle bleibt 100. Eine Größenverringerung allein sagt keinen Speedup voraus, weil die Laufzeit von mehr als den geholten Bytes abhängt.

Kompatibilität und Werkzeuge prägen die Wahl

Vorhandene x86-Binärdateien und -Bibliotheken machen Kompatibilität besonders wertvoll. RISC-V friert Basisbefehlssätze ein und ergänzt Erweiterungen. RV32I-Code kann auf einer Implementierung mit RV32I-Unterstützung laufen, wenn ABI und Ausführungsumgebung übereinstimmen; die Verwendung von M oder V stellt zusätzliche Anforderungen. RV32E ist ein anderer Basisbefehlssatz mit reduzierter Registerzahl und verspricht keine RV32I-Kompatibilität.

ARM wird verbreitet in Mobilgeräten sowie Laptops und Servern eingesetzt; x86 wird häufig in PCs und Servern verwendet; RISC-V dient eingebetteten Systemen, Beschleunigern, Forschung und Lehre. Softwareverfügbarkeit, Lizenzierung und die Qualität bestimmter Chips sind bei der Plattformwahl alle wichtig.

Handgeschriebene Assemblersprache kann bei einer kleinen kritischen Routine helfen oder einen speziellen Befehl zugänglich machen, bindet Code aber an eine ISA und erhöht den Wartungsaufwand. Optimierende Compiler beherrschen Registerallokation und Codeumstrukturierung gut. Begründe anhand von Messungen, wenn du klaren Quellcode durch Assemblersprache ersetzt.