计组实验期末 - Echo

Pasted image 20251116190550

测试指令共分11段（Test_all.coe，已载入初始工程rom中），其中，每段由实验讲义中的12条指令另加跳转测试指令12条，共24条。

由拨码开关sw_i选择起始地址进入，具体如下。


	beq	bne	blt	bge	bltu	bgeu	jal	jalr	sll	srl	sra
Sw_i [5:2]	0000	0001	0010	0011	0100	0101	0110	0111	1000	1001	1010

例如sw_i[5:2]=0101，则对应于bgeu测试指令段。

Sll，srl，sra均为r型指令，作为保底，不要与slli，srli，srai

1
// 起始地址选择参考样例
2

3
`timescale 1ns / 1ps
4
module PC(clk, rst, NPC, PCwr,PC,sw_i);
5

6
  input              clk;
7
  input              rst;
8
  input       [31:0] NPC;
9
  input      wire   PCwr;
10
  input       [3:0]  sw_i;
11
  output   reg  [31:0] PC;
12

13
  always @(posedge clk, negedge rst)
14
  //added for final test 2024.12.19
15
  //choose the test code init address
16
  //PC initialization
17
    if (!rst) begin
18
        case (sw_i)
19
            4'b0000:PC <= 32'h0000_0000; //beq
20
            4'b0001:PC <= 32'h0000_0080; //bne
21
            4'b0010:PC <= 32'h0000_0100; //blt
22
            4'b0011:PC <= 32'h0000_0180; //bge
23
            4'b0100:PC <= 32'h0000_0200; //bltu
24
            4'b0101:PC <= 32'h0000_0280; //bgeu
25
            4'b0110:PC <= 32'h0000_0300; //jal
26
            4'b0111:PC <= 32'h0000_037c; //jalr
27
            4'b1000:PC <= 32'h0000_03f0; //sll
28
            4'b1001:PC <= 32'h0000_0410; //srl
29
            4'b1010:PC <= 32'h0000_0430; //sra
30
        endcase
31
//          PC <= 32'h0000_0000;
32
      end
33
    else
34
     if (PCwr==1'b0)//sw_i[1]= 1,
35
       PC <= NPC;
36

37
endmodule

容易出错的地方#

PC，rom_addr的复位时机要同时（要么都异步复位（写在敏感列表），要么都同步复位（不写在敏感列表）），否则复位会出现部分复位(复位后： A->E->F->…)
Ctrl中指令解析错误，要严格检查解析Opcode，Funct是否正确；以及生成信号是否有遗漏
WD的赋值采取组合逻辑的呈现：always@(*)(reg) 还是 assign(wire)
- 前者可能要使用到块内初始化，这引入了多重赋值和时序竞争的可能性
- 后者直接定义了 WD 与其右侧信号之间的逻辑关系，没有内部的初始化或覆盖步骤，而且连续赋值消除了 always 块内多重赋值带来的所有时序竞争或仿真器对非阻塞赋值的特殊处理，从而确保在任何观察点，WD 都反映了 MUX 逻辑的正确输出
- 但一般简单情形下都适用，这里也是
一般主模块下首先默认是用wire，wire具有快的性质
模块例化出口端口要用wire连接
指令是否有效，观察alu很容易判断：如果运算结果不应该为0，但为0（因为设置了ALUOp的case：default：C为0），则说明Ctrl模块下该指令的解析出错或生成ALUOp信号遗漏了该指令

代码#

下面代码忽略U型指令：lui, auipc以及除了加法的其他运算（or,ori,slt等）

代码亮点#

alu module中把branch指令的各种标志用Zero统一起来
使用 PC和NPC module独立处理PC

核心代码#

SCPU_TOP

1
`timescale 1ns / 1ps
2

3
// 37条指令
4
module SCPU_TOP(
5
    input clk,
6
    input rstn, // 低电平有效，按下后为0
7
    input [15:0] sw_i,
8
    output [7:0] disp_seg_o,
9
    output [7:0] disp_an_o
10
);
11
reg [31:0] clkdiv;
12
wire Clk_CPU;
13

14
always @(posedge clk or negedge rstn) begin
15
    if(!rstn) clkdiv <= 0;
16
    else clkdiv <= clkdiv + 1'b1;
17
end
18

19
assign Clk_CPU = (sw_i[15])?clkdiv[27]:clkdiv[25]; // 2^27 和 2^25分频
20

21
reg [63:0] display_data;
22

23
reg [5:0] led_data_addr;
24
reg [63:0] led_disp_data;
25
parameter LED_DATA_NUM = 19;
26

27
reg [63:0] LED_DATA[18:0];
28
initial begin
29
    LED_DATA[0] = 64'hC6F6F6F0C6F6F6F0;
30
    LED_DATA[1] = 64'hF9F6F6CFF9F6F6CF;
31
    LED_DATA[2] = 64'hFFC6F0FFFFC6F0FF;
32
    LED_DATA[3] = 64'hFFC0FFFFFFC0FFFF;
33
    LED_DATA[4] = 64'hFFA3FFFFFFA3FFFF;
34
    LED_DATA[5] = 64'hFFFFA3FFFFFFA3FF;
35
    LED_DATA[6] = 64'hFFFF9CFFFFFF9CFF;
36
    LED_DATA[7] = 64'hFF9EBCFFFF9EBCFF;
37
    LED_DATA[8] = 64'hFF9CFFFFFF9CFFFF;
38
    LED_DATA[9] = 64'hFFC0FFFFFFC0FFFF;
39
    LED_DATA[10] = 64'hFFA3FFFFFFA3FFFF;
40
    LED_DATA[11] = 64'hFFA7B3FFFFA7B3FF;
41
    LED_DATA[12] = 64'hFFC6F0FFFFC6F0FF;
42
    LED_DATA[13] = 64'hF9F6F6CFF9F6F6CF;
43
    LED_DATA[14] = 64'h9EBEBEBC9EBEBEBC;
44
    LED_DATA[15] = 64'h2737373327373733;
45
    LED_DATA[16] = 64'h505454EC505454EC;
46
    LED_DATA[17] = 64'h744454F8744454F8;
47
    LED_DATA[18] = 64'h0062080000620800;
48
end
49

50
always @(posedge Clk_CPU or negedge rstn) begin
51
    if(!rstn) begin
52
        led_data_addr <= 6'd0;
53
        led_disp_data <= 64'b1;
54
    end
55
    else if(sw_i[0] == 1'b1) begin
56
        if(led_data_addr == LED_DATA_NUM) begin
57
            led_data_addr <= 6'd0;
58
            led_disp_data <= LED_DATA[0];
59
        end
60
        else begin
61
            led_disp_data <= LED_DATA[led_data_addr];
62
            led_data_addr <= led_data_addr + 1'b1;
63
        end
64
    end
65
    else led_data_addr <= led_data_addr;
66
end
67

68
wire [31:0] instr;
69
reg [31:0] reg_data;
70
reg [31:0] alu_disp_data;
71
reg [31:0] dmem_data;
72

73
// PC
74
wire [31:0] PC;
75
wire [31:0] NPC;
76
wire PCwr = ~sw_i[1];
77
wire [2:0] NPCOp;
78

79
// ROM
80
reg [5:0] rom_addr;
81

82
// RF
83
wire RegWrite;
84
wire [31:0] WD;
85
wire [31:0] RD1,RD2;
86

87
reg [5:0] reg_addr; // 显示用
88

89
// ALU
90
wire [31:0] A,B;
91
wire [4:0] ALUOp;
92
wire [31:0] aluout;
93
wire Zero;
94

95
reg [2:0] alu_addr;
96

97
// DM
98
wire MemWrite;
99
wire [5:0] dm_addr;
100
wire [31:0] dm_din;
101
wire [2:0] DMType;
102
wire [31:0] dm_dout;
103

104
reg [6:0] dmem_addr; // 显示用
105

106
// Ctrl
107
wire [5:0] EXTOp;
108
wire [1:0] WDSel;
109
wire ALUSrc;
110

111
// EXT
112
wire [31:0] immout;
113

114
always @(sw_i) begin
115
    if(sw_i[0] == 0) begin
116
        case(sw_i[14:11])
117
            4'b1000 : display_data <= instr;
118
            4'b0100 : display_data <= reg_data;
119
            4'b0010 : display_data <= alu_disp_data;
120
            4'b0001 : display_data <= dmem_data;
121
            default : display_data <= instr;
122
        endcase
123
    end
124
    else display_data = led_disp_data;
125
end
126

127
// 例化显示模块
128
seg7x16 u_seg7x16(
129
    .clk(clk),
130
    .rstn(rstn),
131
    .disp_mode(sw_i[0]),
132
    .i_data(display_data),
133
    .disp_seg_o(disp_seg_o),
134
    .disp_an_o(disp_an_o)
135
);
136
///////////////////////////////////////////////////////
137

138
// 例化PC_Unit module 时序逻辑
139
PC_Unit U_PC(.clk(Clk_CPU),.rst(~rstn),.NPC(NPC),.PCwr(PCwr),.PC(PC));
140

141
// 例化NPC_Unit module 组合逻辑
142
NPC_Unit U_NPC(.PC(PC),.NPCOp(NPCOp),.IMM(immout),.aluout(aluout),.NPC(NPC));
143

144
// 例化ROM模块
145
dist_mem_im U_IM(
146
    .a(rom_addr),
147
    .spo(instr)
148
);
149

150
// 每个CLK_CPU获得一个新指令
151
// 关注上升沿：上升沿PC更新为NPC，所以rom_addr也应更新为NPC以取下条指令
152
 always @(posedge Clk_CPU or negedge rstn) begin
153
     if(!rstn) rom_addr <= 6'b0;
154
     else if(sw_i[1] == 1'b0) rom_addr <= NPC >> 2; // rom以1为单位，指令以4为单位，所以除以4以映射rom
155
     else rom_addr <= rom_addr;
156
 end
157

158
//Decode
159
wire [6:0]  Op        = instr[6:0];
160
wire [6:0]  Funct7    = instr[31:25];
161
wire [2:0]  Funct3    = instr[14:12];
162
wire [4:0]  rs1       = instr[19:15];
163
wire [4:0]  rs2       = instr[24:20];
164
wire [4:0]  rd        = instr[11:7];
165
wire [4:0]  iimm_shamt= instr[24:20];
166
wire [11:0] iimm      = instr[31:20]; // jalr, load, itype
167
wire [11:0] simm      = {instr[31:25],instr[11:7]};
168
wire [11:0] bimm      = {instr[31],instr[7],instr[30:25],instr[11:8]};
169
wire [19:0] uimm      = instr[31:12]; // lui, auipc
170
wire [19:0] jimm      = {instr[31],instr[19:12],instr[20],instr[30:21]}; // jal
171

172

173
// 例化ctrl模块 组合逻辑
174
ctrl u_ctrl(
175
    .Op(Op),
176
    .Funct7(Funct7),
177
    .Funct3(Funct3),
178
    .Zero(Zero),
179
    .RegWrite(RegWrite),
180
    .MemWrite(MemWrite),
181
    .EXTOp(EXTOp),
182
    .ALUOp(ALUOp),
183
    .ALUSrc(ALUSrc),
184
    .NPCOp(NPCOp),
185
    .DMType(DMType),
186
    .WDSel(WDSel)
187
);
188

189
// 例化EXT模块 组合逻辑
190
EXT U_EXT(
191
    .iimm_shamt(iimm_shamt),
192
    .iimm(iimm),
193
    .simm(simm),
194
    .bimm(bimm),
195
    .uimm(uimm),
196
    .jimm(jimm),
197
    .EXTOp(EXTOp),
198
    .immout(immout)
199
);
200

201

202
// 赋值
203

204
// ALU_DM->RF RF_WD
205
// WDSel FromALU 2'b00
206
// WDSel FromMEM 2'b01
207
// WDSel FromPC 2'b10
208
//always @(*) begin
209
//    WD <= 32'h0;
210
//  case(WDSel)
211
//    00: WD <= aluout;
212
//    01: WD <= dm_dout;
213
//    10: WD <= PC + 4;
214
//    default: WD <= 32'h0;
215
//  endcase
216
//end
217

218
// WDSel FromALU 2'b00
219
// WDSel FromMEM 2'b01
220
// WDSel FromPC 2'b10
221
assign WD = (WDSel == 2'b10) ? (PC + 4) :
222
            (WDSel == 2'b01) ? dm_dout :
223
            (WDSel == 2'b00) ? aluout : 32'h00000000;
224

225
// RF->ALU ALU_A_B
226
assign A = RD1;
227
assign B = (ALUSrc == 1'b0)?RD2:immout;
228

229
// ALU->DM DM_addr_din
230
assign dm_addr = aluout;
231
assign dm_din = RD2;
232

233

234
// 例化RF模块 时序逻辑
235
RF U_RF(
236
    .clk(Clk_CPU),
237
    .rstn(rstn),
238
    .RFWr(RegWrite),
239
    .sw_i(sw_i),
240
    .A1(rs1),
241
    .A2(rs2),
242
    .A3(rd),
243
    .WD(WD),
244
    .RD1(RD1),
245
    .RD2(RD2)
246
);
247

248
// 循环显示32个寄存器的内容
249
always @(posedge Clk_CPU or negedge rstn) begin
250
    if(!rstn) begin
251
        reg_addr <= 5'b0;
252
        reg_data <= 32'b0;
253
    end
254
    else if(sw_i[13] == 1'b1)begin
255
        reg_addr <= reg_addr + 1'b1;
256
        reg_data <= U_RF.rf[reg_addr];
257
    end
258
end
259

260
/////////////////////////////////////////////////////
261

262
// 例化alu模块 组合逻辑
263
alu U_alu(
264
    .A(A),
265
    .B(B),
266
    .ALUOp(ALUOp),
267
    .C(aluout),
268
    .Zero(Zero)
269
);
270

271
// 循环显示A B Zero四个值
272
always @(posedge Clk_CPU or negedge rstn) begin
273
    if(!rstn) alu_addr <= 3'b0;
274
    else alu_addr <= alu_addr + 1'b1;
275
    case(alu_addr) // 下面用普通reg接收signed数据，只会数据位复制
276
        3'b001:alu_disp_data <= U_alu.A;
277
        3'b010:alu_disp_data <= U_alu.B;
278
        3'b011:alu_disp_data <= U_alu.C;
279
        3'b100:alu_disp_data <= U_alu.Zero;
280
        default:alu_disp_data <= 32'hFFFFFFFF;
281
    endcase
282
end
283

284
//////////////////////////////////////////////////////
285

286
// 例化dm模块 时序逻辑
287
dm U_DM(
288
    .clk(Clk_CPU),
289
    .DMWr(MemWrite),
290
    .addr(dm_addr),
291
    .din(dm_din),
292
    .DMType(DMType),
293
    .dout(dm_dout)
294
);
295

296
// 循环显示Data Memory内容
297
parameter DM_DATA_NUM = 16;
298
always @(posedge Clk_CPU or negedge rstn) begin
299
    if(!rstn) begin
300
        dmem_addr <= 7'b0;
301
        dmem_data <= 32'hFFFFFFFF;
302
    end
303
    else if(sw_i[11] == 1'b1) begin
304
        dmem_addr <= dmem_addr + 1'b1;
305
        dmem_data <= U_DM.dmem[dmem_addr][7:0];
306
        if(dmem_addr == DM_DATA_NUM) begin // DM_DATA_NUM是不能取到的，所以此时马上切为0
307
            dmem_addr <= 7'd0;
308
            dmem_data <= 32'hFFFFFFFF;
309
        end
310
    end
311
end
312

313
endmodule

1
module PC_Unit(
2
    input clk,
3
    input rst,
4
    input [31:0] NPC,
5
    input PCwr,
6
    output reg [31:0] PC
7
);
8
// 由于主模块下各rstn复位都是异步复位，所以关于rstn的同时集体复位，这里应该采取异步复位，所以敏感列表里应有rst
9
// 否则只有在posedge clk下rst为1才复位，则为同步复位
10
always @(posedge clk or posedge rst) begin
11
    if(rst) PC <= 32'b0;
12
    else if(PCwr) PC <= NPC;
13
end
14
endmodule

NPC

1
`define NPC_PLUS4 3'b000
2
`define NPC_BRANCH 3'b001
3
`define NPC_JUMP 3'b010
4
`define NPC_JALR 3'b100
5

6
module NPC_Unit(
7
    input [31:0] PC,
8
    input [2:0] NPCOp,
9
    input [31:0] IMM,
10
    input [31:0] aluout,
11
    output reg [31:0] NPC
12
);
13
always @(*) begin
14
    case(NPCOp)
15
        `NPC_PLUS4: NPC = PC + 4; // default
16
        `NPC_BRANCH: NPC = PC + IMM; // branch
17
        `NPC_JUMP: NPC = PC + IMM; // jal
18
        `NPC_JALR: NPC = aluout; // jalr
19
        default: NPC = PC + 4;
20
    endcase
21
end
22
endmodule

ctrl

1
module ctrl(
2
    input [6:0] Op,
3
    input [6:0] Funct7,
4
    input [2:0] Funct3,
5
    input Zero,
6
    output RegWrite,
7
    output MemWrite,
8
    output [5:0] EXTOp,
9
    output [4:0] ALUOp,
10
    output [2:0] NPCOp,
11
    output ALUSrc,
12
    output [2:0] DMType,
13
    output [1:0] WDSel // MemtoReg
14
);
15
// R_type 10条
16
wire rtype = ~Op[6] & Op[5] & Op[4] & ~Op[3] & ~Op[2] & Op[1] & Op[0]; //0110011
17
wire i_add = rtype & ~Funct3[2] & ~Funct3[1] & ~Funct3[0] & ~Funct7[5]; // add 0000000 000
18
wire i_sub = rtype & ~Funct3[2] & ~Funct3[1] & ~Funct3[0] & Funct7[5]; // sub 0100000 000
19
wire i_sll = rtype & ~Funct3[2] & ~Funct3[1] & Funct3[0]; // sll 0000000 001
20
wire i_slt = rtype & ~Funct3[2] & Funct3[1] & ~Funct3[0]; // slt 0000000 010
21
wire i_sltu = rtype & ~Funct3[2] & Funct3[1] & Funct3[0]; // sltu 0000000 011
22
wire i_xor = rtype & Funct3[2] & ~Funct3[1] & ~Funct3[0]; // xor 0000000 100
23
wire i_srl = rtype & Funct3[2] & ~Funct3[1] & Funct3[0] & ~Funct7[5]; // srl 0000000 101
24
wire i_sra = rtype & Funct3[2] & ~Funct3[1] & Funct3[0] & Funct7[5]; // sra 0100000 101
25
wire i_or  = rtype & Funct3[2] & Funct3[1] & ~Funct3[0]; // or 0000000 110
26
wire i_and = rtype & Funct3[2] & Funct3[1] & Funct3[0]; // and 0000000 111
27

28
// i_l type load 5条
29
wire itype_l = ~Op[6] & ~Op[5] & ~Op[4] & ~Op[3] & ~Op[2] & Op[1] & Op[0]; //0000011
30
wire i_lb = itype_l & ~Funct3[2] & ~Funct3[1] & ~Funct3[0]; //lb 000
31
wire i_lh = itype_l & ~Funct3[2] & ~Funct3[1] & Funct3[0];  //lh 001
32
wire i_lw = itype_l & ~Funct3[2] & Funct3[1] & ~Funct3[0];  //lw 010
33
wire i_lbu = itype_l & Funct3[2] & ~Funct3[1] & ~Funct3[0]; //lbu 100
34
wire i_lhu = itype_l & Funct3[2] & ~Funct3[1] & Funct3[0];  //lh 101
35

36
 // i_r type 涉及Reg与imm运算，ALU with immediate 10条
37
wire itype_r = ~Op[6] & ~Op[5] & Op[4] & ~Op[3] & ~Op[2] & Op[1] & Op[0]; //0010011
38
wire i_addi = itype_r & ~Funct3[2] & ~Funct3[1] & ~Funct3[0]; // addi 000 func3
39
wire i_slti = itype_r & ~Funct3[2] & Funct3[1] & ~Funct3[0]; // slti 010 func3
40
wire i_sltiu = itype_r & ~Funct3[2] & Funct3[1] & Funct3[0]; // sltiu 011 func3
41

42
wire i_slli = itype_r & ~Funct3[2] & ~Funct3[1] & Funct3[0]; // slli 001
43
wire i_srli = itype_r & Funct3[2] & ~Funct3[1] & Funct3[0] & ~Funct7[5]; // srli 101 0000000
44
wire i_srai = itype_r & Funct3[2] & ~Funct3[1] & Funct3[0] & Funct7[5]; // srai 101 0100000
45
wire itype_shamt = i_slli | i_srli | i_srai;
46

47
// jalr
48
wire i_jalr = Op[6] & Op[5] & ~Op[4] & ~Op[3] & Op[2] & Op[1] & Op[0]; //1100111
49

50
// s format store 3条
51
wire stype = ~Op[6] & Op[5] & ~Op[4] & ~Op[3] & ~Op[2] & Op[1] & Op[0];//0100011
52
wire i_sb = stype & ~Funct3[2] & ~Funct3[1] & ~Funct3[0]; // sb 000
53
wire i_sh = stype & ~Funct3[2] & ~Funct3[1] & Funct3[0];  // sh 001
54
wire i_sw = stype & ~Funct3[2] & Funct3[1] & ~Funct3[0];  // sw 010
55

56
// B_type 6条
57
wire btype = Op[6] & Op[5] & ~Op[4] & ~Op[3] & ~Op[2] & Op[1] & Op[0]; //1100011
58
wire i_beq = btype & ~Funct3[2] & ~Funct3[1] & ~Funct3[0]; // beq 000
59
wire i_bne = btype & ~Funct3[2] & ~Funct3[1] & Funct3[0];  // bne 001
60
wire i_blt = btype & Funct3[2] & ~Funct3[1] & ~Funct3[0];  // blt 100
61
wire i_bge = btype & Funct3[2] & ~Funct3[1] & Funct3[0];   // bge 101
62
wire i_bltu = btype & Funct3[2] & Funct3[1] & ~Funct3[0]; // bltu 110
63
wire i_bgeu = btype & Funct3[2] & Funct3[1] & Funct3[0];  // bgeu 111
64

65
// J_type 1条
66
wire jtype = Op[6] & Op[5] & ~Op[4] & Op[3] & Op[2] & Op[1] & Op[0]; //1101111
67
wire i_jal = jtype; // jal
68

69
// U_type 2条
70
wire utype = ~Op[6] & Op[4] & ~Op[3] & Op[2] & Op[1] & Op[0]; //0X10111
71
wire i_lui = utype & Op[5]; // lui 0110111
72
wire i_auipc = utype & ~Op[5]; // auipc 0010111
73

74

75
assign RegWrite = rtype | itype_r | itype_l | i_jal | i_jalr; // register write (含跳转返回地址)
76
assign MemWrite = stype; // memory write
77

78
//`define EXT_CTRL_ITYPE_SHAMT 6'b100000
79
//`define EXT_CTRL_ITYPE 6'b010000
80
//`define EXT_CTRL_STYPE 6'b001000
81
//`define EXT_CTRL_BTYPE 6'b000100
82
//`define EXT_CTRL_UTYPE 6'b000010
83
//`define EXT_CTRL_JTYPE 6'b000001
84
assign EXTOp[5] = itype_shamt;
85
assign EXTOp[4] = itype_l | (itype_r & ~itype_shamt) | i_jalr;
86
assign EXTOp[3] = stype;
87
assign EXTOp[2] = btype;
88
assign EXTOp[1] = i_lui | i_auipc;
89
assign EXTOp[0] = i_jal;
90

91

92
//`define ALUOp_nop 5'b00000
93

94
//`define ALUOp_sll 5'b00001
95
//`define ALUOp_srl 5'b00010
96
//`define ALUOp_sra 5'b00101
97

98
//`define ALUOp_add 5'b00011
99

100
//`define ALUOp_beq 5'b00100
101
//`define ALUOp_bne 5'b01000
102
//`define ALUOp_blt 5'b01100
103
//`define ALUOp_bge 5'b10000
104
//`define ALUOp_bltu 5'b10100
105
//`define ALUOp_bgeu 5'b11000
106
assign ALUOp[0] = i_add | i_addi | stype | itype_l | i_jalr | i_sll | i_sra | i_slli | i_srai;
107
assign ALUOp[1] = i_add | i_addi | stype | itype_l | i_jalr | i_srl | i_srli;
108
assign ALUOp[2] = i_beq | i_blt | i_bltu | i_sra | i_srai;
109
assign ALUOp[3] = i_bne | i_blt | i_bgeu;
110
assign ALUOp[4] = i_bge | i_bltu | i_bgeu;
111

112

113
//`define NPC_PLUS4 3'b000
114
//`define NPC_BRANCH 3'b001
115
//`define NPC_JUMP 3'b010
116
//`define NPC_JALR 3'b100
117
assign NPCOp[0] = btype & Zero;
118
assign NPCOp[1] = i_jal;
119
assign NPCOp[2] = i_jalr;
120

121

122
assign ALUSrc = itype_r | itype_l | stype | i_jal | i_jalr; // ALU B is from instruction immediate
123

124
// ALU_DM->RF RF_WD
125
// WDSel FromALU 2'b00
126
// WDSel FromMEM 2'b01
127
// WDSel FromPC 2'b10
128
assign WDSel[0] = itype_l;
129
assign WDSel[1] = i_jal | i_jalr;
130

131

132
// dm_word 3'b000
133
// dm_halfword 3'b001
134
// dm_halfword_unsigned 3'b010
135
// dm_byte 3'b011
136
// dm_byte_unsigned 3'b100
137
assign DMType[2] = i_lbu; // bu
138
assign DMType[1] = i_lb | i_sb | i_lhu; // hu和b
139
assign DMType[0] = i_lh | i_sh | i_lb | i_sb; // h和b
140

141
endmodule

alu

1
`define ALUOp_nop 5'b00000
2

3
`define ALUOp_sll 5'b00001
4
`define ALUOp_srl 5'b00010
5
`define ALUOp_sra 5'b00101
6

7
`define ALUOp_add 5'b00011
8

9
`define ALUOp_beq 5'b00100
10
`define ALUOp_bne 5'b01000
11
`define ALUOp_blt 5'b01100
12
`define ALUOp_bge 5'b10000
13
`define ALUOp_bltu 5'b10100
14
`define ALUOp_bgeu 5'b11000
15

16
module alu(
17
    input signed [31:0] A,B,
18
    input [4:0] ALUOp,
19
    output reg signed [31:0] C,
20
    output reg Zero
21
);
22
always @(*) begin
23
    C = 32'b0;
24
    case(ALUOp)
25
        `ALUOp_sll: C = A << B[4:0];
26
        `ALUOp_srl: C = A >> B[4:0];
27
        `ALUOp_sra: C = A >>> B[4:0];
28
        `ALUOp_add: C = A + B;
29
        `ALUOp_beq: C = {31'b0,(A!=B)};
30
        `ALUOp_bne: C = {31'b0,{A==B}};
31
        `ALUOp_blt: C = {31'b0,(A>=B)};
32
        `ALUOp_bge: C = {31'b0,(A<B)};
33
        `ALUOp_bltu: C = {31'b0,($unsigned(A)>=$unsigned(B))};
34
        `ALUOp_bgeu: C = {31'b0,{$unsigned(A)<$unsigned(B)}};
35
        default:C = 32'b0;
36
    endcase
37
    Zero = (C == 0)?1:0; // 阻塞赋值，需等C算出来，而不是同步
38
end
39
endmodule

EXT

1
// 立即数扩展
2
`define EXT_CTRL_ITYPE_SHAMT 6'b100000
3
`define EXT_CTRL_ITYPE 6'b010000
4
`define EXT_CTRL_STYPE 6'b001000
5
`define EXT_CTRL_BTYPE 6'b000100
6
`define EXT_CTRL_UTYPE 6'b000010
7
`define EXT_CTRL_JTYPE 6'b000001
8

9
module EXT(
10
    input [4:0] iimm_shamt,
11
    input [11:0] iimm,
12
    input [11:0] simm,
13
    input [11:0] bimm,
14
    input [19:0] uimm,
15
    input [19:0] jimm,
16
    input [5:0] EXTOp,
17
    output reg [31:0] immout
18
);
19
always @(*) begin
20
    case (EXTOp)
21
    `EXT_CTRL_ITYPE_SHAMT: immout <= {27'b0,iimm_shamt[4:0]}; // I-type 立即数 (用于 slli/srli/srai)
22
    `EXT_CTRL_ITYPE: immout <= {{20{iimm[11]}}, iimm[11:0]}; // I-type 立即数 (用于 addi, lw, jalr 等)
23
    `EXT_CTRL_STYPE: immout <= {{20{simm[11]}}, simm[11:0]}; // S-type 立即数 (用于 sw 等)
24
    `EXT_CTRL_BTYPE: immout<= {{19{bimm[11]}},bimm[11:0],1'b0}; // B-type 立即数 (用于 beq 等)
25
    `EXT_CTRL_UTYPE: immout <= {uimm[19:0], 12'b0}; // U-type 立即数 (用于 lui, auipc)
26
    `EXT_CTRL_JTYPE: immout<= {{11{jimm[19]}},jimm[19:0],1'b0}; // J-type 立即数 (用于 jal)
27
    default: immout <= 32'b0;
28
  endcase
29
end
30

31
endmodule

次要代码#

seg7x16

1
module seg7x16(
2
    input clk,
3
    input rstn,
4
    input disp_mode,
5
    input [63:0] i_data,
6
    output [7:0] disp_seg_o,
7
    output [7:0] disp_an_o
8
);
9
// 2^15分频
10
reg [14:0] cnt;
11
wire seg7_clk;
12

13
always @(posedge clk or negedge rstn) begin
14
    if(!rstn) cnt <= 0;
15
    else cnt <= cnt + 1'b1;
16
end
17

18
assign seg7_clk = cnt[14];
19

20
// 8选1
21
reg [2:0] seg7_addr;
22

23
 always @(posedge seg7_clk or negedge rstn) begin
24
    if(!rstn) seg7_addr <= 0;
25
    else seg7_addr <= seg7_addr + 1'b1;
26
 end
27

28
 // 选中的数码管使能信号
29
 reg [7:0] o_sel_r;
30
 always @(*) begin
31
    case(seg7_addr)
32
        7 : o_sel_r = 8'b01111111;
33
        6 : o_sel_r = 8'b10111111;
34
        5 : o_sel_r = 8'b11011111;
35
        4 : o_sel_r = 8'b11101111;
36
        3 : o_sel_r = 8'b11110111;
37
        2 : o_sel_r = 8'b11111011;
38
        1 : o_sel_r = 8'b11111101;
39
        0 : o_sel_r = 8'b11111110;
40
    endcase
41
 end
42

43
 //
44
 reg [63:0] i_data_store;
45
 always @(posedge clk or negedge rstn) begin
46
    if(!rstn) i_data_store <= 0;
47
    else i_data_store <= i_data;
48
 end
49

50
 reg [7:0] seg_data_r;
51
 always @(*) begin
52
    if(disp_mode == 1'b0) begin // 字符显示模式
53
        case(seg7_addr)
54
            0 : seg_data_r = i_data_store[3:0];
55
            1 : seg_data_r = i_data_store[7:4];
56
            2 : seg_data_r = i_data_store[11:8];
57
            3 : seg_data_r = i_data_store[15:12];
58
            4 : seg_data_r = i_data_store[19:16];
59
            5 : seg_data_r = i_data_store[23:20];
60
            6 : seg_data_r = i_data_store[27:24];
61
            7 : seg_data_r = i_data_store[31:28];
62
            default: seg_data_r = 8'hFF; // 默认全空，防止latch
63
        endcase
64
    end
65
    else begin // 图形显示模式
66
        case(seg7_addr)
67
            0 : seg_data_r = i_data_store[7:0];
68
            1 : seg_data_r = i_data_store[15:8];
69
            2 : seg_data_r = i_data_store[23:16];
70
            3 : seg_data_r = i_data_store[31:24];
71
            4 : seg_data_r = i_data_store[39:32];
72
            5 : seg_data_r = i_data_store[47:40];
73
            6 : seg_data_r = i_data_store[55:48];
74
            7 : seg_data_r = i_data_store[63:56];
75
            default: seg_data_r = 8'hFF; // 默认全空，防止latch
76
        endcase
77
    end
78
 end
79

80
 reg [7:0] o_seg_r;
81
 always @(posedge clk or negedge rstn) begin
82
    if(!rstn) o_seg_r <= 8'hFF;
83
    else if(disp_mode == 1'b0) begin // 字符模式
84
        case(seg_data_r)
85
            4'h0 : o_seg_r <= 8'hC0;
86
            4'h1 : o_seg_r <= 8'hF9;
87
            4'h2 : o_seg_r <= 8'hA4;
88
            4'h3 : o_seg_r <= 8'hB0;
89
            4'h4 : o_seg_r <= 8'h99;
90
            4'h5 : o_seg_r <= 8'h92;
91
            4'h6 : o_seg_r <= 8'h82;
92
            4'h7 : o_seg_r <= 8'hF8;
93
            4'h8 : o_seg_r <= 8'h80;
94
            4'h9 : o_seg_r <= 8'h90;
95
            4'hA : o_seg_r <= 8'h88;
96
            4'hB : o_seg_r <= 8'h83;
97
            4'hC : o_seg_r <= 8'hC6;
98
            4'hD : o_seg_r <= 8'hA1;
99
            4'hE : o_seg_r <= 8'h86;
100
            4'hF : o_seg_r <= 8'h8E;
101
            default : o_seg_r <= 8'hFF;
102
        endcase
103
    end
104
    else o_seg_r <= seg_data_r;
105
 end
106

107
 assign disp_an_o = o_sel_r;
108
 assign disp_seg_o = o_seg_r;
109
endmodule

1
module RF(
2
    input clk,
3
    input rstn,
4
    input RFWr,
5
    input [15:0] sw_i,
6
    input [4:0] A1,A2,A3,
7
    input [31:0] WD,
8
    output [31:0] RD1,RD2
9
);
10
reg [31:0] rf[31:0]; // reg [31:0]为数据类型，rf[31:0]为数组，32位宽，32个寄存器
11

12
integer i;
13
always @(posedge clk or negedge rstn) begin
14
    if(!rstn) begin
15
        for(i=0;i<32;i=i+1) rf[i] <= i;
16
    end
17
    else if(RFWr && (!sw_i[1]) && (A3 != 5'd0)) rf[A3] <= WD; // 正常模式下且RegWrite有效，写rd
18
end
19

20
// 读rs1和rs2
21
assign RD1 = (A1 != 0)?rf[A1]:0;
22
assign RD2 = (A2 != 0)?rf[A2]:0;
23

24
endmodule

1
`define dm_word 3'b000
2
`define dm_halfword 3'b001
3
`define dm_halfword_unsigned 3'b010
4
`define dm_byte 3'b011
5
`define dm_byte_unsigned 3'b100
6

7
module dm(
8
    input clk,
9
    input DMWr,
10
    input [5:0] addr,
11
    input [31:0] din,
12
    input [2:0] DMType,
13
    output reg [31:0] dout
14
);
15
reg [7:0] dmem[6:0]; // 8位宽数据，7个单元，reg [7:0]为数据类型，dmem[6:0]为数组
16
integer i;
17
initial begin
18
    for(i=0;i<7;i=i+1) dmem[i] = 8'h00;
19
end
20

21
// 写操作
22
always @(posedge clk) begin
23
    if(DMWr) begin
24
        case(DMType)
25
            `dm_byte:dmem[addr] <= din[7:0];
26
            `dm_halfword:begin
27
                dmem[addr] <= din[7:0];
28
                dmem[addr+1] <= din[15:8];
29
            end
30
            `dm_word:begin
31
                dmem[addr] <= din[7:0];
32
                dmem[addr+1] <= din[15:8];
33
                dmem[addr+2] <= din[23:16];
34
                dmem[addr+3] <= din[31:24];
35
            end
36
        endcase
37
    end
38
end
39

40
// 读操作
41
always @(*) begin
42
    case(DMType)
43
        `dm_byte:dout = {{24{dmem[addr][7]}},dmem[addr][7:0]};
44
        `dm_byte_unsigned:dout = {24'b0,dmem[addr][7:0]};
45
        `dm_halfword:dout = {{16{dmem[addr+1][7]}},dmem[addr+1][7:0],dmem[addr][7:0]};
46
        `dm_halfword_unsigned:dout = {16'b0,dmem[addr+1][7:0],dmem[addr][7:0]};
47
        `dm_word:dout = {dmem[addr+3][7:0],dmem[addr+2][7:0],dmem[addr+1][7:0],dmem[addr][7:0]};
48
        default:dout = {dmem[addr+3][7:0],dmem[addr+2][7:0],dmem[addr+1][7:0],dmem[addr][7:0]};
49
    endcase
50
end
51
endmodule