RISC-V-Befehle (RV32)

Befehlsreferenz: i386 · x64 · ARM32 (Thumb-2) · ARM64 (AArch64) · RISC-V (RV32)

143 Befehle für .arch riscv32: Name, Operanden, die Bitkodierung (32 Bit, bei den komprimierten Befehlen 16 Bit) und eine kurze Beschreibung mit der Wirkung als Pseudocode. Enthalten ist alles, was die RISC-V-Kerne des Raspberry Pi Pico 2 (Hazard3) ausführen: der Grundbefehlssatz RV32I, Multiplikation und Division (M), die atomaren Befehle (A), die Steuerregister (Zicsr), fence.i (Zifencei), die Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb) und die komprimierten Befehle (C, Zcb). Die Pseudobefehle des Assemblers (li, mv, j, ret …) stehen beim Befehl, zu dem sie werden. Gleitkomma gibt es auf dem Hazard3 nicht.

So liest du die Tabelle

Ein RISC-V-Befehl ist ein Wort mit 32 Bit; die beiden untersten Bits sind dann 11. Ein komprimierter Befehl (Name mit c.) hat 16 Bit und endet auf 00, 01 oder 10. Die Kodierung zeigt die Bits von links (höchste Bit-Nummer) nach rechts: feste Bits als Ziffern (Opcode, funct3, funct7), die Namen sind Felder. Mit der Maus auf einem Feld steht der Bereich der Bits. rd, rs1, rs2 sind Register mit 5 Bit (x0 bis x31); rd', rs1', rs2' in den komprimierten Befehlen haben 3 Bit und meinen x8 bis x15. Darunter steht der Wert der festen Bits und die Maske in Hex: Ein Befehl gehört zu dieser Form, wenn (Wort & Maske) == Wert ist.

Konstanten sind in RISC-V auf mehrere Felder verteilt, damit das Vorzeichen immer in Bit 31 steht und die Register an festen Stellen bleiben. imm[12|10-5] ist ein Feld, das die Bits 12 und 10 bis 5 der Zahl enthält, in dieser Reihenfolge. Bei Sprüngen und Verzweigungen ist Bit 0 der Entfernung immer 0 und wird nicht gespeichert. Flags gibt es nicht: Verzweigungen vergleichen zwei Register selbst, slt schreibt das Ergebnis eines Vergleichs als 0 oder 1 in ein Register.

Die atomaren Befehle haben die Bits aq und rl für die Reihenfolge der Speicherzugriffe; der Disassembler schreibt sie als Anhang an den Namen (amoadd.w.aq, .rl, .aqrl). 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 (oder seinen Pseudonamen). Der Pseudocode ist wie Quelltext englisch geschrieben, auch auf der deutschen Seite; <s und <u vergleichen mit und ohne Vorzeichen, [x]32 ist das Wort im Speicher an der Adresse x.

Befehl	Operanden	Kodierung	Beschreibung
add	rd, rs1, rs2	0000000 rs2 rs1 000 rd 01100110x00000033 / Maske 0xFE00707F	Addition zweier Register`rd = rs1 + rs2`Arithmetik
addi	rd, rs1, imm12auch: li, mv, nop	imm[11-0] rs1 000 rd 00100110x00000013 / Maske 0x0000707F	Addition einer Konstanten (12 Bit mit Vorzeichen)`rd = rs1 + sext(imm12)`Arithmetik
amoadd.w	rd, rs2, (rs1)	00000 aq rl rs2 rs1 010 rd 01011110x0000202F / Maske 0xF800707F	Atomare Addition (A)`rd = [rs1]; [rs1] = rd + rs2`Atomare Speicherbefehle (A)
amoand.w	rd, rs2, (rs1)	01100 aq rl rs2 rs1 010 rd 01011110x6000202F / Maske 0xF800707F	Atomares UND (A)`rd = [rs1]; [rs1] = rd & rs2`Atomare Speicherbefehle (A)
amomax.w	rd, rs2, (rs1)	10100 aq rl rs2 rs1 010 rd 01011110xA000202F / Maske 0xF800707F	Atomares Maximum mit Vorzeichen (A)`rd = [rs1]; [rs1] = max_s(rd, rs2)`Atomare Speicherbefehle (A)
amomaxu.w	rd, rs2, (rs1)	11100 aq rl rs2 rs1 010 rd 01011110xE000202F / Maske 0xF800707F	Atomares Maximum ohne Vorzeichen (A)`rd = [rs1]; [rs1] = max_u(rd, rs2)`Atomare Speicherbefehle (A)
amomin.w	rd, rs2, (rs1)	10000 aq rl rs2 rs1 010 rd 01011110x8000202F / Maske 0xF800707F	Atomares Minimum mit Vorzeichen (A)`rd = [rs1]; [rs1] = min_s(rd, rs2)`Atomare Speicherbefehle (A)
amominu.w	rd, rs2, (rs1)	11000 aq rl rs2 rs1 010 rd 01011110xC000202F / Maske 0xF800707F	Atomares Minimum ohne Vorzeichen (A)`rd = [rs1]; [rs1] = min_u(rd, rs2)`Atomare Speicherbefehle (A)
amoor.w	rd, rs2, (rs1)	01000 aq rl rs2 rs1 010 rd 01011110x4000202F / Maske 0xF800707F	Atomares ODER (A)`rd = [rs1]; [rs1] = rd \| rs2`Atomare Speicherbefehle (A)
amoswap.w	rd, rs2, (rs1)	00001 aq rl rs2 rs1 010 rd 01011110x0800202F / Maske 0xF800707F	Atomarer Austausch (A)`rd = [rs1]; [rs1] = rs2`Atomare Speicherbefehle (A)
amoxor.w	rd, rs2, (rs1)	00100 aq rl rs2 rs1 010 rd 01011110x2000202F / Maske 0xF800707F	Atomares exklusives ODER (A)`rd = [rs1]; [rs1] = rd ^ rs2`Atomare Speicherbefehle (A)
and	rd, rs1, rs2	0000000 rs2 rs1 111 rd 01100110x00007033 / Maske 0xFE00707F	UND`rd = rs1 & rs2`Logik und Bits
andi	rd, rs1, imm12	imm[11-0] rs1 111 rd 00100110x00007013 / Maske 0x0000707F	UND mit einer Konstanten`rd = rs1 & sext(imm12)`Logik und Bits
andn	rd, rs1, rs2	0100000 rs2 rs1 111 rd 01100110x40007033 / Maske 0xFE00707F	UND mit invertiertem Operanden (Zbb, Zbkb)`rd = rs1 & ~rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
auipc	rd, imm20	imm[31-12] rd 00101110x00000017 / Maske 0x0000007F	Addition der oberen 20 Bit zum pc (Adresse relativ zum Befehl)`rd = pc + (imm20 << 12)`Konstanten und Adressen laden
bclr	rd, rs1, rs2	0100100 rs2 rs1 001 rd 01100110x48001033 / Maske 0xFE00707F	Löschen eines Bits (Zbs)`rd = rs1 & ~(1 << rs2[4:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
bclri	rd, rs1, shamt	0100100 shamt rs1 001 rd 00100110x48001013 / Maske 0xFE00707F	Löschen eines Bits, Nummer als Konstante (Zbs)`rd = rs1 & ~(1 << shamt)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
beq	rs1, rs2, labelauch: beqz	imm[12\|10-5] rs2 rs1 000 imm[4-1\|11] 11000110x00000063 / Maske 0x0000707F	Verzweigung, wenn gleich`if rs1 == rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
bext	rd, rs1, rs2	0100100 rs2 rs1 101 rd 01100110x48005033 / Maske 0xFE00707F	Auslesen eines Bits (Zbs)`rd = (rs1 >> rs2[4:0]) & 1`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
bexti	rd, rs1, shamt	0100100 shamt rs1 101 rd 00100110x48005013 / Maske 0xFE00707F	Auslesen eines Bits, Nummer als Konstante (Zbs)`rd = (rs1 >> shamt) & 1`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
bge	rs1, rs2, labelauch: bgez, blez	imm[12\|10-5] rs2 rs1 101 imm[4-1\|11] 11000110x00005063 / Maske 0x0000707F	Verzweigung, wenn größer oder gleich (mit Vorzeichen)`if rs1 >=s rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
bgeu	rs1, rs2, label	imm[12\|10-5] rs2 rs1 111 imm[4-1\|11] 11000110x00007063 / Maske 0x0000707F	Verzweigung, wenn größer oder gleich (ohne Vorzeichen)`if rs1 >=u rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
binv	rd, rs1, rs2	0110100 rs2 rs1 001 rd 01100110x68001033 / Maske 0xFE00707F	Umkehren eines Bits (Zbs)`rd = rs1 ^ (1 << rs2[4:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
binvi	rd, rs1, shamt	0110100 shamt rs1 001 rd 00100110x68001013 / Maske 0xFE00707F	Umkehren eines Bits, Nummer als Konstante (Zbs)`rd = rs1 ^ (1 << shamt)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
blt	rs1, rs2, labelauch: bltz, bgtz	imm[12\|10-5] rs2 rs1 100 imm[4-1\|11] 11000110x00004063 / Maske 0x0000707F	Verzweigung, wenn kleiner (mit Vorzeichen)`if rs1 <s rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
bltu	rs1, rs2, label	imm[12\|10-5] rs2 rs1 110 imm[4-1\|11] 11000110x00006063 / Maske 0x0000707F	Verzweigung, wenn kleiner (ohne Vorzeichen)`if rs1 <u rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
bne	rs1, rs2, labelauch: bnez	imm[12\|10-5] rs2 rs1 001 imm[4-1\|11] 11000110x00001063 / Maske 0x0000707F	Verzweigung, wenn ungleich`if rs1 != rs2 then pc = pc + sext(imm13)`Sprünge und Aufrufe
brev8	rd, rs1	011010000111 rs1 101 rd 00100110x68705013 / Maske 0xFFF0707F	Umkehrung der Bits in jedem Byte (Zbkb)`for every byte: rd.byte = bit_reverse(rs1.byte)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
bset	rd, rs1, rs2	0010100 rs2 rs1 001 rd 01100110x28001033 / Maske 0xFE00707F	Setzen eines Bits (Zbs)`rd = rs1 \| (1 << rs2[4:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
bseti	rd, rs1, shamt	0010100 shamt rs1 001 rd 00100110x28001013 / Maske 0xFE00707F	Setzen eines Bits, Nummer als Konstante (Zbs)`rd = rs1 \| (1 << shamt)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
c.add	rd, rs2	100 1 rd rs2 100x9002 / Maske 0xF003	Addition zweier Register`rd = rd + rs2 (rs2 != 0)`Komprimierte Befehle (C, Zcb)
c.addi	rd, imm6auch: c.nop	000 imm[5] rd imm[4-0] 010x0001 / Maske 0xE003	Addition einer Konstanten (6 Bit mit Vorzeichen)`rd = rd + sext(imm6)`Komprimierte Befehle (C, Zcb)
c.addi16sp	sp, imm	011 imm[9] 00010 imm[4\|6\|8-7\|5] 010x6101 / Maske 0xEF83	Addition eines Vielfachen von 16 zum sp`sp = sp + sext(imm10) (imm != 0)`Komprimierte Befehle (C, Zcb)
c.addi4spn	rd', sp, uimm	000 uimm[5-4\|9-6\|2\|3] rd' 000x0000 / Maske 0xE003	Addition einer Konstanten zum sp (Adresse auf dem Stack)`rd' = sp + zext(uimm) (uimm != 0)`Komprimierte Befehle (C, Zcb)
c.and	rd', rs2'	100 0 11 rd' 11 rs2' 010x8C61 / Maske 0xFC63	UND`rd' = rd' & rs2'`Komprimierte Befehle (C, Zcb)
c.andi	rd', imm6	100 imm[5] 10 rd' imm[4-0] 010x8801 / Maske 0xEC03	UND mit einer Konstanten (6 Bit mit Vorzeichen)`rd' = rd' & sext(imm6)`Komprimierte Befehle (C, Zcb)
c.beqz	rs1', label	110 imm[8\|4-3] rs1' imm[7-6\|2-1\|5] 010xC001 / Maske 0xE003	Verzweigung, wenn 0`if rs1' == 0 then pc = pc + sext(imm9)`Komprimierte Befehle (C, Zcb)
c.bnez	rs1', label	111 imm[8\|4-3] rs1' imm[7-6\|2-1\|5] 010xE001 / Maske 0xE003	Verzweigung, wenn nicht 0`if rs1' != 0 then pc = pc + sext(imm9)`Komprimierte Befehle (C, Zcb)
c.ebreak		100 1 00000 00000 100x9002 / Maske 0xFFFF	Haltepunkt für den Debugger`raise breakpoint exception (or enter debug mode)`Komprimierte Befehle (C, Zcb)
c.j	label	101 imm[11\|4\|9-8\|10\|6\|7\|3-1\|5] 010xA001 / Maske 0xE003	Sprung (±2 KB)`pc = pc + sext(imm12)`Komprimierte Befehle (C, Zcb)
c.jal	label	001 imm[11\|4\|9-8\|10\|6\|7\|3-1\|5] 010x2001 / Maske 0xE003	Sprung mit Rücksprungadresse in ra (±2 KB)`ra = pc + 2; pc = pc + sext(imm12)`Komprimierte Befehle (C, Zcb)
c.jalr	rs1	100 1 rs1 00000 100x9002 / Maske 0xF07F	Sprung an die Adresse in einem Register, mit Rücksprungadresse in ra`t = rs1; ra = pc + 2; pc = t`Komprimierte Befehle (C, Zcb)
c.jr	rs1	100 0 rs1 00000 100x8002 / Maske 0xF07F	Sprung an die Adresse in einem Register`pc = rs1 (rs1 != 0)`Komprimierte Befehle (C, Zcb)
c.lbu	rd', uimm(rs1')	100 000 rs1' uimm[0\|1] rd' 000x8000 / Maske 0xFC03	Laden eines Bytes ohne Vorzeichen (Zcb)`rd' = zext([rs1' + uimm]8)`Komprimierte Befehle (C, Zcb)
c.lh	rd', uimm(rs1')	100 001 rs1' 1 uimm[1] rd' 000x8440 / Maske 0xFC43	Laden eines Halbworts mit Vorzeichen (Zcb)`rd' = sext([rs1' + uimm]16)`Komprimierte Befehle (C, Zcb)
c.lhu	rd', uimm(rs1')	100 001 rs1' 0 uimm[1] rd' 000x8400 / Maske 0xFC43	Laden eines Halbworts ohne Vorzeichen (Zcb)`rd' = zext([rs1' + uimm]16)`Komprimierte Befehle (C, Zcb)
c.li	rd, imm6	010 imm[5] rd imm[4-0] 010x4001 / Maske 0xE003	Laden einer Konstanten (6 Bit mit Vorzeichen)`rd = sext(imm6)`Komprimierte Befehle (C, Zcb)
c.lui	rd, imm6auch: c.addi16sp	011 imm[17] rd imm[16-12] 010x6001 / Maske 0xE003	Laden der Bits 17 bis 12 einer Konstanten`rd = sext(imm6 << 12) (rd != 0, 2)`Komprimierte Befehle (C, Zcb)
c.lw	rd', uimm(rs1')	010 uimm[5-3] rs1' uimm[2\|6] rd' 000x4000 / Maske 0xE003	Laden eines Worts`rd' = [rs1' + zext(uimm)]32`Komprimierte Befehle (C, Zcb)
c.lwsp	rd, uimm(sp)	010 uimm[5] rd uimm[4-2\|7-6] 100x4002 / Maske 0xE003	Laden eines Worts vom Stack`rd = [sp + zext(uimm)]32 (rd != 0)`Komprimierte Befehle (C, Zcb)
c.mul	rd', rs2'	100 1 11 rd' 10 rs2' 010x9C41 / Maske 0xFC63	Multiplikation, untere 32 Bit (Zcb)`rd' = (rd' * rs2')[31:0]`Komprimierte Befehle (C, Zcb)
c.mv	rd, rs2	100 0 rd rs2 100x8002 / Maske 0xF003	Kopieren eines Registers`rd = rs2 (rs2 != 0)`Komprimierte Befehle (C, Zcb)
c.not	rd'	100 1 11 rd' 11 101 010x9C75 / Maske 0xFC7F	Bitweise Umkehrung (Zcb)`rd' = ~rd'`Komprimierte Befehle (C, Zcb)
c.or	rd', rs2'	100 0 11 rd' 10 rs2' 010x8C41 / Maske 0xFC63	ODER`rd' = rd' \| rs2'`Komprimierte Befehle (C, Zcb)
c.sb	rs2', uimm(rs1')	100 010 rs1' uimm[0\|1] rs2' 000x8800 / Maske 0xFC03	Speichern eines Bytes (Zcb)`[rs1' + uimm]8 = rs2'[7:0]`Komprimierte Befehle (C, Zcb)
c.sext.b	rd'	100 1 11 rd' 11 001 010x9C65 / Maske 0xFC7F	Erweiterung eines Bytes mit Vorzeichen (Zcb)`rd' = sext(rd'[7:0])`Komprimierte Befehle (C, Zcb)
c.sext.h	rd'	100 1 11 rd' 11 011 010x9C6D / Maske 0xFC7F	Erweiterung eines Halbworts mit Vorzeichen (Zcb)`rd' = sext(rd'[15:0])`Komprimierte Befehle (C, Zcb)
c.sh	rs2', uimm(rs1')	100 011 rs1' 0 uimm[1] rs2' 000x8C00 / Maske 0xFC43	Speichern eines Halbworts (Zcb)`[rs1' + uimm]16 = rs2'[15:0]`Komprimierte Befehle (C, Zcb)
c.slli	rd, shamt	000 0 rd shamt 100x0002 / Maske 0xF003	Schieben nach links um eine Konstante`rd = rd << shamt`Komprimierte Befehle (C, Zcb)
c.srai	rd', shamt	100 0 01 rd' shamt 010x8401 / Maske 0xFC03	Schieben nach rechts mit Vorzeichen um eine Konstante`rd' = rd' >>s shamt`Komprimierte Befehle (C, Zcb)
c.srli	rd', shamt	100 0 00 rd' shamt 010x8001 / Maske 0xFC03	Schieben nach rechts ohne Vorzeichen um eine Konstante`rd' = rd' >>u shamt`Komprimierte Befehle (C, Zcb)
c.sub	rd', rs2'	100 0 11 rd' 00 rs2' 010x8C01 / Maske 0xFC63	Subtraktion`rd' = rd' - rs2'`Komprimierte Befehle (C, Zcb)
c.sw	rs2', uimm(rs1')	110 uimm[5-3] rs1' uimm[2\|6] rs2' 000xC000 / Maske 0xE003	Speichern eines Worts`[rs1' + zext(uimm)]32 = rs2'`Komprimierte Befehle (C, Zcb)
c.swsp	rs2, uimm(sp)	110 uimm[5-2\|7-6] rs2 100xC002 / Maske 0xE003	Speichern eines Worts auf dem Stack`[sp + zext(uimm)]32 = rs2`Komprimierte Befehle (C, Zcb)
c.xor	rd', rs2'	100 0 11 rd' 01 rs2' 010x8C21 / Maske 0xFC63	Exklusives ODER`rd' = rd' ^ rs2'`Komprimierte Befehle (C, Zcb)
c.zext.b	rd'	100 1 11 rd' 11 000 010x9C61 / Maske 0xFC7F	Erweiterung eines Bytes mit Nullen (Zcb)`rd' = zext(rd'[7:0])`Komprimierte Befehle (C, Zcb)
c.zext.h	rd'	100 1 11 rd' 11 010 010x9C69 / Maske 0xFC7F	Erweiterung eines Halbworts mit Nullen (Zcb)`rd' = zext(rd'[15:0])`Komprimierte Befehle (C, Zcb)
clmul	rd, rs1, rs2	0000101 rs2 rs1 001 rd 01100110x0A001033 / Maske 0xFE00707F	Multiplikation ohne Übertrag, untere 32 Bit (Zbc)`rd = clmul(rs1, rs2)[31:0]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
clmulh	rd, rs1, rs2	0000101 rs2 rs1 011 rd 01100110x0A003033 / Maske 0xFE00707F	Multiplikation ohne Übertrag, obere 32 Bit (Zbc)`rd = clmul(rs1, rs2)[63:32]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
clmulr	rd, rs1, rs2	0000101 rs2 rs1 010 rd 01100110x0A002033 / Maske 0xFE00707F	Multiplikation ohne Übertrag, Bits 62 bis 31 (Zbc)`rd = clmul(rs1, rs2)[62:31]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
clz	rd, rs1	0110000 00000 rs1 001 rd 00100110x60001013 / Maske 0xFFF0707F	Zählen der führenden Nullbits (Zbb)`rd = number of 0 bits above the highest 1 bit (32 for 0)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
cpop	rd, rs1	0110000 00010 rs1 001 rd 00100110x60201013 / Maske 0xFFF0707F	Zählen der gesetzten Bits (Zbb)`rd = number of 1 bits in rs1`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
csrrc	rd, csr, rs1auch: csrc	csr rs1 011 rd 11100110x00003073 / Maske 0x0000707F	Lesen eines Steuerregisters und Löschen von Bits`t = csr; csr = t & ~rs1; rd = t`Steuer- und Statusregister (Zicsr)
csrrci	rd, csr, uimm5auch: csrci	csr uimm 111 rd 11100110x00007073 / Maske 0x0000707F	Lesen eines Steuerregisters und Löschen von Bits einer Konstanten`t = csr; csr = t & ~uimm5; rd = t`Steuer- und Statusregister (Zicsr)
csrrs	rd, csr, rs1auch: csrr, csrs	csr rs1 010 rd 11100110x00002073 / Maske 0x0000707F	Lesen eines Steuerregisters und Setzen von Bits`t = csr; csr = t \| rs1; rd = t`Steuer- und Statusregister (Zicsr)
csrrsi	rd, csr, uimm5auch: csrsi	csr uimm 110 rd 11100110x00006073 / Maske 0x0000707F	Lesen eines Steuerregisters und Setzen von Bits einer Konstanten`t = csr; csr = t \| uimm5; rd = t`Steuer- und Statusregister (Zicsr)
csrrw	rd, csr, rs1auch: csrw	csr rs1 001 rd 11100110x00001073 / Maske 0x0000707F	Austausch eines Steuerregisters mit einem Register`t = csr; csr = rs1; rd = t`Steuer- und Statusregister (Zicsr)
csrrwi	rd, csr, uimm5auch: csrwi	csr uimm 101 rd 11100110x00005073 / Maske 0x0000707F	Austausch eines Steuerregisters mit einer Konstanten (5 Bit)`rd = csr; csr = uimm5`Steuer- und Statusregister (Zicsr)
ctz	rd, rs1	0110000 00001 rs1 001 rd 00100110x60101013 / Maske 0xFFF0707F	Zählen der Nullbits am Ende (Zbb)`rd = number of 0 bits below the lowest 1 bit (32 for 0)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
div	rd, rs1, rs2	0000001 rs2 rs1 100 rd 01100110x02004033 / Maske 0xFE00707F	Division mit Vorzeichen (M)`rd = rs1 /s rs2 (by 0: -1)`Arithmetik
divu	rd, rs1, rs2	0000001 rs2 rs1 101 rd 01100110x02005033 / Maske 0xFE00707F	Division ohne Vorzeichen (M)`rd = rs1 /u rs2 (by 0: all ones)`Arithmetik
ebreak		000000000001 00000 000 00000 11100110x00100073 / Maske 0xFFFFFFFF	Haltepunkt für den Debugger`raise breakpoint exception (or enter debug mode)`System und Privilegien
ecall		000000000000 00000 000 00000 11100110x00000073 / Maske 0xFFFFFFFF	Aufruf der Umgebung (Ausnahme)`raise environment call exception`System und Privilegien
fence	pred, succ	0000 pred succ 00000 000 00000 00011110x0000000F / Maske 0xF00FFFFF	Speicherbarriere: Zugriffe der Art pred vor denen der Art succ`order memory accesses (i, o, r, w)`Schranken und Sonstiges
fence.i		000000000000 00000 001 00000 00011110x0000100F / Maske 0xFFFFFFFF	Synchronisation des Befehlsstroms mit geschriebenem Code (Zifencei)`later instruction fetches see earlier stores`Schranken und Sonstiges
jal	rd, labelauch: j	imm[20\|10-1\|11\|19-12] rd 11011110x0000006F / Maske 0x0000007F	Sprung mit Rücksprungadresse (±1 MB)`rd = pc + 4; pc = pc + sext(imm21)`Sprünge und Aufrufe
jalr	rd, imm12(rs1)auch: jr, ret	imm[11-0] rs1 000 rd 11001110x00000067 / Maske 0x0000707F	Sprung an die Adresse in einem Register, mit Rücksprungadresse`t = rs1 + sext(imm12); rd = pc + 4; pc = t & ~1`Sprünge und Aufrufe
lb	rd, imm12(rs1)	imm[11-0] rs1 000 rd 00000110x00000003 / Maske 0x0000707F	Laden eines Bytes mit Vorzeichen`rd = sext([rs1 + sext(imm12)]8)`Laden und Speichern
lbu	rd, imm12(rs1)	imm[11-0] rs1 100 rd 00000110x00004003 / Maske 0x0000707F	Laden eines Bytes ohne Vorzeichen`rd = zext([rs1 + sext(imm12)]8)`Laden und Speichern
lh	rd, imm12(rs1)	imm[11-0] rs1 001 rd 00000110x00001003 / Maske 0x0000707F	Laden eines Halbworts mit Vorzeichen`rd = sext([rs1 + sext(imm12)]16)`Laden und Speichern
lhu	rd, imm12(rs1)	imm[11-0] rs1 101 rd 00000110x00005003 / Maske 0x0000707F	Laden eines Halbworts ohne Vorzeichen`rd = zext([rs1 + sext(imm12)]16)`Laden und Speichern
lr.w	rd, (rs1)	00010 aq rl 00000 rs1 010 rd 01011110x1000202F / Maske 0xF9F0707F	Laden mit Reservierung (A)`rd = [rs1]32; reserve the address`Atomare Speicherbefehle (A)
lui	rd, imm20	imm[31-12] rd 01101110x00000037 / Maske 0x0000007F	Laden der oberen 20 Bit einer Konstanten`rd = imm20 << 12`Konstanten und Adressen laden
lw	rd, imm12(rs1)	imm[11-0] rs1 010 rd 00000110x00002003 / Maske 0x0000707F	Laden eines Worts (32 Bit)`rd = [rs1 + sext(imm12)]32`Laden und Speichern
max	rd, rs1, rs2	0000101 rs2 rs1 110 rd 01100110x0A006033 / Maske 0xFE00707F	Maximum mit Vorzeichen (Zbb)`rd = (rs1 >s rs2) ? rs1 : rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
maxu	rd, rs1, rs2	0000101 rs2 rs1 111 rd 01100110x0A007033 / Maske 0xFE00707F	Maximum ohne Vorzeichen (Zbb)`rd = (rs1 >u rs2) ? rs1 : rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
min	rd, rs1, rs2	0000101 rs2 rs1 100 rd 01100110x0A004033 / Maske 0xFE00707F	Minimum mit Vorzeichen (Zbb)`rd = (rs1 <s rs2) ? rs1 : rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
minu	rd, rs1, rs2	0000101 rs2 rs1 101 rd 01100110x0A005033 / Maske 0xFE00707F	Minimum ohne Vorzeichen (Zbb)`rd = (rs1 <u rs2) ? rs1 : rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
mret		0011000 00010 00000 000 00000 11100110x30200073 / Maske 0xFFFFFFFF	Rückkehr aus einer Ausnahme im Machine Mode`pc = mepc; restore the mode from mstatus`System und Privilegien
mul	rd, rs1, rs2	0000001 rs2 rs1 000 rd 01100110x02000033 / Maske 0xFE00707F	Multiplikation, untere 32 Bit (M)`rd = (rs1 * rs2)[31:0]`Arithmetik
mulh	rd, rs1, rs2	0000001 rs2 rs1 001 rd 01100110x02001033 / Maske 0xFE00707F	Multiplikation mit Vorzeichen, obere 32 Bit (M)`rd = (sext(rs1) * sext(rs2))[63:32]`Arithmetik
mulhsu	rd, rs1, rs2	0000001 rs2 rs1 010 rd 01100110x02002033 / Maske 0xFE00707F	Multiplikation mit und ohne Vorzeichen, obere 32 Bit (M)`rd = (sext(rs1) * zext(rs2))[63:32]`Arithmetik
mulhu	rd, rs1, rs2	0000001 rs2 rs1 011 rd 01100110x02003033 / Maske 0xFE00707F	Multiplikation ohne Vorzeichen, obere 32 Bit (M)`rd = (zext(rs1) * zext(rs2))[63:32]`Arithmetik
or	rd, rs1, rs2	0000000 rs2 rs1 110 rd 01100110x00006033 / Maske 0xFE00707F	ODER`rd = rs1 \| rs2`Logik und Bits
orc.b	rd, rs1	001010000111 rs1 101 rd 00100110x28705013 / Maske 0xFFF0707F	Bytes auf 0x00 oder 0xFF setzen, je nachdem, ob ein Bit gesetzt ist (Zbb)`for every byte: rd.byte = (rs1.byte != 0) ? 0xFF : 0`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
ori	rd, rs1, imm12	imm[11-0] rs1 110 rd 00100110x00006013 / Maske 0x0000707F	ODER mit einer Konstanten`rd = rs1 \| sext(imm12)`Logik und Bits
orn	rd, rs1, rs2	0100000 rs2 rs1 110 rd 01100110x40006033 / Maske 0xFE00707F	ODER mit invertiertem Operanden (Zbb, Zbkb)`rd = rs1 \| ~rs2`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
pack	rd, rs1, rs2auch: zext.h	0000100 rs2 rs1 100 rd 01100110x08004033 / Maske 0xFE00707F	Zusammensetzen der unteren Halbwörter zweier Register (Zbkb)`rd = (rs2[15:0] << 16) \| rs1[15:0]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
packh	rd, rs1, rs2	0000100 rs2 rs1 111 rd 01100110x08007033 / Maske 0xFE00707F	Zusammensetzen der unteren Bytes zweier Register (Zbkb)`rd = (rs2[7:0] << 8) \| rs1[7:0]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
rem	rd, rs1, rs2	0000001 rs2 rs1 110 rd 01100110x02006033 / Maske 0xFE00707F	Rest der Division mit Vorzeichen (M)`rd = rs1 %s rs2 (by 0: rs1)`Arithmetik
remu	rd, rs1, rs2	0000001 rs2 rs1 111 rd 01100110x02007033 / Maske 0xFE00707F	Rest der Division ohne Vorzeichen (M)`rd = rs1 %u rs2 (by 0: rs1)`Arithmetik
rev8	rd, rs1	011010011000 rs1 101 rd 00100110x69805013 / Maske 0xFFF0707F	Umkehrung der Reihenfolge der Bytes (Zbb, Zbkb)`rd = byte_reverse(rs1)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
rol	rd, rs1, rs2	0110000 rs2 rs1 001 rd 01100110x60001033 / Maske 0xFE00707F	Rotation nach links um ein Register (Zbb, Zbkb)`rd = rotate_left(rs1, rs2[4:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
ror	rd, rs1, rs2	0110000 rs2 rs1 101 rd 01100110x60005033 / Maske 0xFE00707F	Rotation nach rechts um ein Register (Zbb, Zbkb)`rd = rotate_right(rs1, rs2[4:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
rori	rd, rs1, shamt	0110000 shamt rs1 101 rd 00100110x60005013 / Maske 0xFE00707F	Rotation nach rechts um eine Konstante (Zbb, Zbkb)`rd = rotate_right(rs1, shamt)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sb	rs2, imm12(rs1)	imm[11-5] rs2 rs1 000 imm[4-0] 01000110x00000023 / Maske 0x0000707F	Speichern eines Bytes`[rs1 + sext(imm12)]8 = rs2[7:0]`Laden und Speichern
sc.w	rd, rs2, (rs1)	00011 aq rl rs2 rs1 010 rd 01011110x1800202F / Maske 0xF800707F	Bedingtes Speichern nach lr.w (A)`if reserved then [rs1]32 = rs2; rd = 0 else rd = 1`Atomare Speicherbefehle (A)
sext.b	rd, rs1	0110000 00100 rs1 001 rd 00100110x60401013 / Maske 0xFFF0707F	Erweiterung eines Bytes mit Vorzeichen (Zbb)`rd = sext(rs1[7:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sext.h	rd, rs1	0110000 00101 rs1 001 rd 00100110x60501013 / Maske 0xFFF0707F	Erweiterung eines Halbworts mit Vorzeichen (Zbb)`rd = sext(rs1[15:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sh	rs2, imm12(rs1)	imm[11-5] rs2 rs1 001 imm[4-0] 01000110x00001023 / Maske 0x0000707F	Speichern eines Halbworts`[rs1 + sext(imm12)]16 = rs2[15:0]`Laden und Speichern
sh1add	rd, rs1, rs2	0010000 rs2 rs1 010 rd 01100110x20002033 / Maske 0xFE00707F	Addition mit um 1 verschobenem Register (Zba)`rd = rs2 + (rs1 << 1)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sh2add	rd, rs1, rs2	0010000 rs2 rs1 100 rd 01100110x20004033 / Maske 0xFE00707F	Addition mit um 2 verschobenem Register (Zba)`rd = rs2 + (rs1 << 2)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sh3add	rd, rs1, rs2	0010000 rs2 rs1 110 rd 01100110x20006033 / Maske 0xFE00707F	Addition mit um 3 verschobenem Register (Zba)`rd = rs2 + (rs1 << 3)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
sll	rd, rs1, rs2	0000000 rs2 rs1 001 rd 01100110x00001033 / Maske 0xFE00707F	Schieben nach links um ein Register`rd = rs1 << rs2[4:0]`Schieben und Rotieren
slli	rd, rs1, shamt	0000000 shamt rs1 001 rd 00100110x00001013 / Maske 0xFE00707F	Schieben nach links um eine Konstante`rd = rs1 << shamt`Schieben und Rotieren
slt	rd, rs1, rs2auch: sltz, sgtz	0000000 rs2 rs1 010 rd 01100110x00002033 / Maske 0xFE00707F	Vergleich mit Vorzeichen: 1, wenn kleiner`rd = (rs1 <s rs2) ? 1 : 0`Vergleichen und Tauschen
slti	rd, rs1, imm12	imm[11-0] rs1 010 rd 00100110x00002013 / Maske 0x0000707F	Vergleich mit einer Konstanten mit Vorzeichen: 1, wenn kleiner`rd = (rs1 <s sext(imm12)) ? 1 : 0`Vergleichen und Tauschen
sltiu	rd, rs1, imm12auch: seqz	imm[11-0] rs1 011 rd 00100110x00003013 / Maske 0x0000707F	Vergleich mit einer Konstanten ohne Vorzeichen: 1, wenn kleiner`rd = (rs1 <u sext(imm12)) ? 1 : 0`Vergleichen und Tauschen
sltu	rd, rs1, rs2auch: snez	0000000 rs2 rs1 011 rd 01100110x00003033 / Maske 0xFE00707F	Vergleich ohne Vorzeichen: 1, wenn kleiner`rd = (rs1 <u rs2) ? 1 : 0`Vergleichen und Tauschen
sra	rd, rs1, rs2	0100000 rs2 rs1 101 rd 01100110x40005033 / Maske 0xFE00707F	Schieben nach rechts mit Vorzeichen um ein Register`rd = rs1 >>s rs2[4:0]`Schieben und Rotieren
srai	rd, rs1, shamt	0100000 shamt rs1 101 rd 00100110x40005013 / Maske 0xFE00707F	Schieben nach rechts mit Vorzeichen um eine Konstante`rd = rs1 >>s shamt`Schieben und Rotieren
sret		0001000 00010 00000 000 00000 11100110x10200073 / Maske 0xFFFFFFFF	Rückkehr aus einer Ausnahme im Supervisor Mode`pc = sepc; restore the mode from sstatus`System und Privilegien
srl	rd, rs1, rs2	0000000 rs2 rs1 101 rd 01100110x00005033 / Maske 0xFE00707F	Schieben nach rechts ohne Vorzeichen um ein Register`rd = rs1 >>u rs2[4:0]`Schieben und Rotieren
srli	rd, rs1, shamt	0000000 shamt rs1 101 rd 00100110x00005013 / Maske 0xFE00707F	Schieben nach rechts ohne Vorzeichen um eine Konstante`rd = rs1 >>u shamt`Schieben und Rotieren
sub	rd, rs1, rs2auch: neg	0100000 rs2 rs1 000 rd 01100110x40000033 / Maske 0xFE00707F	Subtraktion zweier Register`rd = rs1 - rs2`Arithmetik
sw	rs2, imm12(rs1)	imm[11-5] rs2 rs1 010 imm[4-0] 01000110x00002023 / Maske 0x0000707F	Speichern eines Worts`[rs1 + sext(imm12)]32 = rs2`Laden und Speichern
unzip	rd, rs1	000010001111 rs1 101 rd 00100110x08F05013 / Maske 0xFFF0707F	Entflechten in gerade und ungerade Bits (Zbkb)`rd[i] = rs1[2i]; rd[i+16] = rs1[2i+1]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
wfi		0001000 00101 00000 000 00000 11100110x10500073 / Maske 0xFFFFFFFF	Warten auf einen Interrupt`pause until an interrupt is pending`System und Privilegien
xnor	rd, rs1, rs2	0100000 rs2 rs1 100 rd 01100110x40004033 / Maske 0xFE00707F	Invertiertes exklusives ODER (Zbb, Zbkb)`rd = ~(rs1 ^ rs2)`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
xor	rd, rs1, rs2	0000000 rs2 rs1 100 rd 01100110x00004033 / Maske 0xFE00707F	Exklusives ODER`rd = rs1 ^ rs2`Logik und Bits
xori	rd, rs1, imm12auch: not	imm[11-0] rs1 100 rd 00100110x00004013 / Maske 0x0000707F	Exklusives ODER mit einer Konstanten`rd = rs1 ^ sext(imm12)`Logik und Bits
zext.h	rd, rs1	0000100 00000 rs1 100 rd 01100110x08004033 / Maske 0xFFF0707F	Erweiterung eines Halbworts mit Nullen (Zbb)`rd = zext(rs1[15:0])`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)
zip	rd, rs1	000010001111 rs1 001 rd 00100110x08F01013 / Maske 0xFFF0707F	Verschränken der Bits der beiden Halbwörter (Zbkb)`rd[2i] = rs1[i]; rd[2i+1] = rs1[i+16]`Bit-Manipulation (Zba, Zbb, Zbs, Zbc, Zbkb)