一、实验目标

了解RISC-V mini处理器架构，在其基础之上新增一个指令，完成设计并观察指令执⾏。

二、实验内容

1) 修改数据通路，新增指令comb rs1,rs2,rd采用R型指令格式，实现将rs1高16位和rs2低16位拼接成32位整数，并且保存到rd寄存器。

2) 在处理器上执行该指令，观察仿真波形，验证功能是否正确。

3） 自行设计其他功能指令，并验证设计是否正确

三、实验环境

硬件：桌面PC

软件：Chisel开发环境

四、实验步骤及说明

1) 实验要求

学习Chisel数据通路的Chisel描述，特别是指令译码部分和core核心代码。然后按照下面操作完成指令译码器的修改，以及数据通路的修改，按照参考文档完成comb指令的实现，自行设计新指令实现其功能并验证。

2) 实验过程

（一）COMB指令

分析：添加新指令 comb ，首先需要根据riscv指令格式，设置该指令各个字段的值，并在相应文件中添加该指令的比特模式。然后设置该指令的译码结果，接着在ALU中实现该指令的功能。最后让该指令在处理器上执行，验证功能是否正确。

1. 在Instrutcions.scala文件中添加 comb 指令比特模式串

comb 为R型指令，riscv的R型指令格式如下：

指令功能：comb 是一种 R 型指令，将 rs1 的高 16 位与 rs2 的低 16 位拼接成 32 位数据，结果存储到 rd。

指令格式：基于 RISC-V 的 R 型指令格式，具体字段如下：

opcode（操作码）：7位，用于指定指令类型。

rs2（源寄存器2）：5位，指定第二个源寄存器。

rs1（源寄存器1）：5位，指定第一个源寄存器。

funct3（功能字段3）：3位，用于区分具有相同操作码的不同指令。

rd（目标寄存器）：5位，指定目标寄存器，用于存放指令执行结果。

opcode/funct7（功能字段7）：7位，用于区分具有相同操作码和funct3的不同指令。

为了避免新加指令与riscv-mini已有指令冲突，将 comb 指令的opcode、funct3和funct7部分设置为0110011、111、0000001。然后使用 BitPat() 函数设置 comb 指令的比特模式。

步骤 1.1：定义指令比特模式

在Instructions.scala文件中，添加以下的代码来定义comb指令的比特模式：

1. // Instructions.scala
2. package min
3. import chisel3.util.BitPat
4. object Instructions {
5. // 省略RISCV-mini已定义的指令
6. // 新增指令COMB
7. def COMB = BitPat("b0000001??????????111?????0110011")
8. }

这里的BitPat()函数用于定义一个位模式，确保与现有指令无冲突，其中?表示不关心的位，可以是0或1。

2. 添加 comb 指令的译码

步骤 2.1：定义 ALU 操作常量

comb 指令需要在ALU中将rs1高16位和rs2低16位拼接成32位整数，因此需要在Alu.scala文件中添加常量 ALU_COMB ，让译码器可以译码出正确的信号。因此，在 Alu.scala 文件中添加新的操作码：

1. // Alu.scala
2. import chisel3._
3. import chisel3.util._
4. object Alu {
5.     val ALU_ADD = 0.U(4.W)
6.     val ALU_SUB = 1.U(4.W)
7.     val ALU_AND = 2.U(4.W)
8.     val ALU_OR = 3.U(4.W)
9.     val ALU_XOR = 4.U(4.W)
10.     val ALU_SLT = 5.U(4.W)
11.     val ALU_SLL = 6.U(4.W)
12.     val ALU_SLTU = 7.U(4.W)
13.     val ALU_SRL = 8.U(4.W)
14.     val ALU_SRA = 9.U(4.W)
15.     val ALU_COPY_A = 10.U(4.W)
16.     val ALU_COPY_B = 11.U(4.W)
17.    // 新加常量
18.    val ALU_COMB = 12.U(4.W)
19.    val ALU_XXX = 15.U(4.W)
20. }
21. //省略RISCV-mini的ALU实现部分

步骤 2.2：设置控制信号映射

接下来为 comb 指令添加对应的译码映射。 comb 指令执行后pc需要加4，并将从寄存器文件中读取的数据rs1和rs2进行拼接操作，然后将ALU输出的拼接结果写回到寄存器文件中。在 Control.scala 文件中为 comb 指令配置控制信号：

1. // Control.scala
2. import chisel3._
3. import chisel3.util._
4. object Control {
5. //省略常量定义部分
6. // format: off
7. val default =
8. List(PC_4 , A_XXX, B_XXX, IMM_X, ALU_XXX , BR_XXX, N, ST_XXX, LD_XXX, WB_ALU, N, CSR.N, Y)
9. val map = Array(
10. LUI -> List(PC_4 , A_PC, B_IMM, IMM_U, ALU_COPY_B, BR_XXX, N, ST_XXX, LD_XXX, WB_ALU, Y, CSR.N, N),
11. AUIPC -> List(PC_4 , A_PC, B_IMM, IMM_U, ALU_ADD , BR_XXX, N, ST_XXX, LD_XXX, WB_ALU, Y, CSR.N, N),
12. JAL -> List(PC_ALU, A_PC, B_IMM, IMM_J, ALU_ADD , BR_XXX, Y, ST_XXX, LD_XXX, WB_PC4, Y, CSR.N, N),
13. //省略部分指令译码映射
14. // 这是COMB指令的译码映射
15. COMB -> List(PC_4 , A_RS1, B_RS2, IMM_X, ALU_COMB , BR_XXX, N, ST_XXX, LD_XXX, WB_ALU, N, CSR.N, N))
16. // format: on
17. }
18. //省略RISCV-mini的控制实现部分

3. 实现 comb 指令的执行操作

步骤 3.1：实现拼接逻辑

在Alu.scala文件添加将rs1高16位和rs2低16位拼接成32位整数的操作。因此，在 Alu.scala 文件中为 comb 指令添加具体执行逻辑：使用 MuxLookup 多路选择器，根据 alu_op 确定执行操作。Cat() 函数将 io.A(31,16) 与 io.B(15,0) 拼接为 32 位数据。

1. // Alu.scala
2. import chisel3._
3. import chisel3.util._
4. //省略Alu常量定义和端口声明部分
5. class AluSimple(val width: Int) extends Alu {
6.   val io = IO(new AluIO(width))
7.   val shamt = io.B(4, 0).asUInt
8.   io.out := MuxLookup(
9.     io.alu_op,
10.     io.B,
11.     Seq(
12.       ALU_ADD -> (io.A + io.B),
13.       ALU_SUB -> (io.A - io.B),
14.       ALU_SRA -> (io.A.asSInt >> shamt).asUInt,
15.       ALU_SRL -> (io.A >> shamt),
16.       ALU_SLL -> (io.A << shamt),
17.       ALU_SLT -> (io.A.asSInt < io.B.asSInt),
18.       ALU_SLTU -> (io.A < io.B),
19.       ALU_AND -> (io.A & io.B),
20.       ALU_OR -> (io.A | io.B),
21.       ALU_XOR -> (io.A ^ io.B),
22.       ALU_COPY_A -> io.A,
23.       // COMB指令执行
24.       ALU_COMB -> Cat(io.A(31,16), io.B(15,0))
25.      )
26.    )
27.    io.sum := io.A + Mux(io.alu_op(0), -io.B, io.B)
28. }
29. class AluArea(val width: Int) extends Alu {
30.    val io = IO(new AluIO(width))
31.    val sum = io.A + Mux(io.alu_op(0), -io.B, io.B)
32.    val cmp =
33. Mux(io.A(width - 1) === io.B(width - 1), sum(width - 1), Mux(io.alu_op(1), io.B(width - 1), io.A(width -1)))
34.    val shamt = io.B(4, 0).asUInt
35.    val shin = Mux(io.alu_op(3), io.A, Reverse(io.A))
36. val shiftr = (Cat(io.alu_op(0) && shin(width - 1), shin).asSInt >> shamt)(width - 1, 0)
37.    val shiftl = Reverse(shiftr)
38.    // 将A(rs1)的高16位与B(rs2)的低16位拼接
39.    val comb = Cat(io.A(31,16), io.B(15,0))
40.    val out =
41.      Mux(
42.         io.alu_op === ALU_ADD || io.alu_op === ALU_SUB,
43.         sum,
44.         Mux(
45.            io.alu_op === ALU_SLT || io.alu_op === ALU_SLTU,
46.            cmp,
47.            Mux(
48.              io.alu_op === ALU_SRA || io.alu_op === ALU_SRL,
49.              shiftr,
50.              Mux(
51.                io.alu_op === ALU_SLL,
52.                shiftl,
53.                Mux(
54.                  io.alu_op === ALU_AND,
55.                  io.A & io.B,
56.                  Mux(
57.                    io.alu_op === ALU_OR,
58.                    io.A | io.B,
59.                    Mux(io.alu_op === ALU_XOR, io.A ^ io.B,
60.                        // COMB指令执行
61. Mux(io.alu_op === ALU_COMB, comb, Mux(io.alu_op===ALU_COPY_A, io.A, io.B)))
62.                     )
63.                   )
64.                 )
65.               )
66.             )
67.           )
68.      io.out := out
69.      io.sum := sum
70. }

 对 comb 指令进行测试

步骤 4.1：编写测试程序

编写一个程序加载到处理器中，调用 comb 指令并观察结果。comb.s代码如下：

1.               .text # Define beginning of text section
2.               .global _start # Define entry _start
3. _start:
4.               lui x6, 1 # x6 = 0x00001000
5.               lui x7, 2 # x7 = 0x00002000
6.               # comb x5, x6, x7
7. exit:
8.               csrw mtohost, 1
9.               j exit
10.               .end # End of file

请注意，因为 comb 为自己加入的指令，不能被汇编器汇编，所以这里将其注释掉，到后面生成的comb.hex文件中再将 comb x5, x6, x7 的二进制添加进去。

步骤 4.2：编译测试程序

编写完程序后，使用如下命令进行编译：

$ riscv32-unknown-elf-gcc -nostdlib -Ttext=0x200 -o comb comb.s

然后使用 elf2hx 命令将comb二进制文件转换成十六进制：

$ elf2hex 16 4096 comb > comb.hex

在comb.hex文件中，可以找到 lui x6, 1 和 lui x7, 2 的机器码对应的十六进制形式：

comb x5, x6, x7 转换成机器码的十六机制形式为 027372b3。因此处指令存储为小端模式，故我们需要将十六进制数插入到第一个红线的前面。修改后如下：

步骤 4.3：运行仿真并观察波形

接着需要在主目录下一次执行 make 和 make verilator 命令（若之前已经执行过，则在此次操作之前需要执行 make clean ），执行后会产生VTile可执行文件。然后执行下面命令，使mini处理器执行新建指令并产生波形文件。

$ ./VTile comb.hex comb.vcd

使用GTKWave打开comb.vcd文件，其波形图如下：

指令对应的十六进制形式见下表：

表 1：指令所对应16进制

从波形图中可以看出， comb 指令将拼接后的结果0x00002000写回到了5号寄存器中，故该指令执行正常。

（二）new_inst指令

添加新指令 new_inst ，new_inst 是一个 R 型指令，功能为：将 rs1 和 rs2 的值进行对 rs1 的值取反后与 rs2 进行按位与操作，将结果存储到 rd。

1. 在Instrutcions.scala文件中添加 new_inst 指令比特模式串

指令格式：

基于 R 型指令格式，opcode、funct3 和 funct7 的设置为：

1. opcode: 0110011
2. funct3: 110
3. funct7: 0000001

在 Instructions.scala 文件中添加以下内容：

1. // Instructions.scala
2. import chisel3.util.BitPat
3. object Instructions {
4.   // 已有指令省略
5.   def NEW_INST = BitPat("b0000001??????????110?????0110011")
6. }

2. 添加 comb 指令的译码

步骤 2.1：定义 ALU 操作常量

在 Alu.scala 文件中为 new_inst 指令添加常量：

1. // Alu.scala
2. object Alu {
3.   // 已有常量省略
4.   val ALU_NEW_INST = 13.U(4.W) // 新指令对应的 ALU 操作常量
5. }

步骤 2.2：设置控制信号映射

修改 Control.scala 文件，设置指令控制信号。为 new_inst 指令添加控制信号映射，确保译码后能正确触发对应的 ALU 操作：

1. // Control.scala
2. val map = Array(
3.   // 已有映射省略
4.   NEW_INST -> List(PC_4, A_RS1, B_RS2, IMM_X, ALU_NEW_INST, BR_XXX, N, ST_XXX, LD_XXX, WB_ALU, N, CSR.N, N)
5. )

3. 实现 new_inst 指令的执行操作

步骤 3.1：实现指令逻辑

为 new_inst 添加操作（~io.A & io.B 表示对 rs1 的值取反后与 rs2 进行按位与操作）：

1. // Alu.scala
2. class AluSimple(val width: Int) extends Alu {
3.   val io = IO(new AluIO(width))
4.   io.out := MuxLookup(
5.     io.alu_op,
6.     io.B,
7.     Seq(
8.       // 已有操作省略
9.       ALU_NEW_INST -> (~io.A & io.B) // 新指令逻辑实现
10.     )
11.   )
12. }

要在 AluArea 中添加对 new_inst 指令的支持，进行以下步骤：

1. 定义指令逻辑：new_inst 的功能是对 rs1 取反后与 rs2 按位与，将结果存储到 rd。对应到硬件逻辑，可以直接通过 ~io.A & io.B 实现。
2. 在ALU的Mux逻辑中插入新指令处理逻辑：在out的生成逻辑中添加new_inst的逻辑。
3. 确保ALU操作码正确映射：在控制逻辑中定义ALU_NEW_INST并在AluArea中使用。

1. class AluArea(val width: Int) extends Alu {
2.   val io = IO(new AluIO(width))
3.   val sum = io.A + Mux(io.alu_op(0), -io.B, io.B)
4.   val cmp = Mux(
5.     io.A(width - 1) === io.B(width - 1),
6.     sum(width - 1),
7.     Mux(io.alu_op(1), io.B(width - 1), io.A(width - 1))
8.   )
9.   val shamt = io.B(4, 0).asUInt
10.   val shin = Mux(io.alu_op(3), io.A, Reverse(io.A))
11.   val shiftr = (Cat(io.alu_op(0) && shin(width - 1), shin).asSInt >> shamt)(width - 1, 0)
12.   val shiftl = Reverse(shiftr)
14.   // 新增指令逻辑: rs1取反后与rs2按位与
15.   val newInst = ~io.A & io.B
17.   // 其他指令逻辑
18.   val comb = Cat(io.A(31, 16), io.B(15, 0))
20.   val out =
21.     Mux(
22.       io.alu_op === ALU_ADD || io.alu_op === ALU_SUB,
23.       sum,
24.       Mux(
25.         io.alu_op === ALU_SLT || io.alu_op === ALU_SLTU,
26.         cmp,
27.         Mux(
28.           io.alu_op === ALU_SRA || io.alu_op === ALU_SRL,
29.           shiftr,
30.           Mux(
31.             io.alu_op === ALU_SLL,
32.             shiftl,
33.             Mux(
34.               io.alu_op === ALU_AND,
35.               io.A & io.B,
36.               Mux(
37.                 io.alu_op === ALU_OR,
38.                 io.A | io.B,
39.                 Mux(
40.                   io.alu_op === ALU_XOR,
41.                   io.A ^ io.B,
42.                   Mux(
43.                     io.alu_op === ALU_COMB,
44.                     comb,
45.                     Mux(
46.                       io.alu_op === ALU_NEW_INST, // 新增指令的逻辑
47.                       newInst,
48.                       Mux(io.alu_op === ALU_COPY_A, io.A, io.B)
49.                     )
50.                   )
51.                 )
52.               )
53.             )
54.           )
55.         )
56.       )
57.     )
58.   io.out := out
59.   io.sum := sum
60. }

4. 对 new_inst 指令进行测试

步骤 4.1：编写测试程序

编写一个程序加载到处理器中，调用 new_inst 指令并观察结果。new_inst.s代码如下：

1.               .text # Define beginning of text section
2.               .global _start # Define entry _start
3. _start:
4.               lui x6, 1 # x6 = 0x00001000
5.               lui x7, 2 # x7 = 0x00002000
6.               # new_inst x5, x6, x7
7. exit:
8.               csrw mtohost, 1
9.               j exit
10.               .end # End of file

因为 new_inst 为自己加入的指令，不能被汇编器汇编，所以这里将其注释掉，到后面生成的new_inst.hex文件中再将 new_inst x5, x6, x7 的二进制添加进去。

步骤 4.2：编译测试程序

编写完程序后，使用如下命令进行编译：

$ riscv32-unknown-elf-gcc -nostdlib -Ttext=0x200 -o new_inst new_inst.s

然后使用 elf2hx 命令将new_inst二进制文件转换成十六进制：

$ elf2hex 16 4096 new_inst >new_inst.hex

在new_inst.hex文件中，可以找到 lui x6, 1 和 lui x7, 2 的机器码对应的十六进制形式：

new_inst  x5, x6, x7 转换成机器码的十六机制形式为 01070333。因此处指令存储为小端模式，故我们需要将十六进制数插入到第一个红线的前面。修改后如下：

步骤 4.3：运行仿真并观察波形

接着需要在主目录下一次执行 make 和 make verilator 命令（若之前已经执行过，则在此次操作之前需要执行 make clean ），执行后会产生VTile可执行文件。然后执行下面命令，使mini处理器执行新建指令并产生波形文件。

$ ./VTile new_inst.hex new_inst.vcd

使用GTKWave打开new_inst.vcd文件，其波形图如下：

指令对应的十六进制形式见下表：

表 2：指令所对应16进制

手算验证：

1. ~x6 = 0xFFFFEFFF 的二进制表示为：1111 1111 1111 1110 1111 1111 1111 1111。
2. x7 = 0x00002000 的二进制表示为：0000 0000 0000 0010 0000 0000 0000 0000。
3. x5=(~x6)&x7=0x00002000，即验证正确。

从波形图中可以看出， new_inst 指令将结果0x00002000写回到了5号寄存器中，故该指令执行正常。

五、实验结果

（一）COMB指令

指令对应的十六进制形式见下表：

从波形图中可以看出， comb 指令将拼接后的结果0x00002000写回到了5号寄存器中，故该指令执行正常。

结果验证：comb 指令的功能是将两个寄存器的值拼接成一个 32 位的整数。具体来说，comb 指令将 x6 的高 16 位和 x7 的低 16 位拼接在一起，形成一个新的 32 位值，并将结果写入 x5 寄存器。

1. x6 = 0x00001000 的二进制表示为：00000000 00000001 00000000 00000000。
2. x7 = 0x00002000 的二进制表示为：00000000 00000010 00000000 00000000。

将 x6 的高 16 位（00000000 00000001）与 x7 的低 16 位（00000000 00000000）拼接，得到的 32 位结果是：

x5 = cat(x6(31:16), x7(15:0)) = 0x00002000

因此，x5 的最终值是 0x00002000，指令执行正确。

（二）new_inst指令

指令对应的十六进制形式见下表：

从波形图中可以看出， new_inst 指令将结果0x00002000写回到了5号寄存器中，故该指令执行正常。

结果分析：new_inst 是一个 R 型指令，的功能是将 x6 的值按位取反后，与 x7 的值进行按位与操作，并将结果存储到 x5 中。

1. x6 = 0x00001000 的二进制表示为：00000000 00000001 00000000 00000000。
2. 对 x6 进行按位取反（~x6），得到 0xFFFFEFFF，即二进制表示为：11111111 11111111 11101111 11111111。
3. x7 = 0x00002000 的二进制表示为：00000000 00000010 00000000 00000000。
4. 按位与操作 ~x6 与 x7：

1. 11111111 11111111 11101111 11111111  (x6取反)
2. AND
3. 00000000 00000010 00000000 00000000  (x7)
4. --------------------------------------
5. 00000000 00000010 00000000 00000000  (结果)

得到的结果是 0x00002000，所以 x5 的值为 0x00002000，指令执行正确。