RV32I on Lumenth

RV32I 单周期数据通路

Thu, 24 Sep 2026 00:00:00 +0000

逐指令数据通路说明（配图版）

本文是单周期 RV32I CPU的配套篇：不再用文字画框图，而是逐类说明每条指令的数据通路走向，并标注对应的数据通路图应放在哪里。请将绘制的图片统一放在本目录 Datapath/ 下，文件名按下方标注命名即可直接渲染。

同 opcode 的指令共享同一套数据通路，区别仅在于 ALU 具体运算（由 funct3/funct7 决定）与立即数格式（imm_sel）。因此按 9 类 opcode 组织，每类列出覆盖的全部指令。

公共部分（所有指令共用）

在取指阶段 PC 给出地址从 IMEM 读出 32 位指令；指令字经字段提取得到 opcode / funct3 / funct7 / rs1 / rs2 / rd，其中 opcode/funct3/funct7 送 Control 译码，rs1/rs2 送 RegFile 读端口，rd 作为写回地址。同时 ImmGen 按类型生成符号扩展立即数。执行阶段 ALU 的 A 端由 alu_a_sel 选 rdata1 或 PC，B 端由 alu_src 选 rdata2 或 imm；ALU 输出 alu_result（及 zero 标志）。结果经 WBMUX（wb_sel 选择）写回 RegFile，访存类经 DMEM，下一条 PC 由 pc_next 选择逻辑决定。

1. R-type —— 寄存器-寄存器运算（10 条）

覆盖指令：add sub and or xor sll srl sra slt sltu

数据通路为 RegFile.rdata1 → ALU.A、RegFile.rdata2 → ALU.B（因 alu_src=0，B 端取 rs2）。ALU 运算结果直接经 WBMUX（wb_sel=00）写回 RegFile.rd（reg_write=1）。不经过 DMEM，不改变 PC 流向，PC_next = PC + 4。ALU 运算由 {funct7[5], funct3} 选择：0000 ADD / 1000 SUB / 0111 AND / 0110 OR / 0100 XOR / 0001 SLL / 0101 SRL / 1101 SRA / 0010 SLT / 0011 SLTU。

关键控制信号：reg_write=1, alu_src=0, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=0, imm_sel=000，alu_op根据命令取值

2. I-type —— 寄存器-立即数运算（9 条）

覆盖指令：addi andi ori xori slti sltiu slli srli srai

数据通路与 R-type 几乎一致，唯一区别是 ALU.B 由 alu_src=1 改为取 ImmGen 输出的立即数（rdata2 不再参与）。ALU 结果经 WBMUX（wb_sel=00）写回 rd。不访存，PC_next = PC + 4。ALU 运算由 funct3 选择；slli/srli/srai 移位量来自立即数低 5 位，其中 srli 与 srai 再靠 funct7[5] 区分逻辑/算术右移。注意没有 subi，减法用 addi 传负数实现。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=0, imm_sel=000

3. LOAD —— 从存储器加载（5 条）

覆盖指令：lw lh lb lhu lbu

ALU 计算地址（A=rdata1，B=imm，alu_src=1，即 rs1 + imm），地址送 DMEM；DMEM 在 mem_read=1 时输出 rdata。rdata 经 WBMUX（wb_sel=01，选 MEM）写回 RegFile.rd（reg_write=1）。不写存储器，PC_next = PC + 4。读写宽度/符号扩展由 funct3 决定：000 LB(符号) / 001 LH(符号) / 010 LW / 100 LBU(零扩展) / 101 LHU(零扩展)。

关键控制信号：reg_write=1, alu_src=1, mem_read=1, mem_write=0, branch=0, jump=0, wb_sel=01, alu_a_sel=0, imm_sel=000

4. STORE —— 写入存储器（3 条）

覆盖指令：sw sh sb

ALU 计算地址（rs1 + imm，alu_src=1），地址送 DMEM。待写入的数据来自 rs2（RegFile.rdata2），在 mem_write=1 时写入 DMEM。STORE 不写回寄存器（reg_write=0），也不经过 WBMUX 写回。PC_next = PC + 4。宽度由 funct3 决定：000 SB / 001 SH / 010 SW。画图时注意区分：地址用 rs1，数据是 rs2。

关键控制信号：reg_write=0, alu_src=1, mem_read=0, mem_write=1, branch=0, jump=0, wb_sel=—, alu_a_sel=0, imm_sel=001

5. BRANCH —— 条件分支（6 条）

覆盖指令：beq bne blt bge bltu bgeu

ALU 对 rs1/rs2 做比较（alu_src=0，不访存、不写回）。ALU 输出的 zero 或 result[0] 送「分支判断」逻辑，结合 branch=1 与 funct3 得到 branch_taken。下一条 PC 选择：branch_taken ? PC + imm(B型) : PC + 4。BRANCH 既不写寄存器也不访存。ALU 固定执行减/比较：beq/bne → SUB 看 zero；blt/bge → SLT(有符号)；bltu/bgeu → SLTU(无符号)，由 funct3[2:1] 与 funct3[0] 区分相等/大小比较及是否取反。

关键控制信号：reg_write=0, alu_src=0, mem_read=0, mem_write=0, branch=1, jump=0, wb_sel=—, alu_a_sel=0, imm_sel=010

6. JAL —— 无条件跳转并链接（1 条）

覆盖指令：jal

跳转目标 = PC + imm（J 型立即数），不经过 ALU 做地址运算，直接送「下一条 PC 选择」逻辑（jump=1 → pc_next = PC + imm）。同时 PC + 4 经 WBMUX（wb_sel=10，选 PC+4）写回 RegFile.rd（reg_write=1）作为返回地址。不访存，ALU 在此类指令中可闲置。

关键控制信号：reg_write=1, alu_src=0, mem_read=0, mem_write=0, branch=0, jump=1, wb_sel=10, alu_a_sel=0, imm_sel=100

7. JALR —— 寄存器间接跳转并链接（1 条）

覆盖指令：jalr

文字描述：跳转地址 = rs1 + imm，由 ALU 计算（alu_src=1，A=rdata1，B=imm），结果清最低位（[0]=0）后作为 pc_next（jump=1）。同时 PC + 4 经 WBMUX（wb_sel=10）写回 rd（reg_write=1）作为返回地址。最常用形式 jalr x0, 0(x1) 不保存返回地址（rd=x0）。不访存。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=1, wb_sel=10, alu_a_sel=0, imm_sel=000

8. LUI —— 载入高位立即数（1 条）

覆盖指令：lui

U 型立即数（高 20 位，低 12 位清零）直接经 WBMUX（wb_sel=11，选立即数）写回 RegFile.rd（reg_write=1）。不经过 ALU 运算，也不访存，不访存。PC_next = PC + 4。画图时只需把 ImmGen 输出接到 WBMUX 的 imm 输入端即可。

关键控制信号：reg_write=1, alu_src=—, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=11, alu_a_sel=0, imm_sel=011

9. AUIPC —— 地址无关高位立即数（1 条）

覆盖指令：auipc

文字描述：ALU 的 A 端由 alu_a_sel=1 改为取 PC，B 端由 alu_src=1 取 U 型立即数，执行 ADD 得到 PC + (imm << 12)。结果经 WBMUX（wb_sel=00）写回 RegFile.rd（reg_write=1）。不访存，PC_next = PC + 4。常用于与 jal 配合构造任意 32 位跳转/PC 相对地址。

关键控制信号：reg_write=1, alu_src=1, mem_read=0, mem_write=0, branch=0, jump=0, wb_sel=00, alu_a_sel=1, imm_sel=011

控制信号速查表（9 类汇总，供画图对照）

opcode	类型	reg_write	alu_src	mem_read	mem_write	branch	jump	wb_sel	alu_a_sel	imm_sel
`0110011`	R-type	1	0	0	0	0	0	00	0	—
`0010011`	I-type	1	1	0	0	0	0	00	0	000
`0000011`	LOAD	1	1	1	0	0	0	01	0	000
`0100011`	STORE	0	1	0	1	0	0	—	0	001
`1100011`	BRANCH	0	0	0	0	1	0	—	0	010
`1101111`	JAL	1	0	0	0	0	1	10	0	100
`1100111`	JALR	1	1	0	0	0	1	10	0	000
`0110111`	LUI	1	—	0	0	0	0	11	0	011
`0010111`	AUIPC	1	1	0	0	0	0	00	1	011

该表与单周期 RV32I CPU中 Control 模块的译码表完全一致，可作为画图时每个 MUX 选择位的标注依据。

RV32I单周期CPU

Tue, 08 Sep 2026 00:00:00 +0000

本文介绍单周期RV32I CPU的实现方式

在RV32I指令详解中展示了完整的指令集。本文基于一套可运行的 Verilog 代码，实现一个单周期（Single-Cycle）RV32I 处理器：每一条指令在一个完整时钟周期内完成「取指 → 译码 → 执行 → 访存 → 写回」全过程，因此不存在流水线冒险，也没有数据/控制冒险的问题。

下图为单周期数据通路结构，本项目的模块划分与此一一对应。所有源码均位于此处：

文件	模块	作用
`rtl/core_single_period.v`	core_single_period	顶层模块，组合所有数据通路
`rtl/pc.v`	pc	程序计数器（PC）
`rtl/imem.v`	imem	指令存储器（ROM）
`rtl/control.v`	control	控制单元（译码）
`rtl/regfile.v`	regfile	寄存器堆 x0~x31
`rtl/immgen.v`	immgen	立即数生成器
`rtl/alu.v`	alu	算术逻辑单元
`rtl/dmem.v`	dmem	数据存储器（RAM）
`rtl/program.hex`	—	覆盖全部 37 条 RV32I 指令的测试程序

数据通路整体结构

顶层模块 core_single_period 把各子模块连接起来，形成如下数据流：

PC ──▶ IMEM ──▶ (指令字段提取) ──▶ Control / RegFile / ImmGen
                                        │
                                        ▼
                                     ALU ──▶ DMEM
                                        │        │
                                        ▼        ▼
                                    wb_data 选择  ──▶ RegFile (写回)

首先从指令中提取各字段，供后续模块使用：

wire [6:0] opcode = instr[6:0];
wire [2:0] funct3 = instr[14:12];
wire [6:0] funct7 = instr[31:25];
wire [4:0] rs1    = instr[19:15];
wire [4:0] rs2    = instr[24:20];
wire [4:0] rd     = instr[11:7];

其中 opcode、funct3、funct7 送给控制单元译码，rs1/rs2 作为寄存器堆读地址，rd 作为写回地址。

模块功能介绍

PC —— 程序计数器

pc.v：32 位寄存器，同步复位（低电平有效）。下一拍将 pc_next 写入 pc，pc 作为指令存储器的地址。

module pc (
    input  wire        clk,
    input  wire        rst_n,       // 低电平复位
    input  wire [31:0] pc_next,
    output reg  [31:0] pc
);
    always @(posedge clk) begin
        if (!rst_n) pc <= 32'h0000_0000;
        else     pc <= pc_next;
    end
endmodule

IMEM —— 指令存储器

imem.v：组合逻辑 ROM，按字节寻址，可存 256 条指令（1 KB）。字对齐取指：将字节地址右移 2 位得到字索引。仿真时通过 $readmemh("program.hex", mem) 载入指令。

module imem #(parameter DEPTH = 256) (
    input  wire [31:0] addr,   // PC按字节寻址
    output wire [31:0] instr
);
    reg [31:0] mem [0:DEPTH-1];
    wire [7:0] word_idx = addr[9:2];

    initial $readmemh("program.hex", mem);
    assign instr = mem[word_idx];
endmodule

Control —— 控制单元

control.v：核心译码模块，根据 opcode（以及 funct3、funct7）生成所有控制信号。

信号	位宽	作用
`reg_write`	1	寄存器堆写使能
`alu_src`	1	ALU B 端选择：0=rs2，1=立即数
`mem_read`	1	数据存储器读使能
`mem_write`	1	数据存储器写使能
`branch`	1	是否是分支指令
`jump`	1	是否是跳转指令（JAL/JALR）
`wb_sel`	2	写回数据选择：00=ALU，01=MEM，10=PC+4，11=U型立即数
`alu_a_sel`	1	ALU A 端选择：0=rdata1，1=PC（AUIPC 用）
`alu_op`	4	选择 ALU 具体运算
`imm_sel`	3	立即数格式选择

各 opcode 译码结果如下：

opcode	指令	reg_write	alu_src	mem_read	mem_write	branch	jump	wb_sel	alu_a_sel	imm_sel
`0110011`	R-type	1	0	0	0	0	0	00	0	—
`0010011`	I-type	1	1	0	0	0	0	00	0	000
`0000011`	LOAD	1	1	1	0	0	0	01	0	000
`0100011`	STORE	0	1	0	1	0	0	—	0	001
`1100011`	BRANCH	0	0	0	0	1	0	—	0	010
`1101111`	JAL	1	0	0	0	0	1	10	0	100
`1100111`	JALR	1	1	0	0	0	1	10	0	000
`0110111`	LUI	1	0	0	0	0	0	11	0	011
`0010111`	AUIPC	1	1	0	0	0	0	00	1	011

R 型、算术 I 型指令需要 ALU 完成不同算术逻辑运算，因此译码时结合funct7、funct3产生 ALU 控制信号，选择对应的运算功能；

B 类分支指令 ALU 固定执行rs1−rs2比较操作，ALU 运算功能无需更改，funct3仅用于判别比较结果、决定是否发生分支跳转。

R-type 指令根据 {funct7[5], funct3} 进一步区分运算：

case({funct7[5],funct3})
    4'b0000: alu_op=4'b0000; // ADD
    4'b1000: alu_op=4'b0001; // SUB
    4'b0111: alu_op=4'b0010; // AND
    4'b0110: alu_op=4'b0011; // OR
    4'b0100: alu_op=4'b0100; // XOR
    4'b0010: alu_op=4'b0101; // SLT
    4'b0011: alu_op=4'b0110; // SLTU
    4'b0001: alu_op=4'b0111; // SLL
    4'b0101: alu_op=4'b1000; // SRL
    4'b1101: alu_op=4'b1001; // SRA
endcase

I-type指令根据 funct3 进一步区分运算：

case(funct3)
  3'h0: alu_op=4'b0000; // ADDI
  3'h7: alu_op=4'b0010; // ANDI
  3'h6: alu_op=4'b0011; // ORI
  3'h4: alu_op=4'b0100; // XORI
  3'h2: alu_op=4'b0101; // SLTI
  3'h3: alu_op=4'b0110; // SLTIU
  3'h1: alu_op=4'b0111; // SLLI
  3'h5: alu_op=(funct7[5])?4'b1001:4'b1000; // SRAI/SRLI
  default: alu_op=4'b0000;
endcase

B-type指令根据 funct3 进一步区分运算：

case(funct3)
    3'h0,3'h1: alu_op=4'b0001; // BEQ/BNE: SUB
    3'h4,3'h5: alu_op=4'b0101; // BLT/BGE: SLT
    3'h6,3'h7: alu_op=4'b0110; // BLTU/BGEU: SLTU
    default:   alu_op=4'b0001;
endcase end

RegFile —— 寄存器堆

regfile.v：32 × 32-bit，2 个异步读端口、1 个同步写端口。x0 恒为 0，写入 x0 被忽略，读取 x0 也始终返回 0。

module regfile (
    input  wire        clk,
    input  wire        we,
    input  wire [4:0]  waddr,
    input  wire [31:0] wdata,
    input  wire [4:0]  raddr1,
    output wire [31:0] rdata1,
    input  wire [4:0]  raddr2,
    output wire [31:0] rdata2
);
    reg [31:0] regs [0:31];
    integer i;
    initial for(i=0;i<32;i=i+1) regs[i]=32'b0;

    always @(posedge clk)
        if (we && waddr != 5'd0) regs[waddr] <= wdata;

    assign rdata1 = (raddr1 == 5'd0) ? 32'd0 : regs[raddr1];
    assign rdata2 = (raddr2 == 5'd0) ? 32'd0 : regs[raddr2];
endmodule

ImmGen —— 立即数生成器

immgen.v：按指令类型从指令中提取立即数并做符号扩展。imm_sel 的映射关系为 000=I, 001=S, 010=B, 011=U, 100=J。

always @(*) begin
    case (imm_sel)
        3'b000: imm = {{20{instr[31]}}, instr[31:20]};              // I
        3'b001: imm = {{20{instr[31]}}, instr[31:25], instr[11:7]}; // S
        3'b010: imm = {{19{instr[31]}}, instr[31], instr[7],
                       instr[30:25], instr[11:8], 1'b0};            // B
        3'b011: imm = {instr[31:12], 12'b0};                        // U
        3'b100: imm = {{11{instr[31]}}, instr[31], instr[19:12],
                       instr[20], instr[30:21], 1'b0};              // J
        default: imm = 32'd0;
    endcase
end

各格式立即数的位序对照（均以 instr[31] 符号位扩展）：

类型	立即数构成
I	`imm[11:0] = instr[31:20]`，符号扩展
S	`imm[11:5] = instr[31:25]`，`imm[4:0] = instr[11:7]`，符号扩展
B	`imm[12] = instr[31]`，`imm[11] = instr[7]`，`imm[10:5] = instr[30:25]`，`imm[4:1] = instr[11:8]`，`imm[0]=0`，符号扩展
U	`imm[31:12] = instr[31:12]`，低 12 位清零
J	`imm[20] = instr[31]`，`imm[19:12] = instr[19:12]`，`imm[11] = instr[20]`，`imm[10:1] = instr[30:21]`，`imm[0]=0`，符号扩展

ALU —— 算术逻辑单元

alu.v：支持 10 种运算，输出 result 和 zero（结果为 0 时置 1，供分支指令判断）。移位量取自 B 端低 5 位 shamt = b[4:0]。

alu_op	运算	说明
`0000`	`a + b`	ADD / ADDI
`0001`	`a - b`	SUB
`0010`	`a & b`	AND
`0011`	`a \| b`	OR
`0100`	`a ^ b`	XOR
`0101`	`$signed(a) < $signed(b)`	SLT（有符号）
`0110`	`a < b`	SLTU（无符号）
`0111`	`a << shamt`	SLL
`1000`	`a >> shamt`	SRL
`1001`	`$signed(a) >>> shamt`	SRA（算术右移）

module alu (
    input  wire [31:0] a,        // 操作数A (rs1)
    input  wire [31:0] b,        // 操作数B (rs2 or imm)
    input  wire [3:0]  alu_op,   // 选择操作
    output reg  [31:0] result,   // 计算结果
    output wire        zero      // 结果为0时置1(分支指令使用)
);
    wire [4:0] shamt = b[4:0];   // 移位的量为B的低5位

    always @(*) begin
        case (alu_op)
            4'b0000: result = a + b;                          // ADD
            4'b0001: result = a - b;                          // SUB
            4'b0010: result = a & b;                          // AND
            4'b0011: result = a | b;                          // OR
            4'b0100: result = a ^ b;                          // XOR
            4'b0101: result = ($signed(a) < $signed(b)) ? 32'd1 : 32'd0; // SLT
            4'b0110: result = (a < b)                 ? 32'd1 : 32'd0; // SLTU
            4'b0111: result = a << shamt;                     // SLL
            4'b1000: result = a >> shamt;                     // SRL
            4'b1001: result = $signed(a) >>> shamt;           // SRA
            default: result = 32'd0;
        endcase
    end

    assign zero = (result == 32'd0);
endmodule

DMEM —— 数据存储器

dmem.v：256 × 32-bit（1 KB），同步写、组合逻辑读，支持字节/半字/字三种读写宽度。

mem_read：读使能，来自控制单元（仅 load 指令为 1）；为 0 时 rdata 输出 0；
mem_width：00=字节, 01=半字, 10=字，来自 funct3[1:0]；
mem_sign：加载时是否符号扩展，来自 !funct3[2]（funct3[2]=0 表示有符号）；
字节内偏移 byte_off = addr[1:0]，用于确定字节/半字在字内的位置。

always @(posedge clk) begin
    if (we) begin
        case (mem_width)
            2'b00: begin  // SB
                case (byte_off)
                    2'b00: mem[word_idx][7:0]   <= wdata[7:0];
                    2'b01: mem[word_idx][15:8]  <= wdata[7:0];
                    2'b10: mem[word_idx][23:16] <= wdata[7:0];
                    2'b11: mem[word_idx][31:24] <= wdata[7:0];
                endcase
            end
            2'b01: begin  // SH
                if (byte_off[1]) mem[word_idx][31:16] <= wdata[15:0];
                else             mem[word_idx][15:0]  <= wdata[15:0];
            end
            2'b10: mem[word_idx] <= wdata;  // SW
        endcase
    end
end

读取端根据 mem_read、mem_width 和 mem_sign 生成 rdata（mem_read=0 时输出 0，避免非 load 指令读到无意义的数据）：

wire [31:0] rdata_b = mem_sign ? {{24{b[7]}}, b}        : {24'd0, b};    // LB / LBU
wire [31:0] rdata_h = mem_sign ? {{16{half[15]}}, half} : {16'd0, half}; // LH / LHU
wire [31:0] rdata_w = word;                                               // LW

// 读使能门控
assign rdata = mem_read ? ((mem_width == 2'b00) ? rdata_b :
                           (mem_width == 2'b01) ? rdata_h : rdata_w)
                        : 32'd0;

ALU 输入与写回数据选择

在顶层 core_single_period 中，ALU 的两个操作数由控制信号二选一：

1
2

wire [31:0] alu_a = alu_a_sel ? pc : rdata1;   // AUIPC 用 PC, 其余用 rs1
wire [31:0] alu_b = alu_src  ? imm : rdata2;   // I-type/load/store 用 imm, R-type 用 rs2

写回寄存器数据由 wb_sel 从四个来源中选择：

assign wb_data = (wb_sel == 2'b00) ? alu_result :
                 (wb_sel == 2'b01) ? mem_rdata  :
                 (wb_sel == 2'b10) ? (pc + 32'd4):
                                     imm;        // 2'b11: U-type immediate

分支 / 跳转 / 下一 PC

分支判断利用了 ALU 输出的 zero 和 result[0]。funct3[2:1] 区分相等比较与大小比较，funct3[0] 区分是否取反：

// funct3[2:1]: 00=BEQ/BNE(看zero), 10/11=BLT/BGE/BLTU/BGEU(看result[0])
// funct3[0]:   0=相等/小于时跳转, 1=不等/不小于时跳转
wire branch_cond = (funct3[2:1] == 2'b00) ? (funct3[0] ^ alu_zero)
                                          : (funct3[0] ^ alu_result[0]);
wire branch_taken = branch && branch_cond;

数据存储器地址与写使能：

1
2

wire [1:0] mem_width = funct3[1:0];   // 00=byte, 01=half, 10=word
wire       mem_sign  = !funct3[2];    // 0=unsigned, 1=signed

最后一拍根据 jump、alu_src、branch_taken 计算 pc_next：

wire [31:0] pc_plus_4 = pc + 32'd4;
wire [31:0] pc_branch = pc + imm;                 // B-type / J-type
wire [31:0] pc_jalr   = {alu_result[31:1], 1'b0}; // JALR 清最低位

// JAL: alu_src=0 → 用 PC+imm;  JALR: alu_src=1 → 用 ALU 结果
assign pc_next = jump      ? (alu_src ? pc_jalr : pc_branch) :
                 branch_taken ? pc_branch :
                 pc_plus_4;

测试程序

rtl/program.hex 是一条覆盖本处理器所支持的全部 37 条 RV32I 数据通路指令的测试程序（不含 FENCE/ECALL/EBREAK 等系统指令），包含 R-type ×10、I-type ALU ×9、LOAD ×5、STORE ×3、BRANCH ×6、JAL、JALR、LUI、AUIPC。由于是单周期实现，不存在冒险，可直接顺序验证。

部分测试片段：

// 初始化 x5=10, x6=7, x7=-1
00A00293   // PC=0x00  ADDI x5,  x0, 10   | x5  = 10
00700313   // PC=0x04  ADDI x6,  x0, 7    | x6  = 7
FFF00393   // PC=0x08  ADDI x7,  x0, -1   | x7  = -1 = 0xFFFFFFFF

// R-type
00628433   // PC=0x10  ADD  x8,  x5, x6   | x8  = 17
406284B3   // PC=0x14  SUB  x9,  x5, x6   | x9  = 3

// STORE / LOAD
008A2023   // PC=0x70  SW   x8,  0(x20)   | mem[0x50] = 40
000A2E83   // PC=0x7C  LW   x29, 0(x20)   | x29 = 40

// 停机：BEQ x0,x0,0 进入无限循环
00000063   // PC=0xFC  BEQ  x0,  x0,  0

完整测试程序细节可查看 rtl/program.hex 文件中的注释。

小结

通过这套单周期 RV32I 实现，可以看到处理器的基本骨架：取指（PC+IMEM）→ 译码（Control）→ 执行（ALU）→ 访存（DMEM）→ 写回（RegFile）。单周期实现结构简单、无冒险，但每个时钟周期都要走完最长路径（寄存器堆读出 → ALU → 访存 → 写回），时钟频率因此受限；实际处理器多在此基础上加入流水线，把执行拆成多个流水级来提升吞吐率。极度建议自己在数据通路图中标注信号，逐条跑一下各类指令加深理解。

RV32I指令详解

Tue, 28 Jul 2026 00:00:00 +0000

本文介绍完整的Risc-V指令集

文章内容基于该网站教学。

整套RV32I基础指令集仅需大约40多条指令，也是处理器必须识别的全部 “指令词汇”。这些指令可划归为下面这几大类：

依次为算术与逻辑运算指令、立即数运算指令、加载/存储指令、分支指令、跳转指令、高位立即数指令、系统类指令。

算术与逻辑运算（寄存器 - 寄存器型）——R-type指令（10条）

选取两个寄存器中的数据执行运算操作，并存储运算结果。这类指令是处理器最常用的基础指令：

指令	含义
add / sub	rd = rs1 + rs2 / rd = rs1 − rs2
and / or / xor	按位与 / 按位或 / 按位异或
sll / srl / sra	逻辑左移 / 逻辑右移 / 算术右移（保留符号位）
slt / sltu	（对应有符号/无符号）rd = （rs1 < rs2） ? 1 : 0

# 用法
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
slt rd, rs1, rs2  表示 rd = (rs1 < rs2) ? 1 : 0
sltu rd, rs1, rs2  表示 rd = (rs1 < rs2) ? 1 : 0

算术与逻辑运算（寄存器 - 立即数型）（9条）

指令	含义
addi	rd = rs1 + 立即数 (不存在 “立即数减法 subi” 指令，只需传入负数即可实现减法)
andi / ori / xori	与常量按位与 / 按位或 / 按位异或
slli / srli / srai	逻辑左移 / 逻辑右移 / 算术右移常量位
slti / sltiu	（对应有符号/无符号）rd = （rs1 < 立即数） ? 1 : 0

#用法
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, imm  表示 rd = rs1 << imm
srli rd, rs1, imm  表示 rd = rs1 >> imm
srai rd, rs1, imm  表示 rd = rs1 >>> imm
slti rd, rs1, imm  表示 rd = (rs1 < imm) ? 1 : 0
sltiu rd, rs1, imm  表示 rd = (rs1 < imm) ? 1 : 0

与存储器交互（8条）

指令	含义
lw	将内存中的一个32位字加载至目标寄存器rd
lh / lb	加载半字（16位）/字节（8位）到rd（带符号位扩展）
lhu / lbu	加载半字/字节数据到rd，（无符号位零扩展）
sw / sh / sb	将寄存器rs2中的字数据/半字数据/字节数据存入存储器

# 用法
lw rd, imm(rs1)  表示 rd = MEM[rs1 + imm]
lh rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展符号位）
lb rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展符号位）
lhu rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展0）
lbu rd, imm(rs1)  表示 rd = MEM[rs1 + imm]（高位扩展0）
sw rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2
sh rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2的低 16 位
sb rs2, imm(rs1)  表示 MEM[rs1 + imm] = rs2的低 8 位

分支指令（6条）

CPU执行“if（条件判断）”语句：分支指令会对比两个寄存器的值，仅当判定条件成立时才执行跳转操作，若条件不成立，程序则直接顺序向下执行。

指令	表达式（成立则跳转）
beq / bne	rs1 == rs2 / rs1 != rs2
blt / bge	rs1 < rs2 / rs1 ≥ rs2 (有符号数)
bltu / bgeu	rs1 < rs2 / rs1 ≥ rs2 (无符号数)

# 用法
beq rs1, rs2, imm  表示 if (rs1 == rs2) 跳转到 PC + 偏移地址
bne rs1, rs2, imm  表示 if (rs1 != rs2) 跳转到 PC + 偏移地址
blt rs1, rs2, imm  表示 if (rs1 < rs2) 跳转到 PC + 偏移地址
bge rs1, rs2, imm  表示 if (rs1 >= rs2) 跳转到 PC + 偏移地址
bltu rs1, rs2, imm  表示 if (rs1 < rs2) 跳转到 PC + 偏移地址
bgeu rs1, rs2, imm  表示 if (rs1 >= rs2) 跳转到 PC + 偏移地址

高位立即数指令（2条）

指令	含义
lui	把指令内的20位立即数放置到寄存器高20位，寄存器低12位清零。
auipc	20位立即数左移12位后与当前PC值相加，结果存入目标寄存器；常用于生成PC相对地址，实现位置无关寻址

1
2
3

# 用法
lui rd, imm  表示 rd = imm << 12
auipc rd, imm  表示 rd = (imm << 12) + PC

跳转指令（2条）

指令	含义
jal	Jump and link，PC 相对跳转。跳转目标 = PC + 符号扩展后的立即数，自动把当前 PC+4（下一条指令地址）写入 rd 寄存器，主要用于函数调用
jalr	寄存器间接跳转。跳转地址由「rs1 寄存器值 + 12 位符号扩展立即数」给出，同样会将 PC+4 存入 rd；最常用格式 jalr x0,0(x1) 实现函数返回，也可用于动态计算地址跳转

1
2
3

# 用法
jal rd, imm  表示 PC = PC + imm，rd = PC_old + 4
jalr rd, imm(rs1)  表示 PC = rs1 + imm，rd = PC_old + 4

伪指令

伪指令没有对应的独立机器码，汇编器在编译阶段，会自动把一条伪指令翻译成一条或多条真实硬件指令执行。只是为了编写汇编代码更简洁、好理解。

伪指令	翻译后指令	补充说明
li rd, 5	addi rd, x0, 5	12位范围内小立即数赋值；32位大数会编译为 lui + addi 组合
mv rd, rs	addi rd, rs, 0	复制寄存器
nop	addi x0, x0, 0	不做任何操作
j label	jal x0, label	跳转不保存返回地址
ret	jalr x0, 0(x1)	在跳转操作后，返回x1寄存器内的返回地址

特殊指令（10条）

CSR（控制状态寄存器）属于独立硬件寄存器组，和通用寄存器 x0~x31 物理分离，仅能使用以上 CSR 专用指令访问，普通运算指令无法读写。

指令	含义
ecall	环境调用，触发系统调用异常，向内核申请服务
ebreak	断点指令，触发调试异常，用于 GDB 程序调试暂停
fence	数据内存屏障，管控 Load/Store 访存乱序
fence.i	指令流水线屏障，清空指令缓存、刷新指令流
csrrw	CSR 读写：读出旧值到 rd，写入 rs 数据至 CSR
csrrs	CSR 读置位：读出旧值到 rd，使用 rs 按位或置 1 寄存器 bit
csrrc	CSR 读清零：读出旧值到 rd，使用 rs 按位与清零寄存器 bit
csrrwi	csrrw 立即数版本，使用 5 位立即数写入 CSR
csrrsi	csrrs 立即数版本，使用立即数做按位置位
csrrci	csrrc 立即数版本，使用立即数做按位清零

# 用法
ecall        # 发起系统调用
ebreak       # 触发调试断点异常
fence        # 数据内存屏障
fence.i      # 指令流水线刷新屏障
csrrw rd, csr, rs1  表示 rd = csr，csr = rs1
csrrs rd, csr, rs1  表示 rd = csr，csr = csr | rs1
csrrc rd, csr, rs1  表示 rd = csr，csr = csr & ~rs1
csrrwi rd, csr, imm  表示 rd = csr，csr = imm
csrrsi rd, csr, imm  表示 rd = csr，csr = csr | imm
csrrci rd, csr, imm  表示 rd = csr，csr = csr & ~imm