Referència tècnica
RV32I
Registres
Propòsit general
RISC-V 1: RV32I Registres — Propòsit general
| ISA | ABI | Propòsit | Saver |
|---|---|---|---|
x0 |
zero |
El valor constant zero | — |
x1 |
ra |
Adreça de retorn (return address) de subrutina | Caller |
x2 |
sp |
Punter de pila (stack pointer), adreça del cim de la pila | Callee |
x3 |
gp |
Punter global (global pointer) | — |
x4 |
tp |
Punter de fil (thread pointer) | — |
x5–x7 |
t0–t2 |
Temporals | Caller |
x8 |
s0 / fp |
Segur / Punter de marc (frame pointer) | Callee |
x9 |
s1 |
Segur | Callee |
x10, x11 |
a0, a1 |
Arguments de subrutines / Valors de retorn | Caller |
x12–x17 |
a2–a7 |
Arguments de subrutines | Caller |
x18–x27 |
s2–s11 |
Segurs | Callee |
x28–x31 |
t3–t6 |
Temporals | Caller |
Vegeu RISC-V 2.24.
Caller-saved i callee-saved
RISC-V 2: RV32I ABI — Registres caller-saved i callee-saved
| Categoria | Registres ABI | Saver |
|---|---|---|
| Temporals i arguments | t0–t6, a0–a7 |
Caller |
| Adreça de retorn | ra |
Caller |
| Segurs | s0–s11, sp |
Callee |
Vegeu RISC-V 3.22.
Format de les instruccions
RISC-V 3: RV32I ISA — Formats d’instrucció
Instruccions
Aritmètica entera
RISC-V 4: RV32I ISA — Instruccions d’aritmètica entera
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
add |
rd, rs1, rs2 |
\(rd \leftarrow rs1 + rs2\) | add | R |
addi |
rd, rs1, imm12 |
\(rd \leftarrow rs1 + SignExt(imm12)\) | add immediate | I |
sub |
rd, rs1, rs2 |
\(rd \leftarrow rs1 - rs2\) | subtract | R |
lui |
rd, imm20 |
\(rd \leftarrow imm20 << 12\) | load upper immediate | U |
auipc |
rd, imm20 |
\(rd \leftarrow PC + (imm20 << 12)\) | add upper immediate to PC | U |
Vegeu RISC-V 2.12, RISC-V 2.13 i RISC-V 2.14.
Lògica bit a bit
RISC-V 5: RV32I ISA — Instruccions lògiques bit a bit
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
and |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \land rs2\) | and | R |
andi |
rd, rs1, imm12 |
\(rd \leftarrow rs1 \land SignExt(imm12)\) | and immediate | I |
or |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \lor rs2\) | or | R |
ori |
rd, rs1, imm12 |
\(rd \leftarrow rs1 \lor SignExt(imm12)\) | or immediate | I |
xor |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \oplus rs2\) | exclusive or | R |
xori |
rd, rs1, imm12 |
\(rd \leftarrow rs1 \oplus SignExt(imm12)\) | exclusive or immediate | I |
Vegeu RISC-V 3.3.
Desplaçaments de bits
RISC-V 6: RV32I ISA — Instruccions de desplaçament de bits
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
sll |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \,<<\, rs2[4:0]\) | shift left logical | R |
slli |
rd, rs1, shamt |
\(rd \leftarrow rs1 \,<<\, shamt\) | shift left logical | I |
srl |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \,>>\, rs2[4:0]\) | shift right logical | R |
srli |
rd, rs1, shamt |
\(rd \leftarrow rs1 \,>>\, shamt\) | shift right logical | I |
sra |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \,>>> rs2[4:0]\) | shift right arithmetic | R |
srai |
rd, rs1, shamt |
\(rd \leftarrow rs1 \,>>> shamt\) | shift right arithmetic | I |
Vegeu RISC-V 3.1 i RISC-V 3.2. Vegeu EC 3.2 per a la notació >>>.
Comparació
RISC-V 7: RV32I ISA — Instruccions de comparació
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
slt |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 < rs2) \,?\, 1 : 0 \quad (\mathbb{Z})\) | set less than | R |
sltu |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 < rs2) \,?\, 1 : 0 \quad (\mathbb{N})\) | set less than unsigned | R |
slti |
rd, rs1, imm12 |
\(rd \leftarrow (rs1 < SignExt(imm12)) \,?\, 1 : 0 \quad (\mathbb{Z})\) | set less than immediate | I |
sltiu |
rd, rs1, imm12 |
\(rd \leftarrow (rs1 < SignExt(imm12)) \,?\, 1 : 0 \quad (\mathbb{N})\) | set less than immediate unsigned | I |
Vegeu RISC-V 3.5.
Lectura i escriptura
RISC-V 8: RV32I ISA — Instruccions de lectura i escriptura
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
lw |
rd, offset(rs1) |
\(rd \leftarrow M_w[rs1 + SignExt(offset)]\) | load word | I |
lh |
rd, offset(rs1) |
\(rd \leftarrow SignExt(M_h[rs1 + SignExt(offset)])\) | load half | I |
lhu |
rd, offset(rs1) |
\(rd \leftarrow ZeroExt(M_h[rs1 + SignExt(offset)])\) | load half unsigned | I |
lb |
rd, offset(rs1) |
\(rd \leftarrow SignExt(M_b[rs1 + SignExt(offset)])\) | load byte | I |
lbu |
rd, offset(rs1) |
\(rd \leftarrow ZeroExt(M_b[rs1 + SignExt(offset)])\) | load byte unsigned | I |
sw |
rs2, offset(rs1) |
\(M_w[rs1 + SignExt(offset)] \leftarrow rs2\) | store word | S |
sh |
rs2, offset(rs1) |
\(M_h[rs1 + SignExt(offset)] \leftarrow rs2[15:0]\) | store half | S |
sb |
rs2, offset(rs1) |
\(M_b[rs1 + SignExt(offset)] \leftarrow rs2[7:0]\) | store byte | S |
Vegeu RISC-V 2.29.
Salts condicionals
RISC-V 9: RV32I ISA — Instruccions de salt condicional
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
beq |
rs1, rs2, label |
\(rs1 == rs2 \,?\, PC \leftarrow PC + SignExt(offset13)\) | branch equal | B |
bne |
rs1, rs2, label |
\(rs1 != rs2 \,?\, PC \leftarrow PC + SignExt(offset13)\) | branch not equal | B |
blt |
rs1, rs2, label |
\(rs1 < rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | branch less than | B |
bge |
rs1, rs2, label |
\(rs1 >= rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | branch greater than or equal | B |
bltu |
rs1, rs2, label |
\(rs1 < rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{N})\) | branch less than unsigned | B |
bgeu |
rs1, rs2, label |
\(rs1 >= rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{N})\) | branch greater than or equal unsigned | B |
Vegeu RISC-V 3.7.
Salts incondicionals
RISC-V 10: RV32I ISA — Instruccions de salt incondicional
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
jal |
rd, label |
\(rd \leftarrow PC + 4; PC \leftarrow PC + SignExt(offset21)\) | jump and link | J |
jalr |
rd, offset(rs1) |
\(PC \leftarrow (rs1 + SignExt(offset)) \land \overline{1};\ rd \leftarrow PC_{ant} + 4\) | jump and link register | I |
Vegeu RISC-V 3.11 i RISC-V 3.13.
Pseudoinstruccions
Aritmètiques i de còpia
RISC-V 11: Pseudoinstruccions — Aritmètiques i de còpia
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
mv rd, rs |
\(rd \leftarrow rs\) | addi rd, rs, 0 |
neg rd, rs |
\(rd \leftarrow -rs\) | sub rd, zero, rs |
not rd, rs |
\(rd \leftarrow \overline{rs}\) | xori rd, rs, -1 |
Vegeu RISC-V 2.15, RISC-V 3.4 i RISC-V 4.1.
li
RISC-V 12: Pseudoinstruccions — Càrrega d’immediat a registre:
li
| Pseudoinstrucció | Operació | Condició | Expansió |
|---|---|---|---|
li rd, imm12 |
\(rd \leftarrow imm12\) | \(-2048 \le imm12 \le 2047\) | addi rd, zero, imm12 |
li rd, imm32 |
\(rd \leftarrow imm32\) | \(lo_{12}(imm32) = 0\) | lui rd, hi_20(imm32) |
li rd, imm32 |
\(rd \leftarrow imm32\) | \(lo_{12}(imm32) \neq 0\) | lui rd, hi_20(imm32) addi rd, rd, lo_12(imm32) |
Vegeu RISC-V 2.16.
la
RISC-V 13: Pseudoinstruccions — Càrrega d’adreça de memòria:
la
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
la rd, label |
\(rd \leftarrow @label\) | auipc rd, hi_20(@label - PC) addi rd, rd, lo_12(@label - PC) (amb l’ajust de \(hi_{20}\) si \(lo_{12}[11] = 1\)) |
Vegeu RISC-V 2.17, RISC-V 2.14 i RISC-V 2.14.
Salt condicional
RISC-V 14: Pseudoinstruccions — Salt condicional
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
bgt rs1, rs2, label |
\(rs1 > rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | blt rs2, rs1, label |
ble rs1, rs2, label |
\(rs1 <= rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | bge rs2, rs1, label |
bgtu rs1, rs2, label |
\(rs1 > rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{N})\) | bltu rs2, rs1, label |
bleu rs1, rs2, label |
\(rs1 <= rs2 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{N})\) | bgeu rs2, rs1, label |
Vegeu RISC-V 3.8.
Salt condicional amb zero
RISC-V 15: Pseudoinstruccions — Salt condicional amb zero
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
beqz rs, label |
\(rs == 0 \,?\, PC \leftarrow PC + SignExt(offset13)\) | beq rs, zero, label |
bnez rs, label |
\(rs != 0 \,?\, PC \leftarrow PC + SignExt(offset13)\) | bne rs, zero, label |
bltz rs, label |
\(rs < 0 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | blt rs, zero, label |
bgez rs, label |
\(rs >= 0 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | bge rs, zero, label |
bgtz rs, label |
\(rs > 0 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | blt zero, rs, label |
blez rs, label |
\(rs <= 0 \,?\, PC \leftarrow PC + SignExt(offset13) \quad (\mathbb{Z})\) | bge zero, rs, label |
Vegeu RISC-V 3.9.
Salt incondicional
RISC-V 16: Pseudoinstruccions — Salt incondicional
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
j label |
\(PC \leftarrow PC + SignExt(offset21)\) | jal zero, label |
jr rs |
\(PC \leftarrow rs\) | jalr zero, 0(rs) |
ret |
\(PC \leftarrow ra\) | jalr zero, 0(ra) |
Vegeu RISC-V 3.12 i RISC-V 3.14.
RV32M
Instruccions
RISC-V 17: RV32IM ISA — Instruccions de multiplicació i divisió entera
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
mul |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 \times rs2)[31{:}0]\) | Multiply | R |
mulh |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 \times rs2)[63{:}32]\) (enters) | Multiply High | R |
mulhu |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 \times rs2)[63{:}32]\) (naturals) | Multiply High Unsigned | R |
mulhsu |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 \times rs2)[63{:}32]\) (\(rs1\) enter, \(rs2\) natural) | Multiply High Signed-Unsigned | R |
div |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \div rs2\) (enters) | Divide | R |
divu |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \div rs2\) (naturals) | Divide Unsigned | R |
rem |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \bmod rs2\) (enters) | Remainder | R |
remu |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \bmod rs2\) (naturals) | Remainder Unsigned | R |
Vegeu RISC-V 4.2 i RISC-V 4.3.
RV32F
Registres
Coma flotant
RISC-V 18: RV32F ABI — Registres de coma flotant
| ISA | ABI | Propòsit | Saver |
|---|---|---|---|
f0–f7 |
ft0–ft7 |
Temporals | Caller |
f8–f9 |
fs0–fs1 |
Segurs | Callee |
f10–f11 |
fa0–fa1 |
Arguments de subrutines / Valors de retorn | Caller |
f12–f17 |
fa2–fa7 |
Arguments de subrutines | Caller |
f18–f27 |
fs2–fs11 |
Segurs | Callee |
f28–f31 |
ft8–ft11 |
Temporals | Caller |
Vegeu RISC-V 5.2.
Control (fcsr)
RISC-V 19: RV32F ISA — Registre de control
fcsr
Instruccions
Lectura i escriptura
RISC-V 20: RV32F ISA — Lectura i escriptura
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
flw |
rd, offset(rs1) |
\(rd \leftarrow M_w[rs1 + SignExt(offset)]\) | Float Load Word | I |
fsw |
rs2, offset(rs1) |
\(M_w[rs1 + SignExt(offset)] \leftarrow rs2\) | Float Store Word | S |
Vegeu RISC-V 5.4.
Aritmètica
RISC-V 21: RV32F ISA — Instruccions aritmètiques
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
fadd.s |
rd, rs1, rs2 |
\(rd \leftarrow rs1 + rs2\) | Float Add | R |
fsub.s |
rd, rs1, rs2 |
\(rd \leftarrow rs1 - rs2\) | Float Subtract | R |
fmul.s |
rd, rs1, rs2 |
\(rd \leftarrow rs1 \times rs2\) | Float Multiply | R |
fdiv.s |
rd, rs1, rs2 |
\(rd \leftarrow rs1 / rs2\) | Float Divide | R |
fsqrt.s |
rd, rs1 |
\(rd \leftarrow \sqrt{rs1}\) | Float Square Root | R |
fmin.s |
rd, rs1, rs2 |
\(rd \leftarrow \min(rs1, rs2)\) | Float Minimum | R |
fmax.s |
rd, rs1, rs2 |
\(rd \leftarrow \max(rs1, rs2)\) | Float Maximum | R |
Vegeu RISC-V 5.5.
Comparacions
RISC-V 22: RV32F ISA — Comparacions
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
feq.s |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 = rs2)\ ?\ 1 : 0\) | Float Equal | R |
flt.s |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 < rs2)\ ?\ 1 : 0\) | Float Less Than | R |
fle.s |
rd, rs1, rs2 |
\(rd \leftarrow (rs1 \leq rs2)\ ?\ 1 : 0\) | Float Less or Equal | R |
Vegeu RISC-V 5.7.
Conversions i moviments
RISC-V 23: RV32F ISA — Conversions i moviments
Conversions (amb conversió numèrica):
| Mnemònic | Operands | Operació | Nom |
|---|---|---|---|
fcvt.s.w |
rd, rs1 |
\(rd \leftarrow (float)\ rs1\) | Enter → flotant |
fcvt.s.wu |
rd, rs1 |
\(rd \leftarrow (float)\ rs1\) | Natural → flotant |
fcvt.w.s |
rd, rs1 |
\(rd \leftarrow (int)\ rs1\) | Flotant → enter (arrodoniment segons rm; rtz per a la conversió de tipus de C) |
fcvt.wu.s |
rd, rs1 |
\(rd \leftarrow (unsigned)\ rs1\) | Flotant → natural (arrodoniment segons rm; rtz per a la conversió de tipus de C) |
Moviments (còpia de bits sense conversió numèrica):
| Mnemònic | Operands | Operació | Nom |
|---|---|---|---|
fmv.w.x |
rd, rs1 |
\(rd \leftarrow rs1\) | Enter → flotant (bits) |
fmv.x.w |
rd, rs1 |
\(rd \leftarrow rs1\) | Flotant → enter (bits) |
Vegeu RISC-V 5.8.
Pseudoinstruccions
RISC-V 24: Pseudoinstruccions — Còpia entre registres de coma flotant:
fmv.s
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
fmv.s rd, rs |
\(rd \leftarrow rs\) | fsgnj.s rd, rs, rs |
Vegeu RISC-V 5.6.
Zicsr
Instruccions
RISC-V 25: Zicsr ISA — Instruccions d’accés als CSR
| Mnemònic | Operands | Operació | Nom | Tipus |
|---|---|---|---|---|
csrrw |
rd, csr, rs1 |
\(rd \leftarrow csr; \ csr \leftarrow rs1\) | CSR read/write | I |
csrrs |
rd, csr, rs1 |
\(rd \leftarrow csr; \ csr \leftarrow csr \lor rs1\) | CSR read and set bits | I |
csrrc |
rd, csr, rs1 |
\(rd \leftarrow csr; \ csr \leftarrow csr \land \overline{rs1}\) | CSR read and clear bits | I |
Vegeu RISC-V 9.2.
Pseudoinstruccions
RISC-V 26: Pseudoinstruccions — Accés als CSR:
csrr i csrw
| Pseudoinstrucció | Operació | Expansió |
|---|---|---|
csrr rd, csr |
\(rd \leftarrow csr\) | csrrs rd, csr, zero |
csrw csr, rs |
\(csr \leftarrow rs\) | csrrw zero, csr, rs |
RARS 1.6 espera l’ordre invers dels operands de csrw, csrw rs, csr (csrw t1, fcsr), i no té els CSR de mode M, com mepc.
Vegeu RISC-V 9.3.
Excepcions i interrupcions
Instruccions
RISC-V 27: RV32I ISA —
ecall i ebreak
| Mnemònic | Operands | Operació | Nom |
|---|---|---|---|
ecall |
— | Provoca una excepció (crida al sistema) | Environment call |
ebreak |
— | Provoca una excepció (punt de parada) | Environment break |
Vegeu RISC-V 9.11.
RISC-V 28: RV32I ISA —
mret
| Mnemònic | Operands | Operació | Nom |
|---|---|---|---|
mret |
— | \(MIE \leftarrow MPIE; \ MPIE \leftarrow 1; \ mode \leftarrow MPP; \ MPP \leftarrow U; \ PC \leftarrow mepc\) | Machine return |
Vegeu RISC-V 9.10.
RISC-V 29: Supervisor ISA —
sfence.vma
| Mnemònic | Operands | Operació | Nom |
|---|---|---|---|
sfence.vma |
rs1, rs2 |
Invalida les entrades del TLB per a l’adreça rs1 i l’ASID rs2 (x0 = totes) |
Supervisor fence |
Vegeu RISC-V 9.16.
Registres CSR
RISC-V 30: RV32I ISA —
mcause — Valors més rellevants
| Bit 31 | Codi | Causa |
|---|---|---|
| 0 | 0 | Instrucció mal alineada |
| 0 | 1 | Error d’accés en cerca d’instrucció |
| 0 | 2 | Instrucció il·legal |
| 0 | 3 | Punt de parada (ebreak) |
| 0 | 4 | Lectura de dada mal alineada |
| 0 | 5 | Error d’accés en lectura de dada |
| 0 | 6 | Escriptura de dada mal alineada |
| 0 | 7 | Error d’accés en escriptura de dada |
| 0 | 8 | Crida al sistema des del mode U (ecall) |
| 0 | 9 | Crida al sistema des del mode S (ecall) |
| 0 | 11 | Crida al sistema des del mode M (ecall) |
| 0 | 12 | Fallada de pàgina en cerca d’instrucció |
| 0 | 13 | Fallada de pàgina en lectura |
| 0 | 15 | Fallada de pàgina en escriptura o en una atomic memory operation (AMO) |
| 1 | 3 | Interrupció de programari en mode M |
| 1 | 7 | Interrupció de temporitzador en mode M |
| 1 | 11 | Interrupció externa (E/S) en mode M |
Vegeu RISC-V 9.4.
RISC-V 31: RV32I ISA —
mepc
RISC-V 32: RV32I ISA —
mstatus
RISC-V 33: RV32I ISA —
mtvec
BASE(bits 31:2): adreça base de la rutina o taula de vectors, alineada a 4 bytes.MODE(bits 1:0): mode de funcionament.
RISC-V defineix dos modes:
MODE |
Nom | Comportament |
|---|---|---|
| 0 | Directe | Totes les excepcions i interrupcions salten a BASE |
| 1 | Vectoritzat | Les interrupcions salten a BASE + 4 × causa; les excepcions sempre a BASE |
Vegeu RISC-V 9.7.
RISC-V 34: RV32I ISA —
mip i mie
| Bit | Nom mip |
Nom mie |
Tipus d’interrupció |
|---|---|---|---|
| 11 | MEIP |
MEIE |
Externa (E/S) en mode M |
| 9 | SEIP |
SEIE |
Externa (E/S) en mode S |
| 7 | MTIP |
MTIE |
Temporitzador en mode M |
| 5 | STIP |
STIE |
Temporitzador en mode S |
| 3 | MSIP |
MSIE |
Programari en mode M |
| 1 | SSIP |
SSIE |
Programari en mode S |
Vegeu RISC-V 9.8.
RISC-V 35: RV32I ISA — Registres CSR de mode M i mode S
| Registre mode M | Registre mode S | Funció |
|---|---|---|
mcause |
scause |
Codi de causa de l’excepció o interrupció |
mepc |
sepc |
Adreça de retorn |
mstatus |
sstatus |
Estat global (subconjunt dels bits de mstatus) |
mtvec |
stvec |
Adreça de la rutina de servei |
mip |
sip |
Peticions d’interrupció pendents |
mie |
sie |
Màscares d’interrupció |
Vegeu RISC-V 9.9.
RISC-V 36: RV32I ISA — Registres CSR de memòria virtual
| Registre | Nom complet | Funció |
|---|---|---|
satp |
Supervisor Address Translation and Protection | Mode de traducció i adreça física de la taula de pàgines de primer nivell |
stval |
Supervisor Trap Value | Adreça virtual que ha causat la fallada de pàgina |
Vegeu RISC-V 9.14.
RISC-V 37: RV32I ISA —
satp
RARS
Mapa de memòria
RISC-V 38: RARS — Segments de memòria
| Segment | Tipus | Adreça inicial | Contingut | Creix cap a |
|---|---|---|---|---|
.text |
Estàtic | 0x00400000 |
Codi màquina (instruccions) | — |
.data |
Estàtic | 0x10010000 |
Variables globals | — |
| heap | Dinàmic | 0x10040000 |
Variables dinàmiques (malloc()/free()) |
adreces altes |
| pila (stack) | Dinàmic | 0x7FFFFFFC (sp: 0x7FFFEFFC, RISC-V 3.21) |
Variables locals, registres desats | adreces baixes |
| nucli (kernel) | Estàtic | 0x80000000 |
Codi i dades del sistema operatiu | — |
Vegeu RISC-V 3.15.
Directives
RISC-V 39: Directives — RARS
| Directiva | Operands | Descripció |
|---|---|---|
.align |
k |
Alinea l’element següent a la frontera de \(2^k\) bytes |
.ascii |
"cadena" |
Emmagatzema la cadena al segment de dades sense terminador nul |
.asciz |
"cadena" |
Emmagatzema la cadena al segment de dades amb terminador nul |
.byte |
v1, v2, ... |
Emmagatzema els valors com a bytes de 8 bits |
.data |
— | Els elements següents s’emmagatzemen al segment de dades |
.double |
v1, v2, ... |
Emmagatzema els valors com a nombres en coma flotant de precisió doble |
.dword |
v1, v2, ... |
Emmagatzema els valors com a paraules dobles de 64 bits |
.end_macro |
— | Acaba la definició d’una macro (vegeu Macros) |
.eqv |
símbol, literal |
Substitueix el símbol pel literal. ⚠️ No s’hi admet cap expressió aritmètica ni cap valor negatiu: .eqv T, 5*6*4 dona Invalid language element i .eqv NEG, -4, Malformed .eqv directive. Vegeu EC 2.3. |
.float |
v1, v2, ... |
Emmagatzema els valors com a nombres en coma flotant de precisió simple |
.globl |
etiqueta |
Declara l’etiqueta com a global (també s’accepta .global) |
.half |
v1, v2, ... |
Emmagatzema els valors com a mitges paraules de 16 bits |
.macro |
nom [(%p1, …)] |
Inicia la definició d’una macro, amb els paràmetres opcionals (vegeu Macros) |
.section |
nom |
⚠️ No la useu; useu .data i .text. Amb un nom reconegut (.rodata, .sdata) descarta sense cap avís el codi que la segueix, que no queda assemblat en cap segment. Amb .data o .text com a operand no assembla. Amb un nom desconegut, avisa i no fa res. Vegeu Segments. |
.space |
n |
Reserva n bytes al segment de dades |
.string |
"cadena" |
Àlies de .asciz |
.text |
— | Els elements següents s’emmagatzemen al segment de text |
.word |
v1, v2, ... |
Emmagatzema els valors com a paraules de 32 bits |
Crides al sistema
RISC-V 40: RARS — Registres de crida al sistema
a7: codi de servei.a0: argument principal i valor de retorn.
Vegeu RISC-V 9.12.
RISC-V 41: RARS — Codis de servei més rellevants
| Codi | Nom | Arguments | Retorn |
|---|---|---|---|
| 1 | print_int |
a0 = enter |
— |
| 2 | print_float |
fa0 = flotant |
— |
| 4 | print_string |
a0 = adreça de la cadena |
— |
| 5 | read_int |
— | a0 = enter |
| 6 | read_float |
— | fa0 = flotant |
| 8 | read_string |
a0 = adreça de la memòria intermèdia, a1 = longitud màxima |
— |
| 10 | exit |
— | — |
| 11 | print_char |
a0 = caràcter (ASCII) |
— |
| 12 | read_char |
— | a0 = caràcter (ASCII) |
| 34 | print_hex |
a0 = enter |
— |
| 35 | print_bin |
a0 = enter |
— |
| 36 | print_unsigned |
a0 = natural |
— |
| 93 | exit2 |
a0 = codi de sortida |
— |
Vegeu RISC-V 9.13.