Skip to content
shug的笔记集合

RISCV32

RISC-V 是一种开源的指令集架构，由加州大学伯克利分校的计算机科学家开发。与其他专有架构（如 ARM 或 x86）不同，RISC-V 完全开源，允许任何人使用、修改和扩展。

复位

RISC-V 32

在 RISC-V 32位架构中，处理器在复位后会从一个预定义的启动地址开始执行第一条指令。这个启动地址通常是硬编码的，通常为0x00000000 或 0xFFFFFFF0。复位后的第一条指令通常是用于初始化系统的引导加载程序（Bootloader）的开始。

RISC-V 64

在 RISC-V 64位架构（riscv64）中，处理器在复位后会从一个预定义的启动地址开始执行第一条指令。这个启动地址通常是硬编码的，通常为0x00000000或其他设计者指定的地址。

架构

RISC-V 指令集架构（ISA）是一个模块化和可扩展的指令集，设计上分为基础指令集和多个标准扩展。以下是 RISC-V 指令集各部分的详细说明：

基础指令集

RV32I 和 RV64I

  • RV32I：32位整数基本指令集，是所有 RISC-V 实现的基础，包含基本的算术、逻辑、控制流和内存访问指令。
  • RV64I：64位整数基本指令集，类似于 RV32I，但寄存器和操作数是64位宽。

基础指令分类

  • 算术指令：ADD, SUB, ADDI 等。
  • 逻辑指令：AND, OR, XOR, ANDI 等。
  • 移位指令：SLL, SRL, SRA, SLLI, SRLI, SRAI 等。
  • 比较指令：SLT, SLTI, SLTU, SLTIU 等。
  • 内存访问指令：LW, SW, LB, SB, LH, SH, LBU, LHU 等。
  • 控制流指令：JAL, JALR, BEQ, BNE, BLT, BGE, BLTU, BGEU 等。
  • 系统指令：ECALL, EBREAK 等。

标准扩展

M扩展（整数乘除扩展）

  • 提供乘法和除法指令，例如 MUL, MULH, DIV, DIVU, REM, REMU。

A扩展（原子操作扩展）

  • 支持原子读-修改-写指令，用于多处理器同步，例如 LR.W, SC.W, AMOSWAP.W, AMOADD.W 等。

F扩展（单精度浮点扩展）

  • 支持 IEEE 754 单精度浮点运算指令，例如 FADD.S, FSUB.S, FMUL.S, FDIV.S, FSQRT.S, FMIN.S, FMAX.S 等。

D扩展（双精度浮点扩展）

  • 支持 IEEE 754 双精度浮点运算指令，例如 FADD.D, FSUB.D, FMUL.D, FDIV.D, FSQRT.D, FMIN.D, FMAX.D 等。

Q扩展（四倍精度浮点扩展）

  • 支持 IEEE 754 四倍精度浮点运算指令。

C扩展（压缩指令集扩展）

  • 提供 16 位压缩指令，减少程序的内存占用，例如 C.ADDI, C.LW, C.SW, C.JAL, C.JR 等。

B扩展（位操作扩展）

  • 提供位操作指令，例如 ANDN, ORN, XNOR, CLZ, CTZ, CPOP, SEXT.B, SEXT.H, ROL, ROR 等。

J扩展（动态可插拔指令扩展）

  • 支持动态可插拔指令。

H扩展（硬件线程扩展）

  • 提供硬件线程管理指令。

独立的小扩展

Z扩展

  • 用于独立的小扩展，如：
    • Zifencei：指令流 FENCE 扩展，用于确保指令流的一致性。
    • Zicsr：控制状态寄存器扩展，提供对 CSR 的访问指令。

特殊用途指令

特殊用途寄存器指令

  • CSRRW：控制状态寄存器读写。
  • CSRRS：控制状态寄存器读并设置。
  • CSRRC：控制状态寄存器读并清除。

示例代码

以下是一个使用多种 RISC-V 指令的示例程序：

.section .data
num1:   .dword 5       // 定义第一个数
num2:   .dword 10      // 定义第二个数


.section .text
.globl _start
_start:
    li t0, 10          // 将立即数 10 加载到临时寄存器 t0
    li t1, 20          // 将立即数 20 加载到临时寄存器 t1
    add t2, t0, t1     // 将 t0 和 t1 相加，结果存储在 t2
    mv a0, t2          // 将 t2 的值复制到 a0


    // 浮点运算示例
    fmv.s.x ft0, t0    // 将整数 t0 转换为单精度浮点数
    fadd.s ft1, ft0, ft0 // 将两个单精度浮点数相加


    // 原子操作示例
    li t3, 1           // 将 1 加载到 t3
    amoswap.w.aq t4, t3, (t0) // 交换 t0 地址处的值与 t3


    // 退出程序（假设在一个支持的模拟器或操作系统中运行）
    li a7, 93          // ecall 退出系统调用号（Linux）
    ecall              // 执行系统调用

寄存器

RISC-V 32位架构（riscv32）有32个通用寄存器，每个寄存器都是32位宽。每个寄存器都有特定的用途和惯例名称，以便在汇编编程中使用。以下是 riscv32 寄存器的详细信息：

通用寄存器

RISC-V 的通用寄存器由 x0 到 x31 表示，使用惯例名称以帮助识别其典型用途。

  1. x0 (zero)：值永远为 0，读写该寄存器不会改变它的值。
  2. x1 (ra, return address)：存储函数返回地址。
  3. x2 (sp, stack pointer)：指向当前栈顶，用于栈操作。
  4. x3 (gp, global pointer)：全局指针，用于全局数据访问。
  5. x4 (tp, thread pointer)：线程指针，用于线程局部存储。
  6. x5-x7 (t0-t2, temporary registers)：临时寄存器，在函数调用过程中不需要保存。
  7. x8 (s0/fp, saved register/frame pointer)：保存寄存器/帧指针，在函数调用过程中需要保存。
  8. x9 (s1, saved register)：保存寄存器，在函数调用过程中需要保存。
  9. x10-x11 (a0-a1, function arguments/return values)：函数参数和返回值寄存器。
  10. x12-x17 (a2-a7, function arguments)：函数参数寄存器。
  11. x18-x27 (s2-s11, saved registers)：保存寄存器，在函数调用过程中需要保存。
  12. x28-x31 (t3-t6, temporary registers)：临时寄存器，在函数调用过程中不需要保存。

寄存器用途和描述

寄存器名称用途
x0zero常值 0
x1ra返回地址
x2sp栈指针
x3gp全局指针
x4tp线程指针
x5t0临时寄存器
x6t1临时寄存器
x7t2临时寄存器
x8s0/fp保存寄存器/帧指针
x9s1保存寄存器
x10a0函数参数/返回值
x11a1函数参数/返回值
x12a2函数参数
x13a3函数参数
x14a4函数参数
x15a5函数参数
x16a6函数参数
x17a7函数参数
x18s2保存寄存器
x19s3保存寄存器
x20s4保存寄存器
x21s5保存寄存器
x22s6保存寄存器
x23s7保存寄存器
x24s8保存寄存器
x25s9保存寄存器
x26s10保存寄存器
x27s11保存寄存器
x28t3临时寄存器
x29t4临时寄存器
x30t5临时寄存器
x31t6临时寄存器

示例代码

以下是一个简单的 RISC-V 汇编程序，演示了如何使用这些寄存器来进行基本运算：

.section .data
num1:   .word 5       // 定义第一个数
num2:   .word 10      // 定义第二个数


.section .text
.globl _start
_start:
    lw x10, num1       // 将 num1 加载到寄存器 a0 (x10)
    lw x11, num2       // 将 num2 加载到寄存器 a1 (x11)
    add x12, x10, x11  // 将 a0 和 a1 相加，结果存储在 x12
    // 这里假设程序到此结束
    // 通常你会需要一个系统调用来退出程序，但这是一个简单示例

指令

RISC-V 32位架构（RV32）的指令集设计简洁、模块化，包含了各种基础指令以及可选的扩展指令。以下是 RISC-V 32位架构的基本指令集（RV32I）的一些常见指令和说明：

指令格式

RISC-V 的指令格式分为以下几种主要类型：

  1. R型指令：用于寄存器到寄存器的运算。
  2. I型指令：用于立即数运算和内存加载。
  3. S型指令：用于内存存储。
  4. B型指令：用于条件分支。
  5. U型指令：用于加载高位立即数。
  6. J型指令：用于跳转。

R型指令

R型指令用于寄存器之间的算术和逻辑运算。格式如下：

opcode | rd | funct3 | rs1 | rs2 | funct7
  • rd：目标寄存器。
  • rs1：第一个源寄存器。
  • rs2：第二个源寄存器。
  • funct3 和 funct7：指定具体操作。

常见 R型指令：

add  rd, rs1, rs2  // rd = rs1 + rs2
sub  rd, rs1, rs2  // rd = rs1 - rs2
and  rd, rs1, rs2  // rd = rs1 & rs2
or   rd, rs1, rs2  // rd = rs1 | rs2
xor  rd, rs1, rs2  // rd = rs1 ^ rs2
sll  rd, rs1, rs2  // rd = rs1 << rs2 (逻辑左移)
srl  rd, rs1, rs2  // rd = rs1 >> rs2 (逻辑右移)
sra  rd, rs1, rs2  // rd = rs1 >>> rs2 (算术右移)

I型指令

I型指令用于立即数运算和内存加载。格式如下：

opcode | rd | funct3 | rs1 | imm
  • imm：立即数。

常见 I型指令：

addi  rd, rs1, imm   // rd = rs1 + imm
andi  rd, rs1, imm   // rd = rs1 & imm
ori   rd, rs1, imm   // rd = rs1 | imm
xori  rd, rs1, imm   // rd = rs1 ^ imm
slli  rd, rs1, shamt // rd = rs1 << shamt (逻辑左移)
srli  rd, rs1, shamt // rd = rs1 >> shamt (逻辑右移)
srai  rd, rs1, shamt // rd = rs1 >>> shamt (算术右移)
lw    rd, imm(rs1)   // 从内存地址rs1+imm加载字到rd
lb    rd, imm(rs1)   // 从内存地址rs1+imm加载字节到rd
lh    rd, imm(rs1)   // 从内存地址rs1+imm加载半字到rd

S型指令

S型指令用于内存存储。格式如下：

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

常见 S型指令：

sw  rs2, imm(rs1)  // 将rs2存储到内存地址rs1+imm
sb  rs2, imm(rs1)  // 将rs2的低8位存储到内存地址rs1+imm
sh  rs2, imm(rs1)  // 将rs2的低16位存储到内存地址rs1+imm

B型指令

B型指令用于条件分支。格式如下：

opcode | imm[12] | imm[10:5] | rs2 | rs1 | funct3 | imm[4:1] | imm[11]

常见 B型指令：

beq   rs1, rs2, offset  // 如果rs1 == rs2，则跳转到当前地址加上offset
bne   rs1, rs2, offset  // 如果rs1 != rs2，则跳转到当前地址加上offset
blt   rs1, rs2, offset  // 如果rs1 < rs2，则跳转到当前地址加上offset
bge   rs1, rs2, offset  // 如果rs1 >= rs2，则跳转到当前地址加上offset

U型指令

U型指令用于加载高位立即数。格式如下：

opcode | rd | imm

常见 U型指令：

lui  rd, imm  // 将imm加载到rd的高20位
auipc rd, imm // 将PC+imm加载到rd的高20位

J型指令

J型指令用于跳转。格式如下：

opcode | rd | imm

常见 J型指令：

jal  rd, offset  // 跳转到当前地址加上offset，并将返回地址存储到rd
jalr rd, imm(rs1) // 跳转到rs1+imm，并将返回地址存储到rd

特殊指令

RISC-V 还有一些特殊指令，例如用于系统调用和控制寄存器的指令：

ecall  // 环境调用，用于系统调用
ebreak // 环境断点，用于调试
csrrw  rd, csr, rs1 // 读写控制状态寄存器
csrrs  rd, csr, rs1 // 读并设置控制状态寄存器
csrrc  rd, csr, rs1 // 读并清除控制状态寄存器

示例代码

下面是一个简单的 RISC-V 汇编程序示例，它实现了两个数的加法并将结果存储在一个寄存器中：

.section .data
num1:   .word 5       // 定义第一个数
num2:   .word 10      // 定义第二个数


.section .text
.globl _start
_start:
    lw x10, num1       // 加载num1到寄存器x10
    lw x11, num2       // 加载num2到寄存器x11
    add x12, x10, x11  // 将x10和x11相加，结果存储到x12


    // 退出程序（假设在一个支持的模拟器或操作系统中运行）
    li a7, 93          // ecall退出系统调用号（Linux）
    ecall              // 执行系统调用

伪指令

RISC-V 伪指令（Pseudo Instructions）是一种便于编程的汇编指令，它们不是直接在硬件上执行的指令，而是由汇编器（Assembler）翻译成一个或多个实际的机器指令。伪指令简化了汇编编程，使代码更易读、易写。以下是一些常见的 RISC-V 32位伪指令及其等效的真实指令：

常见伪指令及其等效指令

  1. li rd, imm（加载立即数）

    • 加载一个立即数到寄存器 rd。
    • 等效指令： 
      li rd, imm    // 当 imm 可以用 12 位表示时
      或 
      lui rd, imm[31:12]
      addi rd, rd, imm[11:0]

  2. mv rd, rs（寄存器间移动）

    • 将寄存器 rs 的值复制到寄存器 rd。
    • 等效指令： 
      addi rd, rs, 0

  3. nop（空操作）

    • 不执行任何操作。
    • 等效指令： 
      addi x0, x0, 0

  4. j offset（无条件跳转）

    • 跳转到当前地址加上偏移量 offset。
    • 等效指令： 
      jal x0, offset

  5. jr rs（寄存器无条件跳转）

    • 跳转到寄存器 rs 所指向的地址。
    • 等效指令： 
      jalr x0, 0(rs)

  6. ret（返回）

    • 从子程序返回。
    • 等效指令： 
      jalr x0, 0(ra)

  7. call label（调用子程序）

    • 调用子程序并保存返回地址。
    • 等效指令： 
      auipc ra, %pcrel_hi(label)
      jalr ra, %pcrel_lo(label)(ra)

  8. tail label（尾调用）

    • 跳转到子程序，不保存返回地址。
    • 等效指令： 
      auipc x0, %pcrel_hi(label)
      jalr x0, %pcrel_lo(label)(x0)

  9. la(加载地址)

    • 加载符号的地址

示例代码

以下是一个使用伪指令的简单 RISC-V 汇编程序示例：

.section .text
.globl _start
_start:
    li t0, 10       // 将立即数 10 加载到临时寄存器 t0
    li t1, 20       // 将立即数 20 加载到临时寄存器 t1
    add t2, t0, t1  // 将 t0 和 t1 相加，结果存储在 t2
    mv a0, t2       // 将 t2 的值复制到 a0


    // 退出程序（假设在一个支持的模拟器或操作系统中运行）
    li a7, 93       // ecall退出系统调用号（Linux）
    ecall           // 执行系统调用

在这个示例中，伪指令 li 和 mv 被使用来简化代码的编写和阅读。

测试环境

需要的软件

  • qemu
  • gcc
  • gdb-multiarch

main.c

#define UART_BASE 0x10000000  // UART 基地址


volatile char *uart = (volatile char *)UART_BASE;


void uart_putc(char c) {
    *(volatile char *)uart = c;
}


void uart_puts(const char *s) {
    while (*s) {
        uart_putc(*s++);
    }
}


void main() {
    uart_puts("Hello, RISC-V!\n");
    while (1); // 无限循环，防止程序退出
}

start.s

.section .text
.global _start


_start:
    la sp, stack_top     # 设置栈指针
    call main            # 调用 main 函数
    nop                  # 如果 main 返回，停在这里


.section .bss
    .align 12
    .space 4096          # 定义一个简单的栈
stack_top:

编译

Terminal window
riscv64-linux-gnu-gcc -g -nostdlib -Ttext=0x80000000 -no-pie -o hello.elf start.s main.c

在qemu中运行

Terminal window
qemu-system-riscv64 -nographic -machine virt -bios none -serial mon:stdio -S -s -kernel hello.elf -S -s

.gdbinit

target remote :1234
Terminal window
gdb-multiarch -x .gdbinit hello.elf