Xtensa-Befehle (ESP32-S3, ESP32)
Befehlsreferenz: i386 · x64 · ARM32 (Thumb-2) · ARM64 (AArch64) · RISC-V (RV32) · Xtensa
224 Befehle für .arch xtensa: Name, Operanden, die Bitkodierung (24 Bit, bei den kurzen Befehlen 16 Bit) und eine kurze Beschreibung mit der Wirkung als Pseudocode. Enthalten ist, was die Kerne des ESP32-S3 (Xtensa LX7) für gewöhnliche Programme ausführen: die Grundbefehle, die 16-Bit-Befehle (Code Density), die Registerfenster, die Schleifen ohne Zusatzaufwand, Multiplikation und Division, Minimum und Maximum, die booleschen Register, die Gleitkommabefehle (einfache Genauigkeit), die Spezial- und Benutzerregister und die Befehle für Ausnahmen, Interrupts und den Debugger. Der ESP32 (Xtensa LX6) hat dieselben Kodierungen; nur salt und saltu fehlen ihm (sie sind markiert). Nicht enthalten sind die Vektorbefehle des ESP32-S3 (ee.*) und MAC16.
So liest du die Tabelle
Ein Xtensa-Befehl hat 24 Bit (drei Bytes) oder 16 Bit; welches, sagen die untersten 4 Bit (op0): 0 bis 7 sind 24 Bit, 8 bis 13 die 16-Bit-Befehle mit .n im Namen. Im Speicher steht das unterste Byte zuerst. Die Kodierung zeigt die Bits von links (höchste Bit-Nummer) nach rechts: feste Bits als Ziffern, die Namen sind Felder; mit der Maus auf einem Feld steht der Bereich der Bits. Die Register stehen in drei Feldern zu 4 Bit, r (Bits 15 bis 12), s (11 bis 8) und t (7 bis 4): ar, as, at sind Adressregister a0 bis a15, fr … Gleitkommaregister f0 bis f15, br … boolesche Register b0 bis b15. Darunter stehen der Wert der festen Bits und die Maske in Hex: Ein Befehl gehört zu dieser Form, wenn (Wort & Maske) == Wert ist.
Registerfenster. Die 16 Register a0 bis a15 sind ein Fenster auf 64 Register. call8 merkt sich die Rücksprungadresse und den Wunsch, das Fenster um 8 zu drehen; der erste Befehl der Funktion, entry, dreht es und legt den Stack an. Danach sind a10 bis a15 des Aufrufers die a2 bis a7 der Funktion (die Argumente), a1 ist der Stackpointer, a0 die Rücksprungadresse, deren oberste zwei Bits die Drehung sagen. retw dreht zurück. Ohne Fenster arbeiten call0 und ret.
Konstanten. movi lädt 12 Bit mit Vorzeichen, movi.n -32 bis 95. Größere Konstanten und Adressen kommen mit l32r aus einem Literal-Pool: einem Wort mit dd, das vor dem Befehl steht (bis zu 256 KB davor, seine Adresse durch 4 teilbar). Die Verzweigungen mit einer Konstanten (beqi, bltui …) nehmen nur die 16 Werte der Tabelle b4const oder b4constu. Wie GNU as schreibt Asmonite die 16-Bit-Form, wenn die Operanden passen (add wird add.n, l32i mit kleinem Offset l32i.n …).
Jede Kodierung in dieser Tabelle ist gegen den Zerleger von Asmonite geprüft (mit zufälligen Werten für die Felder ergibt sie wieder diesen Befehl), und der Zerleger gegen GNU objdump von Espressif (über eine Million Befehlswörter, ohne Abweichung). Die Spezialregister (rsr.ps a3, wsr.epc6 a2 …) sind die des ESP32-S3; beim ESP32 sind es fast dieselben. Der Pseudocode ist wie Quelltext englisch geschrieben, auch auf der deutschen Seite; <s und <u vergleichen mit und ohne Vorzeichen, mem32[x] ist das Wort im Speicher an der Adresse x.
| Befehl | Operanden | Kodierung | Beschreibung |
|---|---|---|---|
| abs | ar, at | 01100000 ar 0001 at 00000x600100 / Maske 0xFF0F0F | Betragar = |at|Arithmetik |
| abs.s | fr, fs | 11111010 fr fs 000100000xFA0010 / Maske 0xFF00FF | Gleitkomma-Betragfr = |fs|Gleitkomma (skalar) |
| add | ar, as, at | 10000000 ar as at 00000x800000 / Maske 0xFF000F | Addition zweier Registerar = as + atArithmetik |
| add.n | ar, as, at | ar as at 10100x000A / Maske 0x000F | Addition zweier Register (16 Bit)ar = as + at16-Bit-Befehle (Code Density) |
| add.s | fr, fs, ft | 00001010 fr fs ft 00000x0A0000 / Maske 0xFF000F | Gleitkomma-Additionfr = fs + ftGleitkomma (skalar) |
| addexp.s | fr, fs | 11111010 fr fs 111000000xFA00E0 / Maske 0xFF00FF | Exponenten addieren (Schritt der Division und Wurzel)Gleitkomma (skalar) |
| addexpm.s | fr, fs | 11111010 fr fs 111100000xFA00F0 / Maske 0xFF00FF | Exponenten addieren, aus der Mantisse (Schritt der Division und Wurzel)Gleitkomma (skalar) |
| addi | at, as, imm8 | imm8 1100 as at 00100x00C002 / Maske 0x00F00F | Addition einer Konstanten (8 Bit mit Vorzeichen); mit -1 oder 1..15 wird daraus addi.n, mit 0 mov.nat = as + sext(imm8)Arithmetik |
| addi.n | ar, as, imm | ar as imm4 10110x000B / Maske 0x000F | Addition einer Konstanten -1 oder 1..15 (16 Bit; das Feld 0 ist -1)ar = as + imm16-Bit-Befehle (Code Density) |
| addmi | at, as, imm | imm8 1101 as at 00100x00D002 / Maske 0x00F00F | Addition einer Konstanten mal 256 (-32768..32512)at = as + (sext(imm8) << 8)Arithmetik |
| addx2 | ar, as, at | 10010000 ar as at 00000x900000 / Maske 0xFF000F | Addition, das erste Register mal 2 (Adresse eines Halbworts)ar = (as << 1) + atArithmetik |
| addx4 | ar, as, at | 10100000 ar as at 00000xA00000 / Maske 0xFF000F | Addition, das erste Register mal 4 (Adresse eines Worts)ar = (as << 2) + atArithmetik |
| addx8 | ar, as, at | 10110000 ar as at 00000xB00000 / Maske 0xFF000F | Addition, das erste Register mal 8ar = (as << 3) + atArithmetik |
| all4 | bt, bs | 000000001001 bs bt 00000x009000 / Maske 0xFFF00F | 1, wenn alle 4 booleschen Register 1 sindbt = bs & bs+1 & bs+2 & bs+3Boolesche Register |
| all8 | bt, bs | 000000001011 bs bt 00000x00B000 / Maske 0xFFF00F | 1, wenn alle 8 booleschen Register 1 sindbt = bs & ... & bs+7Boolesche Register |
| and | ar, as, at | 00010000 ar as at 00000x100000 / Maske 0xFF000F | UNDar = as & atLogik und Bits |
| andb | br, bs, bt | 00000010 br bs bt 00000x020000 / Maske 0xFF000F | UND boolescher Registerbr = bs & btBoolesche Register |
| andbc | br, bs, bt | 00010010 br bs bt 00000x120000 / Maske 0xFF000F | UND mit dem Gegenteil des zweitenbr = bs & ~btBoolesche Register |
| any4 | bt, bs | 000000001000 bs bt 00000x008000 / Maske 0xFFF00F | 1, wenn eins von 4 booleschen Registern 1 ist (die Gruppe ab b0, b4, b8, b12)bt = bs | bs+1 | bs+2 | bs+3Boolesche Register |
| any8 | bt, bs | 000000001010 bs bt 00000x00A000 / Maske 0xFFF00F | 1, wenn eins von 8 booleschen Registern 1 ist (ab b0 oder b8)bt = bs | ... | bs+7Boolesche Register |
| ball | as, at, label | imm8 0100 as at 01110x004007 / Maske 0x00F00F | Verzweigen, wenn alle Bits der Maske gesetzt sindif (~as & at) == 0: pc = labelSprünge und Aufrufe |
| bany | as, at, label | imm8 1000 as at 01110x008007 / Maske 0x00F00F | Verzweigen, wenn eins der Bits der Maske gesetzt istif (as & at) != 0: pc = labelSprünge und Aufrufe |
| bbc | as, at, label | imm8 0101 as at 01110x005007 / Maske 0x00F00F | Verzweigen, wenn das Bit (Nummer im Register) 0 istif as[at & 31] == 0: pc = labelSprünge und Aufrufe |
| bbci | as, bit, label | imm8 011 bit[4] as bit[3-0] 01110x006007 / Maske 0x00E00F | Verzweigen, wenn das Bit (Konstante 0..31) 0 istif as[bit] == 0: pc = labelSprünge und Aufrufe |
| bbs | as, at, label | imm8 1101 as at 01110x00D007 / Maske 0x00F00F | Verzweigen, wenn das Bit (Nummer im Register) 1 istif as[at & 31] == 1: pc = labelSprünge und Aufrufe |
| bbsi | as, bit, label | imm8 111 bit[4] as bit[3-0] 01110x00E007 / Maske 0x00E00F | Verzweigen, wenn das Bit (Konstante 0..31) 1 istif as[bit] == 1: pc = labelSprünge und Aufrufe |
| beq | as, at, label | imm8 0001 as at 01110x001007 / Maske 0x00F00F | Verzweigen, wenn gleich (-128..127 Byte weit)if as == at: pc = labelSprünge und Aufrufe |
| beqi | as, b4const, label | imm8 r as 001001100x000026 / Maske 0x0000FF | Verzweigen, wenn gleich einer Konstanten (-1, 1..8, 10, 12, 16, 32, 64, 128, 256)if as == b4const: pc = labelSprünge und Aufrufe |
| beqz | as, label | imm12 as 000101100x000016 / Maske 0x0000FF | Verzweigen, wenn 0 (bis 2 KB weit)if as == 0: pc = labelSprünge und Aufrufe |
| beqz.n | as, label | imm[3-0] as 10 imm[5-4] 11000x008C / Maske 0x00CF | Verzweigen, wenn 0, nur vorwärts 0..63 Byte (16 Bit)if as == 0: pc = label16-Bit-Befehle (Code Density) |
| bf | bs, label | imm8 0000 bs 011101100x000076 / Maske 0x00F0FF | Verzweigen, wenn das boolesche Register 0 istif not bs: pc = labelBoolesche Register |
| bge | as, at, label | imm8 1010 as at 01110x00A007 / Maske 0x00F00F | Verzweigen, wenn größer oder gleich (mit Vorzeichen)if as >=s at: pc = labelSprünge und Aufrufe |
| bgei | as, b4const, label | imm8 r as 111001100x0000E6 / Maske 0x0000FF | Verzweigen, wenn größer oder gleich einer Konstanten (mit Vorzeichen)if as >=s b4const: pc = labelSprünge und Aufrufe |
| bgeu | as, at, label | imm8 1011 as at 01110x00B007 / Maske 0x00F00F | Verzweigen, wenn größer oder gleich (ohne Vorzeichen)if as >=u at: pc = labelSprünge und Aufrufe |
| bgeui | as, b4constu, label | imm8 r as 111101100x0000F6 / Maske 0x0000FF | Verzweigen, wenn größer oder gleich einer Konstanten ohne Vorzeichenif as >=u b4constu: pc = labelSprünge und Aufrufe |
| bgez | as, label | imm12 as 110101100x0000D6 / Maske 0x0000FF | Verzweigen, wenn nicht negativif as >=s 0: pc = labelSprünge und Aufrufe |
| blt | as, at, label | imm8 0010 as at 01110x002007 / Maske 0x00F00F | Verzweigen, wenn kleiner (mit Vorzeichen)if as <s at: pc = labelSprünge und Aufrufe |
| blti | as, b4const, label | imm8 r as 101001100x0000A6 / Maske 0x0000FF | Verzweigen, wenn kleiner als eine Konstante (mit Vorzeichen)if as <s b4const: pc = labelSprünge und Aufrufe |
| bltu | as, at, label | imm8 0011 as at 01110x003007 / Maske 0x00F00F | Verzweigen, wenn kleiner (ohne Vorzeichen)if as <u at: pc = labelSprünge und Aufrufe |
| bltui | as, b4constu, label | imm8 r as 101101100x0000B6 / Maske 0x0000FF | Verzweigen, wenn kleiner als eine Konstante ohne Vorzeichen (2..8, 10, 12, 16, 32, 64, 128, 256, 32768, 65536)if as <u b4constu: pc = labelSprünge und Aufrufe |
| bltz | as, label | imm12 as 100101100x000096 / Maske 0x0000FF | Verzweigen, wenn negativif as <s 0: pc = labelSprünge und Aufrufe |
| bnall | as, at, label | imm8 1100 as at 01110x00C007 / Maske 0x00F00F | Verzweigen, wenn nicht alle Bits der Maske gesetzt sindif (~as & at) != 0: pc = labelSprünge und Aufrufe |
| bne | as, at, label | imm8 1001 as at 01110x009007 / Maske 0x00F00F | Verzweigen, wenn ungleichif as != at: pc = labelSprünge und Aufrufe |
| bnei | as, b4const, label | imm8 r as 011001100x000066 / Maske 0x0000FF | Verzweigen, wenn ungleich einer Konstantenif as != b4const: pc = labelSprünge und Aufrufe |
| bnez | as, label | imm12 as 010101100x000056 / Maske 0x0000FF | Verzweigen, wenn nicht 0if as != 0: pc = labelSprünge und Aufrufe |
| bnez.n | as, label | imm[3-0] as 11 imm[5-4] 11000x00CC / Maske 0x00CF | Verzweigen, wenn nicht 0, nur vorwärts 0..63 Byte (16 Bit)if as != 0: pc = label16-Bit-Befehle (Code Density) |
| bnone | as, at, label | imm8 0000 as at 01110x000007 / Maske 0x00F00F | Verzweigen, wenn keins der Bits der Maske gesetzt istif (as & at) == 0: pc = labelSprünge und Aufrufe |
| break | imm4, imm4 | 000000000100 imm4 00000x004000 / Maske 0xFFF00F | Haltepunkt: hält im Debugger an (Debug-Ausnahme), die Zahlen sagen dem Handler den GrundSystem und Privilegien |
| break.n | imm4 | 1111 imm4 001011010xF02D / Maske 0xF0FF | Haltepunkt (16 Bit); Asmonite setzt ihn für Haltepunkte auf 16-Bit-Befehle16-Bit-Befehle (Code Density) |
| bt | bs, label | imm8 0001 bs 011101100x001076 / Maske 0x00F0FF | Verzweigen, wenn das boolesche Register 1 istif bs: pc = labelBoolesche Register |
| call0 | label | offset 0001010x000005 / Maske 0x00003F | Aufruf ohne Registerfenster: die Rücksprungadresse in a0 (das Ziel durch 4 teilbar)a0 = pc + 3; pc = labelSprünge und Aufrufe |
| call12 | label | offset 1101010x000035 / Maske 0x00003F | Aufruf, der das Registerfenster um 12 drehta12 = return address (top bits: 3); PS.CALLINC = 3; pc = labelRegisterfenster (call4/8/12, entry, retw) |
| call4 | label | offset 0101010x000015 / Maske 0x00003F | Aufruf, der das Registerfenster um 4 dreht (wenn die Funktion entry ausführt): a4..a7 des Aufrufers sind ihre a0..a3a4 = return address (top bits: 1); PS.CALLINC = 1; pc = labelRegisterfenster (call4/8/12, entry, retw) |
| call8 | label | offset 1001010x000025 / Maske 0x00003F | Aufruf, der das Registerfenster um 8 dreht: a10..a15 des Aufrufers sind die Argumente a2..a7 der Funktiona8 = return address (top bits: 2); PS.CALLINC = 2; pc = labelRegisterfenster (call4/8/12, entry, retw) |
| callx0 | as | 000000000000 as 110000000x0000C0 / Maske 0xFFF0FF | Aufruf der Adresse im Register, ohne Registerfenstera0 = pc + 3; pc = asSprünge und Aufrufe |
| callx12 | as | 000000000000 as 111100000x0000F0 / Maske 0xFFF0FF | call12 an die Adresse im Registera12 = return address; PS.CALLINC = 3; pc = asRegisterfenster (call4/8/12, entry, retw) |
| callx4 | as | 000000000000 as 110100000x0000D0 / Maske 0xFFF0FF | call4 an die Adresse im Registera4 = return address; PS.CALLINC = 1; pc = asRegisterfenster (call4/8/12, entry, retw) |
| callx8 | as | 000000000000 as 111000000x0000E0 / Maske 0xFFF0FF | call8 an die Adresse im Registera8 = return address; PS.CALLINC = 2; pc = asRegisterfenster (call4/8/12, entry, retw) |
| ceil.s | ar, fs, imm4 | 10111010 ar fs imm4 00000xBA0000 / Maske 0xFF000F | In eine Ganzzahl wandeln, aufgerundetar = ceil(fs * 2^imm4)Gleitkomma (skalar) |
| clamps | ar, as, bits | 00110011 ar as b-7 00000x330000 / Maske 0xFF000F | Begrenzen auf den Bereich einer Zahl mit b+1 Bit (7..22) mit Vorzeichenar = min(max(as, -2^b), 2^b - 1)Arithmetik |
| const.s | fr, imm4 | 11111010 fr imm4 001100000xFA0030 / Maske 0xFF00FF | Eine Gleitkomma-Konstante laden (0, 1, 2, 0.5 ... nach imm4)fr = constant[imm4]Gleitkomma (skalar) |
| div0.s | fr, fs | 11111010 fr fs 011100000xFA0070 / Maske 0xFF00FF | Anfangswert für eine DivisionGleitkomma (skalar) |
| divn.s | fr, fs, ft | 01111010 fr fs ft 00000x7A0000 / Maske 0xFF000F | Letzter Schritt einer Division (nach div0.s, nexp01.s ...)Gleitkomma (skalar) |
| dsync | 0000000000100000001100000x002030 / Maske 0xFFFFFF | Warten, bis geschriebene Spezialregister für Speicherzugriffe geltenSchranken und Sonstiges | |
| entry | as, framesize | imm12 as 001101100x000036 / Maske 0x0000FF | Der erste Befehl einer Funktion mit Registerfenster: dreht das Fenster um PS.CALLINC * 4 und legt den Stack an (framesize 0..32760, durch 8 teilbar; die Adresse durch 4 teilbar)WINDOWBASE += PS.CALLINC; as = as(old window) - framesizeRegisterfenster (call4/8/12, entry, retw) |
| esync | 0000000000100000001000000x002020 / Maske 0xFFFFFF | Warten, bis geschriebene Spezialregister für die Ausführung geltenSchranken und Sonstiges | |
| excw | 0000000000100000100000000x002080 / Maske 0xFFFFFF | Warten, bis die Ausnahmen der vorigen Befehle ausgelöst sindSchranken und Sonstiges | |
| extui | ar, at, shift, width | w-1 010 sh[4] ar sh[3-0] at 00000x040000 / Maske 0x0E000F | Ein Bitfeld ohne Vorzeichen holen: width Bit ab Bit shift (shift + width bis 32)ar = (at >> shift) & ((1 << width) - 1)Schieben und Rotieren |
| extw | 0000000000100000110100000x0020D0 / Maske 0xFFFFFF | Warten, bis alle früheren Zugriffe außen angekommen sindSchranken und Sonstiges | |
| float.s | fr, as, imm4 | 11001010 fr as imm4 00000xCA0000 / Maske 0xFF000F | Ganzzahl mit Vorzeichen in Gleitkomma wandeln, geteilt durch 2^imm4fr = float(as) / 2^imm4Gleitkomma (skalar) |
| floor.s | ar, fs, imm4 | 10101010 ar fs imm4 00000xAA0000 / Maske 0xFF000F | In eine Ganzzahl wandeln, abgerundetar = floor(fs * 2^imm4)Gleitkomma (skalar) |
| idtlb | as | 010100001100 as 000000000x50C000 / Maske 0xFFF0FF | Eintrag des Daten-TLB ungültig macheninvalidate DTLB[as]System und Privilegien |
| iitlb | as | 010100000100 as 000000000x504000 / Maske 0xFFF0FF | Eintrag des Befehls-TLB ungültig macheninvalidate ITLB[as]System und Privilegien |
| ill | 0000000000000000000000000x000000 / Maske 0xFFFFFF | Ungültiger Befehl: löst eine Ausnahme ausSystem und Privilegien | |
| ill.n | 11110000011011010xF06D / Maske 0xFFFF | Ungültiger Befehl (16 Bit)16-Bit-Befehle (Code Density) | |
| isync | 0000000000100000000000000x002000 / Maske 0xFFFFFF | Befehle neu holen (nach geändertem Code oder geänderten Spezialregistern)Schranken und Sonstiges | |
| j | label | offset 0001100x000006 / Maske 0x00003F | Sprung (bis 128 KB weit)pc = labelSprünge und Aufrufe |
| jx | as | 000000000000 as 101000000x0000A0 / Maske 0xFFF0FF | Sprung an die Adresse im Registerpc = asSprünge und Aufrufe |
| l16si | at, as, offset | imm8 1001 as at 00100x009002 / Maske 0x00F00F | Laden eines Halbworts mit Vorzeichenat = sext(mem16[as + (imm8 << 1)])Laden und Speichern |
| l16ui | at, as, offset | imm8 0001 as at 00100x001002 / Maske 0x00F00F | Laden eines Halbworts ohne Vorzeichen (Offset 0..510, gerade)at = zext(mem16[as + (imm8 << 1)])Laden und Speichern |
| l32ai | at, as, offset | imm8 1011 as at 00100x00B002 / Maske 0x00F00F | Laden eines Worts mit Acquire-Ordnung (spätere Zugriffe erst danach)at = mem32[as + (imm8 << 2)]; acquireLaden und Speichern |
| l32e | at, as, offset | 00001001 imm4 as at 00000x090000 / Maske 0xFF000F | Laden für die Handler der Fensterausnahmen (Offset -64..-4)at = mem32[as + ((imm4 << 2) - 64)]Registerfenster (call4/8/12, entry, retw) |
| l32i | at, as, offset | imm8 0010 as at 00100x002002 / Maske 0x00F00F | Laden eines Worts (Offset 0..1020, durch 4 teilbar); mit kleinem Offset wird daraus l32i.nat = mem32[as + (imm8 << 2)]Laden und Speichern |
| l32i.n | at, as, offset | imm4 as at 10000x0008 / Maske 0x000F | Laden eines Worts, Offset 0..60 (16 Bit)at = mem32[as + (imm4 << 2)]16-Bit-Befehle (Code Density) |
| l32r | at, label | imm16 at 00010x000001 / Maske 0x00000F | Laden eines Worts aus dem Literal-Pool: einer Konstanten, die bis zu 256 KB vor dem Befehl steht (die Adresse durch 4 teilbar); so kommen 32-Bit-Konstanten in ein Registerat = mem32[((pc + 3) & ~3) + (0xFFFF0000 | imm16) * 4]Laden und Speichern |
| l8ui | at, as, imm8 | imm8 0000 as at 00100x000002 / Maske 0x00F00F | Laden eines Bytes ohne Vorzeichenat = zext(mem8[as + imm8])Laden und Speichern |
| lddr32.p | as | 000000000111 as 111000000x0070E0 / Maske 0xFFF0FF | Debug-Modus: ein Wort nach DDR laden und die Adresse um 4 erhöhen (schnelles Lesen des Speichers durch den Debugger)DDR = mem32[as]; as += 4System und Privilegien |
| loop | as, label | imm8 1000 as 011101100x008076 / Maske 0x00F0FF | Schleife ohne Zusatzaufwand: der Teil bis label läuft as-mal (as = 0: 2^32-mal); LBEG, LEND, LCOUNTLCOUNT = as - 1; LBEG = pc + 3; LEND = labelSchleifen ohne Zusatzaufwand (loop) |
| loopgtz | as, label | imm8 1010 as 011101100x00A076 / Maske 0x00F0FF | Schleife wie loop, übersprungen, wenn as nicht größer als 0 istif as <=s 0: pc = label else loopSchleifen ohne Zusatzaufwand (loop) |
| loopnez | as, label | imm8 1001 as 011101100x009076 / Maske 0x00F0FF | Schleife wie loop, bei as = 0 übersprungenif as == 0: pc = label else loopSchleifen ohne Zusatzaufwand (loop) |
| lsi | ft, as, offset | imm8 0000 as ft 00110x000003 / Maske 0x00F00F | Gleitkommazahl ladenft = mem32[as + (imm8 << 2)]Gleitkomma (skalar) |
| lsip | ft, as, offset | imm8 1000 as ft 00110x008003 / Maske 0x00F00F | Gleitkommazahl laden, dann die Adresse erhöhenft = mem32[as]; as += imm8 << 2Gleitkomma (skalar) |
| lsx | fr, as, at | 00001000 fr as at 00000x080000 / Maske 0xFF000F | Gleitkommazahl laden, Adresse aus zwei Registernfr = mem32[as + at]Gleitkomma (skalar) |
| lsxp | fr, as, at | 00011000 fr as at 00000x180000 / Maske 0xFF000F | Gleitkommazahl laden, dann die Adresse erhöhenfr = mem32[as]; as += atGleitkomma (skalar) |
| madd.s | fr, fs, ft | 01001010 fr fs ft 00000x4A0000 / Maske 0xFF000F | Multiplizieren und addierenfr = fr + fs * ftGleitkomma (skalar) |
| maddn.s | fr, fs, ft | 01101010 fr fs ft 00000x6A0000 / Maske 0xFF000F | Multiplizieren und addieren, gerundet zur nächsten Zahl (ein Schritt der Division und Wurzel)fr = round(fr + fs * ft)Gleitkomma (skalar) |
| max | ar, as, at | 01010011 ar as at 00000x530000 / Maske 0xFF000F | Maximum mit Vorzeichenar = (as >s at) ? as : atVergleichen und Tauschen |
| maxu | ar, as, at | 01110011 ar as at 00000x730000 / Maske 0xFF000F | Maximum ohne Vorzeichenar = (as >u at) ? as : atVergleichen und Tauschen |
| memw | 0000000000100000110000000x0020C0 / Maske 0xFFFFFF | Speicherschranke: frühere Zugriffe vor späteren (für Peripherieregister)Schranken und Sonstiges | |
| min | ar, as, at | 01000011 ar as at 00000x430000 / Maske 0xFF000F | Minimum mit Vorzeichenar = (as <s at) ? as : atVergleichen und Tauschen |
| minu | ar, as, at | 01100011 ar as at 00000x630000 / Maske 0xFF000F | Minimum ohne Vorzeichenar = (as <u at) ? as : atVergleichen und Tauschen |
| mkdadj.s | fr, fs | 11111010 fr fs 110100000xFA00D0 / Maske 0xFF00FF | Exponentenkorrektur für die Division bildenGleitkomma (skalar) |
| mksadj.s | fr, fs | 11111010 fr fs 110000000xFA00C0 / Maske 0xFF00FF | Exponentenkorrektur für die Quadratwurzel bildenGleitkomma (skalar) |
| mov.n | at, as | 0000 as at 11010x000D / Maske 0xF00F | Kopieren eines Registers (16 Bit)at = as16-Bit-Befehle (Code Density) |
| mov.s | fr, fs | 11111010 fr fs 000000000xFA0000 / Maske 0xFF00FF | Gleitkommaregister kopierenfr = fsGleitkomma (skalar) |
| moveqz | ar, as, at | 10000011 ar as at 00000x830000 / Maske 0xFF000F | Kopieren, wenn das dritte Register 0 istif at == 0: ar = asBedingte Auswahl |
| moveqz.s | fr, fs, at | 10001011 fr fs at 00000x8B0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn at 0 istif at == 0: fr = fsGleitkomma (skalar) |
| movf | ar, as, bt | 11000011 ar as bt 00000xC30000 / Maske 0xFF000F | Kopieren, wenn das boolesche Register 0 istif not bt: ar = asBedingte Auswahl |
| movf.s | fr, fs, bt | 11001011 fr fs bt 00000xCB0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn das boolesche Register 0 istif not bt: fr = fsGleitkomma (skalar) |
| movgez | ar, as, at | 10110011 ar as at 00000xB30000 / Maske 0xFF000F | Kopieren, wenn das dritte Register nicht negativ istif at >=s 0: ar = asBedingte Auswahl |
| movgez.s | fr, fs, at | 10111011 fr fs at 00000xBB0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn at nicht negativ istif at >=s 0: fr = fsGleitkomma (skalar) |
| movi | at, imm12 | imm[7-0] 1010 imm[11-8] at 00100x00A002 / Maske 0x00F00F | Laden einer Konstanten (12 Bit mit Vorzeichen, -2048..2047); größere kommen mit l32rat = sext(imm12)Konstanten und Adressen laden |
| movi.n | as, imm7 | imm[3-0] as 0 imm[6-4] 11000x000C / Maske 0x008F | Laden einer Konstanten -32..95 (16 Bit)as = imm716-Bit-Befehle (Code Density) |
| movltz | ar, as, at | 10100011 ar as at 00000xA30000 / Maske 0xFF000F | Kopieren, wenn das dritte Register negativ istif at <s 0: ar = asBedingte Auswahl |
| movltz.s | fr, fs, at | 10101011 fr fs at 00000xAB0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn at negativ istif at <s 0: fr = fsGleitkomma (skalar) |
| movnez | ar, as, at | 10010011 ar as at 00000x930000 / Maske 0xFF000F | Kopieren, wenn das dritte Register nicht 0 istif at != 0: ar = asBedingte Auswahl |
| movnez.s | fr, fs, at | 10011011 fr fs at 00000x9B0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn at nicht 0 istif at != 0: fr = fsGleitkomma (skalar) |
| movsp | at, as | 000000000001 as at 00000x001000 / Maske 0xFFF00F | Den Stackpointer setzen, so dass Registerfenster der Aufrufer zuerst gespeichert werdenat = as (after spilling the windows when needed)Registerfenster (call4/8/12, entry, retw) |
| movt | ar, as, bt | 11010011 ar as bt 00000xD30000 / Maske 0xFF000F | Kopieren, wenn das boolesche Register 1 istif bt: ar = asBedingte Auswahl |
| movt.s | fr, fs, bt | 11011011 fr fs bt 00000xDB0000 / Maske 0xFF000F | Gleitkommaregister kopieren, wenn das boolesche Register 1 istif bt: fr = fsGleitkomma (skalar) |
| msub.s | fr, fs, ft | 01011010 fr fs ft 00000x5A0000 / Maske 0xFF000F | Multiplizieren und subtrahierenfr = fr - fs * ftGleitkomma (skalar) |
| mul.s | fr, fs, ft | 00101010 fr fs ft 00000x2A0000 / Maske 0xFF000F | Gleitkomma-Multiplikationfr = fs * ftGleitkomma (skalar) |
| mul16s | ar, as, at | 11010001 ar as at 00000xD10000 / Maske 0xFF000F | Multiplikation der unteren 16 Bit mit Vorzeichenar = sext(as[15:0]) * sext(at[15:0])Arithmetik |
| mul16u | ar, as, at | 11000001 ar as at 00000xC10000 / Maske 0xFF000F | Multiplikation der unteren 16 Bit ohne Vorzeichenar = zext(as[15:0]) * zext(at[15:0])Arithmetik |
| mull | ar, as, at | 10000010 ar as at 00000x820000 / Maske 0xFF000F | Multiplikation, die unteren 32 Bitar = (as * at)[31:0]Arithmetik |
| mulsh | ar, as, at | 10110010 ar as at 00000xB20000 / Maske 0xFF000F | Multiplikation mit Vorzeichen, die oberen 32 Bitar = (as *s at)[63:32]Arithmetik |
| muluh | ar, as, at | 10100010 ar as at 00000xA20000 / Maske 0xFF000F | Multiplikation ohne Vorzeichen, die oberen 32 Bitar = (as *u at)[63:32]Arithmetik |
| neg | ar, at | 01100000 ar 0000 at 00000x600000 / Maske 0xFF0F0F | Negationar = -atArithmetik |
| neg.s | fr, fs | 11111010 fr fs 011000000xFA0060 / Maske 0xFF00FF | Gleitkomma-Negationfr = -fsGleitkomma (skalar) |
| nexp01.s | fr, fs | 11111010 fr fs 101100000xFA00B0 / Maske 0xFF00FF | Mantisse auf 1..2 bringen und Exponent negieren (Schritt der Division und Wurzel)Gleitkomma (skalar) |
| nop | 0000000000100000111100000x0020F0 / Maske 0xFFFFFF | Keine Wirkung; wird als nop.n geschriebenSchranken und Sonstiges | |
| nop.n | 11110000001111010xF03D / Maske 0xFFFF | Keine Wirkung (16 Bit)16-Bit-Befehle (Code Density) | |
| nsa | at, as | 010000001110 as at 00000x40E000 / Maske 0xFFF00F | Anzahl der Vorzeichenbits minus 1 (Normalisieren mit Vorzeichen)at = count of the leading bits equal to as[31], less 1Logik und Bits |
| nsau | at, as | 010000001111 as at 00000x40F000 / Maske 0xFFF00F | Anzahl der führenden Nullbits (32 bei 0)at = clz(as)Logik und Bits |
| oeq.s | br, fs, ft | 00101011 br fs ft 00000x2B0000 / Maske 0xFF000F | Vergleich: 1, wenn gleich (ohne NaN)br = fs == ftGleitkomma (skalar) |
| ole.s | br, fs, ft | 01101011 br fs ft 00000x6B0000 / Maske 0xFF000F | Vergleich: 1, wenn kleiner oder gleich (ohne NaN)br = fs <= ftGleitkomma (skalar) |
| olt.s | br, fs, ft | 01001011 br fs ft 00000x4B0000 / Maske 0xFF000F | Vergleich: 1, wenn kleiner (ohne NaN)br = fs < ftGleitkomma (skalar) |
| or | ar, as, atauch: mov | 00100000 ar as at 00000x200000 / Maske 0xFF000F | ODER; mit zwei gleichen Quellen das Kopieren eines Registers (mov, als mov.n)ar = as | atLogik und Bits |
| orb | br, bs, bt | 00100010 br bs bt 00000x220000 / Maske 0xFF000F | ODER boolescher Registerbr = bs | btBoolesche Register |
| orbc | br, bs, bt | 00110010 br bs bt 00000x320000 / Maske 0xFF000F | ODER mit dem Gegenteil des zweitenbr = bs | ~btBoolesche Register |
| pdtlb | at, as | 010100001101 as at 00000x50D000 / Maske 0xFFF00F | Daten-TLB für eine Adresse befragenat = probe DTLB(as)System und Privilegien |
| pitlb | at, as | 010100000101 as at 00000x505000 / Maske 0xFFF00F | Befehls-TLB für eine Adresse befragenat = probe ITLB(as)System und Privilegien |
| quos | ar, as, at | 11010010 ar as at 00000xD20000 / Maske 0xFF000F | Division mit Vorzeichenar = as /s atArithmetik |
| quou | ar, as, at | 11000010 ar as at 00000xC20000 / Maske 0xFF000F | Division ohne Vorzeichen (bei 0: Ausnahme)ar = as /u atArithmetik |
| rdtlb0 | at, as | 010100001011 as at 00000x50B000 / Maske 0xFFF00F | Eintrag des Daten-TLB lesen (virtuelle Adresse)at = DTLB[as].vaddrSystem und Privilegien |
| rdtlb1 | at, as | 010100001111 as at 00000x50F000 / Maske 0xFFF00F | Eintrag des Daten-TLB lesen (Übersetzung)at = DTLB[as].paddrSystem und Privilegien |
| recip0.s | fr, fs | 11111010 fr fs 100000000xFA0080 / Maske 0xFF00FF | Anfangswert für einen KehrwertGleitkomma (skalar) |
| rems | ar, as, at | 11110010 ar as at 00000xF20000 / Maske 0xFF000F | Rest der Division mit Vorzeichenar = as %s atArithmetik |
| remu | ar, as, at | 11100010 ar as at 00000xE20000 / Maske 0xFF000F | Rest der Division ohne Vorzeichenar = as %u atArithmetik |
| rer | at, as | 010000000110 as at 00000x406000 / Maske 0xFFF00F | Externes Register lesenat = ER[as]System und Privilegien |
| ret | 000000000000 s 100000000x000080 / Maske 0xFFF0FF | Rücksprung nach call0 (an a0); wird als ret.n geschriebenpc = a0Sprünge und Aufrufe | |
| ret.n | 1111 s 000011010xF00D / Maske 0xF0FF | Rücksprung nach call0 (16 Bit)pc = a016-Bit-Befehle (Code Density) | |
| retw | 000000000000 s 100100000x000090 / Maske 0xFFF0FF | Rücksprung aus einer Funktion mit Registerfenster: dreht das Fenster zurück; wird als retw.n geschriebenpc = a0 (top bits from pc); WINDOWBASE -= a0[31:30]Registerfenster (call4/8/12, entry, retw) | |
| retw.n | 1111 s 000111010xF01D / Maske 0xF0FF | Rücksprung mit Registerfenster (16 Bit)pc = a0; WINDOWBASE -= a0[31:30]16-Bit-Befehle (Code Density) | |
| rfdd | 111100011110 s 000100000xF1E010 / Maske 0xFFF0FF | Rückkehr aus einer Debug-Ausnahme im Debug-ModusSystem und Privilegien | |
| rfde | 0000000000110010000000000x003200 / Maske 0xFFFFFF | Rückkehr aus einer doppelten Ausnahmepc = DEPCSystem und Privilegien | |
| rfdo | imm4 | 111100011110 imm4 000000000xF1E000 / Maske 0xFFF0FF | Rückkehr aus dem Debug-Modus (OCD: der Debugger lässt den Kern weiterlaufen)pc = EPC6; PS = EPS6System und Privilegien |
| rfe | 0000000000110000000000000x003000 / Maske 0xFFFFFF | Rückkehr aus einer Ausnahme der Ebene 1pc = EPC1; PS.EXCM = 0System und Privilegien | |
| rfi | imm4 | 000000000011 imm4 000100000x003010 / Maske 0xFFF0FF | Rückkehr aus einem Interrupt der Ebene imm4pc = EPC[imm4]; PS = EPS[imm4]System und Privilegien |
| rfr | ar, fs | 11111010 ar fs 010000000xFA0040 / Maske 0xFF00FF | Gleitkommaregister in ein Adressregister kopieren (die Bits)ar = bits(fs)Gleitkomma (skalar) |
| rfwo | 0000000000110100000000000x003400 / Maske 0xFFFFFF | Rückkehr aus dem Handler eines FensterüberlaufsRegisterfenster (call4/8/12, entry, retw) | |
| rfwu | 0000000000110101000000000x003500 / Maske 0xFFFFFF | Rückkehr aus dem Handler eines FensterunterlaufsRegisterfenster (call4/8/12, entry, retw) | |
| ritlb0 | at, as | 010100000011 as at 00000x503000 / Maske 0xFFF00F | Eintrag des Befehls-TLB lesen (virtuelle Adresse)at = ITLB[as].vaddrSystem und Privilegien |
| ritlb1 | at, as | 010100000111 as at 00000x507000 / Maske 0xFFF00F | Eintrag des Befehls-TLB lesen (Übersetzung)at = ITLB[as].paddrSystem und Privilegien |
| rotw | imm4 | 0100000010000000 imm4 00000x408000 / Maske 0xFFFF0F | Das Registerfenster drehen (in den Handlern der Fensterausnahmen)WINDOWBASE += imm4Registerfenster (call4/8/12, entry, retw) |
| round.s | ar, fs, imm4 | 10001010 ar fs imm4 00000x8A0000 / Maske 0xFF000F | In eine Ganzzahl wandeln, gerundet (mal 2^imm4)ar = round(fs * 2^imm4)Gleitkomma (skalar) |
| rsil | at, imm4 | 000000000110 imm4 at 00000x006000 / Maske 0xFFF00F | PS lesen und die Interrupt-Ebene setzen (Interrupts bis imm4 aus)at = PS; PS.INTLEVEL = imm4System und Privilegien |
| rsqrt0.s | fr, fs | 11111010 fr fs 101000000xFA00A0 / Maske 0xFF00FF | Anfangswert für den Kehrwert einer QuadratwurzelGleitkomma (skalar) |
| rsr | sr, at | 00000011 sr at 00000x030000 / Maske 0xFF000F | Spezialregister lesen; auch rsr.name at geschrieben (rsr.ps a3)at = SR[sr]Spezial- und Benutzerregister |
| rsync | 0000000000100000000100000x002010 / Maske 0xFFFFFF | Warten, bis geschriebene Spezialregister für das Lesen von Registern geltenSchranken und Sonstiges | |
| rur | ar, ur | 11100011 ar ur 00000xE30000 / Maske 0xFF000F | Benutzerregister lesen (threadptr, fcr, fsr ...); auch rur.name arar = UR[ur]Spezial- und Benutzerregister |
| s16i | at, as, offset | imm8 0101 as at 00100x005002 / Maske 0x00F00F | Speichern eines Halbwortsmem16[as + (imm8 << 1)] = at[15:0]Laden und Speichern |
| s32c1i | at, as, offset | imm8 1110 as at 00100x00E002 / Maske 0x00F00F | Bedingtes Speichern (Compare and Swap): speichert at, wenn das Wort gleich SCOMPARE1 ist; at bekommt den alten Wertold = mem32[a]; if old == SCOMPARE1: mem32[a] = at; at = oldLaden und Speichern |
| s32e | at, as, offset | 01001001 imm4 as at 00000x490000 / Maske 0xFF000F | Speichern für die Handler der Fensterausnahmen (Offset -64..-4)mem32[as + ((imm4 << 2) - 64)] = atRegisterfenster (call4/8/12, entry, retw) |
| s32i | at, as, offset | imm8 0110 as at 00100x006002 / Maske 0x00F00F | Speichern eines Worts; mit kleinem Offset wird daraus s32i.nmem32[as + (imm8 << 2)] = atLaden und Speichern |
| s32i.n | at, as, offset | imm4 as at 10010x0009 / Maske 0x000F | Speichern eines Worts, Offset 0..60 (16 Bit)mem32[as + (imm4 << 2)] = at16-Bit-Befehle (Code Density) |
| s32nb | at, as, offset | 01011001 imm4 as at 00000x590000 / Maske 0xFF000F | Speichern eines Worts am Schreibpuffer vorbei (Offset 0..60)mem32[as + (imm4 << 2)] = atLaden und Speichern |
| s32ri | at, as, offset | imm8 1111 as at 00100x00F002 / Maske 0x00F00F | Speichern eines Worts mit Release-Ordnung (frühere Zugriffe zuerst)release; mem32[as + (imm8 << 2)] = atLaden und Speichern |
| s8i | at, as, imm8 | imm8 0100 as at 00100x004002 / Maske 0x00F00F | Speichern eines Bytesmem8[as + imm8] = at[7:0]Laden und Speichern |
| salt | ar, as, at | 01110010 ar as at 00000x720000 / Maske 0xFF000F | Vergleich mit Vorzeichen: 1, wenn kleiner (nur ESP32-S3, nicht ESP32)ar = (as <s at) ? 1 : 0Vergleichen und Tauschen |
| saltu | ar, as, at | 01100010 ar as at 00000x620000 / Maske 0xFF000F | Vergleich ohne Vorzeichen: 1, wenn kleiner (nur ESP32-S3, nicht ESP32)ar = (as <u at) ? 1 : 0Vergleichen und Tauschen |
| sddr32.p | as | 000000000111 as 111100000x0070F0 / Maske 0xFFF0FF | Debug-Modus: DDR speichern und die Adresse um 4 erhöhenmem32[as] = DDR; as += 4System und Privilegien |
| sext | ar, as, bits | 00100011 ar as b-7 00000x230000 / Maske 0xFF000F | Vorzeichen erweitern ab Bit b (7..22)ar = sext(as[b:0])Arithmetik |
| simcall | 0000000001010001000000000x005100 / Maske 0xFFFFFF | Aufruf eines Simulators (auf dem Chip ohne Wirkung)System und Privilegien | |
| sll | ar, as | 10100001 ar as 000000000xA10000 / Maske 0xFF00FF | Schieben nach links um 32 minus SAR (SAR mit ssl gesetzt)ar = as << (32 - SAR)Schieben und Rotieren |
| slli | ar, as, sa | 000 sa[4] 0001 ar as sa[3-0] 00000x010000 / Maske 0xEF000F | Schieben nach links um eine Konstante (1..31; die Felder halten 32 minus sa)ar = as << saSchieben und Rotieren |
| sqrt0.s | fr, fs | 11111010 fr fs 100100000xFA0090 / Maske 0xFF00FF | Anfangswert für eine QuadratwurzelGleitkomma (skalar) |
| sra | ar, at | 10110001 ar 0000 at 00000xB10000 / Maske 0xFF0F0F | Schieben nach rechts mit Vorzeichen um SARar = at >>s SARSchieben und Rotieren |
| srai | ar, at, sa | 001 sa[4] 0001 ar sa[3-0] at 00000x210000 / Maske 0xEF000F | Schieben nach rechts mit Vorzeichen um eine Konstante (0..31)ar = at >>s saSchieben und Rotieren |
| src | ar, as, at | 10000001 ar as at 00000x810000 / Maske 0xFF000F | Schieben nach rechts über zwei Register (64 Bit) um SAR; mit zweimal demselben Register ein Rotierenar = ((as : at) >> SAR)[31:0]Schieben und Rotieren |
| srl | ar, at | 10010001 ar 0000 at 00000x910000 / Maske 0xFF0F0F | Schieben nach rechts ohne Vorzeichen um SARar = at >>u SARSchieben und Rotieren |
| srli | ar, at, imm4 | 01000001 ar imm4 at 00000x410000 / Maske 0xFF000F | Schieben nach rechts ohne Vorzeichen um eine Konstante (0..15; mehr mit extui)ar = at >>u imm4Schieben und Rotieren |
| ssa8b | as | 010000000011 as 000000000x403000 / Maske 0xFFF0FF | SAR für das Schieben um ganze Bytes (big endian) setzenSAR = 32 - as[1:0] * 8Schieben und Rotieren |
| ssa8l | as | 010000000010 as 000000000x402000 / Maske 0xFFF0FF | SAR für das Schieben um ganze Bytes (little endian) setzenSAR = as[1:0] * 8Schieben und Rotieren |
| ssai | sa | 010000000100 sa[3-0] 000 sa[4] 00000x404000 / Maske 0xFFF0EF | SAR auf eine Konstante setzenSAR = saSchieben und Rotieren |
| ssi | ft, as, offset | imm8 0100 as ft 00110x004003 / Maske 0x00F00F | Gleitkommazahl speichernmem32[as + (imm8 << 2)] = ftGleitkomma (skalar) |
| ssip | ft, as, offset | imm8 1100 as ft 00110x00C003 / Maske 0x00F00F | Gleitkommazahl speichern, dann die Adresse erhöhenmem32[as] = ft; as += imm8 << 2Gleitkomma (skalar) |
| ssl | as | 010000000001 as 000000000x401000 / Maske 0xFFF0FF | SAR für das Schieben nach links setzenSAR = 32 - as[4:0]Schieben und Rotieren |
| ssr | as | 010000000000 as 000000000x400000 / Maske 0xFFF0FF | SAR für das Schieben nach rechts setzen (aus den unteren 5 Bit)SAR = as[4:0]Schieben und Rotieren |
| ssx | fr, as, at | 01001000 fr as at 00000x480000 / Maske 0xFF000F | Gleitkommazahl speichern, Adresse aus zwei Registernmem32[as + at] = frGleitkomma (skalar) |
| ssxp | fr, as, at | 01011000 fr as at 00000x580000 / Maske 0xFF000F | Gleitkommazahl speichern, dann die Adresse erhöhenmem32[as] = fr; as += atGleitkomma (skalar) |
| sub | ar, as, at | 11000000 ar as at 00000xC00000 / Maske 0xFF000F | Subtraktion zweier Registerar = as - atArithmetik |
| sub.s | fr, fs, ft | 00011010 fr fs ft 00000x1A0000 / Maske 0xFF000F | Gleitkomma-Subtraktionfr = fs - ftGleitkomma (skalar) |
| subx2 | ar, as, at | 11010000 ar as at 00000xD00000 / Maske 0xFF000F | Subtraktion, das erste Register mal 2ar = (as << 1) - atArithmetik |
| subx4 | ar, as, at | 11100000 ar as at 00000xE00000 / Maske 0xFF000F | Subtraktion, das erste Register mal 4ar = (as << 2) - atArithmetik |
| subx8 | ar, as, at | 11110000 ar as at 00000xF00000 / Maske 0xFF000F | Subtraktion, das erste Register mal 8ar = (as << 3) - atArithmetik |
| syscall | 0000000001010000000000000x005000 / Maske 0xFFFFFF | Systemaufruf: löst die Ausnahme SYSCALL ausSystem und Privilegien | |
| trunc.s | ar, fs, imm4 | 10011010 ar fs imm4 00000x9A0000 / Maske 0xFF000F | In eine Ganzzahl wandeln, abgeschnittenar = trunc(fs * 2^imm4)Gleitkomma (skalar) |
| ueq.s | br, fs, ft | 00111011 br fs ft 00000x3B0000 / Maske 0xFF000F | Vergleich: 1, wenn gleich oder NaNbr = fs == ft or unorderedGleitkomma (skalar) |
| ufloat.s | fr, as, imm4 | 11011010 fr as imm4 00000xDA0000 / Maske 0xFF000F | Ganzzahl ohne Vorzeichen in Gleitkomma wandeln, geteilt durch 2^imm4fr = ufloat(as) / 2^imm4Gleitkomma (skalar) |
| ule.s | br, fs, ft | 01111011 br fs ft 00000x7B0000 / Maske 0xFF000F | Vergleich: 1, wenn kleiner oder gleich oder NaNbr = fs <= ft or unorderedGleitkomma (skalar) |
| ult.s | br, fs, ft | 01011011 br fs ft 00000x5B0000 / Maske 0xFF000F | Vergleich: 1, wenn kleiner oder NaNbr = fs < ft or unorderedGleitkomma (skalar) |
| un.s | br, fs, ft | 00011011 br fs ft 00000x1B0000 / Maske 0xFF000F | Vergleich: 1, wenn eine der Zahlen NaN istbr = isnan(fs) or isnan(ft)Gleitkomma (skalar) |
| utrunc.s | ar, fs, imm4 | 11101010 ar fs imm4 00000xEA0000 / Maske 0xFF000F | In eine Ganzzahl ohne Vorzeichen wandeln, abgeschnittenar = utrunc(fs * 2^imm4)Gleitkomma (skalar) |
| waiti | imm4 | 000000000111 imm4 000000000x007000 / Maske 0xFFF0FF | Interrupt-Ebene setzen und auf einen Interrupt warten (Strom sparen)PS.INTLEVEL = imm4; waitSystem und Privilegien |
| wdtlb | at, as | 010100001110 as at 00000x50E000 / Maske 0xFFF00F | Eintrag des Daten-TLB schreibenDTLB[as] = atSystem und Privilegien |
| wer | at, as | 010000000111 as at 00000x407000 / Maske 0xFFF00F | Externes Register schreibenER[as] = atSystem und Privilegien |
| wfr | fr, as | 11111010 fr as 010100000xFA0050 / Maske 0xFF00FF | Adressregister in ein Gleitkommaregister kopieren (die Bits)fr = bits(as)Gleitkomma (skalar) |
| witlb | at, as | 010100000110 as at 00000x506000 / Maske 0xFFF00F | Eintrag des Befehls-TLB schreibenITLB[as] = atSystem und Privilegien |
| wsr | sr, at | 00010011 sr at 00000x130000 / Maske 0xFF000F | Spezialregister schreiben; auch wsr.name atSR[sr] = atSpezial- und Benutzerregister |
| wur | ur, at | 11110011 ur at 00000xF30000 / Maske 0xFF000F | Benutzerregister schreiben; auch wur.name atUR[ur] = atSpezial- und Benutzerregister |
| xor | ar, as, at | 00110000 ar as at 00000x300000 / Maske 0xFF000F | Exklusives ODERar = as ^ atLogik und Bits |
| xorb | br, bs, bt | 01000010 br bs bt 00000x420000 / Maske 0xFF000F | Exklusives ODER boolescher Registerbr = bs ^ btBoolesche Register |
| xsr | sr, at | 01100001 sr at 00000x610000 / Maske 0xFF000F | Spezialregister und Register tauschen; auch xsr.name att = SR[sr]; SR[sr] = at; at = tSpezial- und Benutzerregister |