Anccend/risc-v-cpu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Anccend/risc-v-cpu:556fbe9530ae36aa498f032a835eec97fc4ea5cd
Branches Tags
Anccend/risc-v-cpu:feat/saolei-minesweeper Anccend/risc-v-cpu:feat/isa-ext Anccend/risc-v-cpu:master
...
compare: Anccend/risc-v-cpu:cb0cb433ac9f0ee65e0d3febe2faadbf8a75f17b
Branches Tags
Anccend/risc-v-cpu:feat/saolei-minesweeper Anccend/risc-v-cpu:feat/isa-ext Anccend/risc-v-cpu:master
3 Commits
556fbe9530 ... cb0cb433ac
Author SHA1 Message Date
Anccend cb0cb433ac 源文件收敛到 pipelined-cpu/ 一份：删除根目录 rtl/board/testbench/tools，补充回归脚本 
- 现在只有一份源文件，就在 pipelined-cpu/ 下：
    srcs/rtl（13 个处理器 RTL）、srcs/board、srcs/constrs、srcs/tb、srcs/rom、
    tools/（rv_asm.py、hex2vh.py、run_regress.ps1）、programs/（汇编源码与期望值）。
  仓库根目录的 rtl/、board/、testbench/、tools/ 已删除（删除前逐个文件比对过 MD5，
  与工程目录里的副本完全一致），说明文档仍放在最外层
  cpu21_riscv_redirect_int_bpb说明.md。
- .gitignore 改为：忽略 pipelined-cpu/ 下的工程生成物（*.xpr、*.runs、*.sim、*.cache…），
  只跟踪 srcs/、tools/、programs/、create_project.tcl；_tmp/、_vivado/ 等本地临时目录
  继续忽略。
- 新增 tools/run_regress.ps1：一键回归脚本。编译 srcs/rtl/ → 跑 muldiv/isa/lui/mmio
  四个指令测试并与 programs/*.expected 逐值比对 → 跑两个流水基线 → 跑板级顶层
  （-d BOARD_ROM_FAST）检查跑马灯，最后汇总 PASS/FAIL 并返回失败数作为退出码。
  编译与仿真的中间文件写在 %TEMP%\cpu21_regress，不污染工程目录。实测全部通过。
- 新增 programs/board_demo_fast.asm：快速版演示程序（延时初值 64，约 2.6 µs/步），
  对应 srcs/board/cpu21_board_rom_fast.vh；仿真时用 -d BOARD_ROM_FAST 才会选到它。
- 两个测试平台增加 srcs/rom 探测路径，工程目录内直接 Run Simulation 即可加载镜像。
- 文档：目录结构一节按新布局重写；新增“回归测试”一节（脚本用法 + 期望基线数字）；
  上板章节的生成/仿真命令改为相对工程目录（python tools/rv_asm.py programs/…、
  xvlog -d BOARD_ROM_FAST srcs/rtl/*.v …）；tools 里的用法示例同步更新；
  “工程分享”一节去掉已不存在的副本同步说明。
- 清理：删除本地 _tmp/（约 57 MB）、_vivado/、.Xil/ 临时目录。
 2026-09-13 19:09:36 +08:00
Anccend fed01f5910 工程整理：源文件复制进 pipelined-cpu/，提供一键重建脚本 create_project.tcl 
- pipelined-cpu/ 变成自包含的工程目录，所有设计文件都在里面，可以整个拷给别人：
  srcs/rtl（12 个处理器 RTL）、srcs/board（板级顶层 + 片内 ROM 初始化，含 __FAST 版）、
  srcs/constrs（引脚约束 + 板级母版）、srcs/tb（三个测试平台）、srcs/rom（ROM 镜像），
  另外附上 tools/（迷你汇编器）与 programs/（测试程序源码与期望值）。
  Vivado 工程里的引用全部改到这些副本上（sources_1 ×15、constrs_1 ×2、sim_1 ×12、sim_2 ×2），
  并用副本重新综合通过。
- 新增 pipelined-cpu/create_project.tcl：手写的一键重建脚本。
  * 用 [info script] 定位自身目录，整个文件夹拷到任意路径都能用；
  * 就地创建工程（源文件留在 srcs/ 下不动），带文件自检与“工程已存在”提示；
  * 配好三个 fileset 的顶层、cpu21_board_rom(.vh) 的 Verilog Header 类型、
    xsim.simulate.runtime=all。
  实测：把工程文件夹拷到别处、从另一个工作目录运行脚本，工程重建成功且
  synth_design Complete!（分享包只有 create_project.tcl + srcs/ + tools/ + programs/ +
  说明文档，约 0.3 MB）。
- testbench 从 sources_1 移到仿真 fileset（sim_1 / sim_2）：不再需要
  USED_IN_SYNTHESIS=0 这类设置，也彻底避免“testbench 被当成顶层”的
  [Place 30-494] The design is empty 问题。
- 两个 CPU 测试平台增加 srcs/rom/ 探测路径（含 GUI 仿真目录向上 5 层的相对路径），
  别人拿到工程后不用额外配置就能直接 Run Simulation。
- .gitignore：放行 pipelined-cpu/create_project.tcl（其余工程生成物仍不入库，
  这样重建脚本不会因为工程目录被忽略而丢失）。
- 说明文档新增“工程分享（Tcl 一键重建）”一节：目录结构、脚本用法、分享前应删除的
  生成目录、仓库源码与工程副本的同步命令，以及用 write_project_tcl 自动生成版本时
  需要改的两行（origin_dir / create_project 目标）。
- 验证：muldiv_test 13/13、isa_test 24/24、lui_test 4/4、mmio_test 5/5 以及两个
  流水基线全部通过（与改动前一致）。
 2026-09-13 18:59:25 +08:00
Anccend 4a81685066 乘除法改为多周期时序单元，CPU 时钟从 6.25 MHz 提到 50 MHz 
- 新增 rtl/cpu21_riscv_muldiv.v：移位迭代的多周期乘除法单元。
  * 乘法：32 拍移位加法得到 64 位乘积；有符号变体先取操作数绝对值，迭代结束后
    按符号对 64 位乘积取负。
  * 除法：32 拍恢复余数法得到商与余数；除零按 RISC-V 约定（商全 1、余数为被除数）。
  * 一次乘/除独占 EX 共 34 拍（1 拍装载 + 32 拍迭代 + 1 拍定型）：期间 ID/EX 保持、
    EX/MEM 插气泡、取指/译码冻结，并屏蔽中断（避免结果未定型就写回 rd）。
- rtl/cpu21_riscv_alu.v：删除组合的 32x32 乘法与除法/取余（原来关键路径约 94 ns、
  325 级逻辑、286 个 CARRY4，是 100 MHz 无法收敛的根因）。ALU_MUL/ALU_DIVU 现在
  只作为“这是乘除法指令”的标识，结果由顶层从 muldiv 选取（wb_sel=3 取 result2 的
  约定保持不变，译码器与写回选择都不用改）。
- rtl/cpu21_riscv_decoder.v：新增 md_op_o（乘除法操作类型），并补上课程真值表里的
  divu（funct3=101）——之前这一项译码缺失，会导致 divu 不写 rd。
- rtl/cpu21_riscv_redirect_int_bpb.v：ID/EX 增加 md_op；EX 级停留、结果选择与中断
  屏蔽。另外为时序做了三处行为等价的重构（100 MHz 下 WNS 从 -3.54 ns 改善到
  -1.10 ns）：
  * JAL/JALR 的链接地址 PC+4 改在 EX 级预先算好并随流水寄存器传递，去掉
    “写回值/前递 → 停机判定 → 流水控制”路径上的两个 32 位加法器；
  * ID/EX 的 payload 时钟使能不再依赖冲刷（只有 valid 位受冲刷控制），把
    “EX 级组合判决 → 流水寄存器时钟使能”这条最长路径缩到只剩 1 位；
  * ex_block_irq 不再包含 ex_redirect_valid / ex_halt_event（它们本身就会让
    flush_younger 有效，中断优先时返回地址由 irq_save_pc 正确给出），切断
    “分支判决 → 中断控制器 → flush”的绕行路径。
- rtl/cpu21_riscv_hazard_unit.v：停顿条件去掉 flush_younger（冲刷由 valid 位与
  PC/IF-ID 的冲刷分支处理，同时发生停顿只会多保持一拍 payload），避免把长路径
  引到 payload 的时钟使能上。
- board/cpu21_board_top.v / .xdc：乘除法已不在关键路径上，分频比从 16 降到 2
  （50 MHz，周期 20 ns）。实测（xc7a100tcsg324-1）：CLK_DIV=1（100 MHz）下
  WNS=-1.1 ns，剩余违例路径是 EX 级“分支判决/中断保存 → BPB 更新”，与乘除法无关
  （逻辑只占约 3 ns，其余 ~8 ns 是布线）；CLK_DIV=2 时 WNS=+5.109 ns，余量约 25%。
- 上板 ROM 按 50 MHz 重新生成（延时计数 0x7A000 ≈ 20 ms/步，快速版 64 次循环），
  CPU 时钟比改造前快 8 倍。
- tools/rv_asm.py：支持 divu / remu 助记符。新增 testbench/programs/muldiv_test.asm
  与 muldiv_test.expected（13 个用例：mul/mulh/mulhsu/mulhu/divu/remu、负数、
  0xffffffff、除零、0x12345678 大数）。
- 验证：muldiv_test 13/13、isa_test 24/24、lui_test 4/4、mmio_test 5/5 全部 PASS；
  两个基线（5560 / 6003 周期）与改造前的流水统计一致（差异只来自多周期乘除法带来的
  停顿/气泡计数）；中断测试仍能正常进入 0x30ac / 0x31e0 / 0x3300 三层嵌套处理程序；
  板级仿真：默认 ROM 首次写入 LED=0001、快速 ROM 跑马灯 0001..8000 循环正常。
- 实现结果：synth_design / route_design / write_bitstream 全部完成，
  LUT 5400 → 3420（5.39%）、DSP 12 → 0、IOB 23，时钟 6.25 MHz → 50 MHz，
  bit 文件已更新。
 2026-09-13 18:45:17 +08:00
52 changed files with 1270 additions and 194 deletions
Expand all files Collapse all files
.gitignore
+5
View File
@@ -1,4 +1,9 @@
# Vivado 工程生成物不入库；源文件都在 pipelined-cpu/ 下（srcs/、tools/、programs/）
pipelined-cpu/* pipelined-cpu/*
!pipelined-cpu/srcs/
!pipelined-cpu/tools/
!pipelined-cpu/programs/
!pipelined-cpu/create_project.tcl
# 本地临时目录（仿真脚本、日志、中间文件） # 本地临时目录（仿真脚本、日志、中间文件）
_tmp/ _tmp/
cpu21_riscv_redirect_int_bpb说明.md
+206 -103
View File
@@ -1,6 +1,6 @@
# `cpu21-riscv-4.circ` 的 Verilog 实现 # `cpu21-riscv-4.circ` 的 Verilog 实现
处理器顶层文件：`rtl/cpu21_riscv_redirect_int_bpb.v` 处理器顶层文件：`pipelined-cpu/srcs/rtl/cpu21_riscv_redirect_int_bpb.v`
该设计对应原电路中的“重定向流水线+中断+分支预测”部分，顶层模块为 该设计对应原电路中的“重定向流水线+中断+分支预测”部分，顶层模块为
`cpu21_riscv_redirect_int_bpb`。为便于单独仿真与调试，各功能单元已拆分为 `cpu21_riscv_redirect_int_bpb`。为便于单独仿真与调试，各功能单元已拆分为
@@ -10,26 +10,25 @@
```text ```text
risc-v/ risc-v/
├─ rtl/ 处理器 RTL（13 个文件，cpu21_riscv_redirect_int_bpb.v 为顶层） ├─ pipelined-cpu/ Vivado 工程目录（也是源文件所在地）
├─ board/ 上板（Nexys4DDR）：板级顶层、引脚约束、片内 ROM 初始化 │ ├─ create_project.tcl 一键重建工程的 Tcl 脚本
│ ├─ cpu21_board_top.v 板级顶层（时钟分频 + 片内 ROM/RAM + 引脚） │ ├─ srcs/rtl/*.v 处理器 RTL（13 个文件，cpu21_riscv_redirect_int_bpb.v 为顶层）
│ ├─ cpu21_board_top.xdc 引脚约束与分频时钟约束 │ ├─ srcs/board/*.v|*.vh 板级顶层（时钟分频 + 片内 ROM/RAM + 引脚）、片内 ROM 初始化
│ ├─ cpu21_board_rom.vh 片内 ROM 内容（由 tools/hex2vh.py 生成，上板用） │ ├─ srcs/constrs/*.xdc 引脚与分频时钟约束（+ Nexys4DDR 母版）
│ └─ cpu21_board_rom_fast.vh 短延时的 ROM 内容（仅仿真，-d BOARD_ROM_FAST 选择） │ ├─ srcs/tb/*.v 三个测试平台
├─ testbench/ 仿真 │ ├─ srcs/rom/*.hex 测试平台加载的 ROM 镜像
│ ├─ tb_cpu21_riscv_redirect_int_bpb.v 中断/分支预测测试平台 │ ├─ tools/ rv_asm.py（迷你汇编器）、hex2vh.py（hex → ROM 初始化）、run_regress.ps1（一键回归）
│ ├─ tb_no_intr.v 无中断测试平台（指令集测试用） │ ├─ programs/ 汇编源程序、期望值、课程原始资产（RARS）
│ ├─ tb_board_top.v 板级顶层仿真 │ └─ pipelined-cpu.xpr（+*.runs/…） 本机工程与生成物（不入库，可删）
│ ├─ rom/ 仿真实际加载的 ROM 镜像（.hex） ├─ cpu21_riscv_redirect_int_bpb说明.md 本文档
│ └─ programs/ 汇编源程序、期望值、课程原始资产（RARS） └─ _tmp/、_vivado/ 本地临时目录（不入库）
├─ tools/ rv_asm.py（迷你汇编器）、hex2vh.py（hex → ROM 初始化）
├─ pipelined-cpu/ Vivado 工程（本地目录，不入库）
└─ cpu21_riscv_redirect_int_bpb说明.md 本文档
``` ```
约定：`rtl/` 只放可综合的处理器源码；板级/仿真相关的东西都在 `board/`、 约定：git 只跟踪 `pipelined-cpu/` 下的源文件（`srcs/`、`tools/`、`programs/`、
`testbench/` 下；`testbench/rom/` 里的镜像是测试平台默认加载的那个版本 `create_project.tcl`），Vivado 生成物（`*.xpr`、`*.runs`、`*.sim`、`*.cache`…）由
（已按 MMIO 写 LED 修改），`testbench/programs/` 保留课程原始程序与 RARS 输出。 `.gitignore` 排除。`srcs/rtl/` 只放可综合的处理器源码；板级顶层与约束在 `srcs/board/`、
`srcs/constrs/`；测试平台与 ROM 镜像在 `srcs/tb/`、`srcs/rom/`（镜像是按 MMIO 写 LED
修改过的版本，课程原始程序与 RARS 输出保留在 `programs/`）。
## 已转换的功能 ## 已转换的功能
@@ -46,43 +45,46 @@ risc-v/
- `lui`：加载高位立即数，`rd = imm[31:12] << 12`（按需求补充的扩展指令，标准 opcode `0x37`）。 - `lui`：加载高位立即数，`rd = imm[31:12] << 12`（按需求补充的扩展指令，标准 opcode `0x37`）。
- `sltiu`：I 型 `funct3=011`，立即数符号扩展后按无符号与 rs1 比较。 - `sltiu`：I 型 `funct3=011`，立即数符号扩展后按无符号与 rs1 比较。
- M 扩展乘法（`funct7=0000001`）：`mul`（乘积低 32 位）、`mulh`（有符号×有符号高 32 位）、`mulhsu`（有符号×无符号高 32 位）、`mulhu`（无符号×无符号高 32 位）。 - M 扩展乘法（`funct7=0000001`）：`mul`（乘积低 32 位）、`mulh`（有符号×有符号高 32 位）、`mulhsu`（有符号×无符号高 32 位）、`mulhu`（无符号×无符号高 32 位）。
- M 扩展除法：课程真值表里的 `divu`（`funct3=101`，无符号商）与 `remu`（`funct3=111`，无符号余数）。
以上六条乘法/除法指令都由 **多周期单元** `pipelined-cpu/srcs/rtl/cpu21_riscv_muldiv.v` 完成（见“时序和使用说明”第 7 条），
而不是组合逻辑。
## 指令编码 ## 指令编码
表中的 `opcode` 是控制器使用的五位字段 `IR[6:2]`，不是包含最低两位的 7 位原始 opcode。 表中的 `opcode` 是控制器使用的五位字段 `IR[6:2]`，不是包含最低两位的 7 位原始 opcode。
因此它与标准 RISC-V 指令的低 7 位 opcode 相差右移两位。 因此它与标准 RISC-V 指令的低 7 位 opcode 相差右移两位。
| 指令类别 | opcode | 说明 | | 指令类别 | opcode | 说明 |
| ----------------------------------------------------------- | -------: | -------------------------------------------------------------------------------- | | ----------------------------------------------- | -----: | ----------------------------------------------------------------------------------- |
| R 型 | `0x0c` | add/sub/and/or/xor/slt/sltu/sll/srl/sra | | R 型 | `0x0c` | add/sub/and/or/xor/slt/sltu/sll/srl/sra |
| M 扩展（R 型） | `0x0c` | `funct7=0000001`：mul/mulh/mulhsu/mulhu（另有课程约定的 remu，`funct3=111`） | | M 扩展（R 型） | `0x0c` | `funct7=0000001`：mul/mulh/mulhsu/mulhu、divu（`funct3=101`）、remu（`funct3=111`） |
| I 型 ALU | `0x04` | addi/andi/ori/xori/slti/sltiu/slli/srli/srai | | I 型 ALU | `0x04` | addi/andi/ori/xori/slti/sltiu/slli/srli/srai |
| `lui`（扩展） | `0x0d` | 加载高位立即数，`rd = imm[31:12] << 12` | | `lui`（扩展） | `0x0d` | 加载高位立即数，`rd = imm[31:12] << 12` |
| `lw` | `0x00` | `funct3=010` | | `lw` | `0x00` | `funct3=010` |
| `sw` / `sb` | `0x08` | `funct3=010` / `000` | | `sw` / `sb` | `0x08` | `funct3=010` / `000` |
| `beq` / `bne` / `blt` / `bge` / `bltu` / `bgeu` | `0x18` | `funct3=000` / `001` / `100` / `101` / `110` / `111` | | `beq` / `bne` / `blt` / `bge` / `bltu` / `bgeu` | `0x18` | `funct3=000` / `001` / `100` / `101` / `110` / `111` |
| `jal` | `0x1b` | J 型立即数 | | `jal` | `0x1b` | J 型立即数 |
| `jalr` | `0x19` | `funct3=000` | | `jalr` | `0x19` | `funct3=000` |
| 系统类 | `0x1c` | `ecall`、`URET`、CSRRSI、CSRRCI | | 系统类 | `0x1c` | `ecall`、`URET`、CSRRSI、CSRRCI |
`ecall` 和 `URET` 都是 `opcode=0x1c、funct3=0`，由 `IR[21]` 区分： `ecall` 和 `URET` 都是 `opcode=0x1c、funct3=0`，由 `IR[21]` 区分：
`IR[21]=0` 是 `ecall`，`IR[21]=1` 是 `URET`。这一点来自原控制器中的 `IR21` 分支逻辑。 `IR[21]=0` 是 `ecall`，`IR[21]=1` 是 `URET`。这一点来自原控制器中的 `IR21` 分支逻辑。
## MMIO 与外设 ## MMIO 与外设
外设寄存器映射在数据存储器地址空间，由 `rtl/cpu21_mmio.v` 在 MEM 级译码， 外设寄存器映射在数据存储器地址空间，由 `pipelined-cpu/srcs/rtl/cpu21_mmio.v` 在 MEM 级译码，
顶层参数 `LED_ADDR`（默认 `0x0000_1000`）指定 LED 数据寄存器的地址。 顶层参数 `LED_ADDR`（默认 `0x0000_1000`）指定 LED 数据寄存器的地址。
该地址位于 4 KB 数据 RAM（`0x0000`–`0x0FFC`）之外，因此不会与 RAM 冲突。 该地址位于 4 KB 数据 RAM（`0x0000`–`0x0FFC`）之外，因此不会与 RAM 冲突。
| 地址 | 外设 | 写 | 读 | | 地址 | 外设 | 写 | 读 |
| --------------- | -------------- | ------------------------------------------------------------------------------------ | ---------------------------- | | ------------- | -------------- | ---------------------------------------------------------------------------- | -------------------------- |
| `0x0000_1000` | LED 数据寄存器 | `sw` 写全字；`sb` 按 `data_wstrb_o` 只改对应字节通道，`led_valid_o` 拉高一拍 | `lw` 返回 LED 寄存器当前值 | | `0x0000_1000` | LED 数据寄存器 | `sw` 写全字；`sb` 按 `data_wstrb_o` 只改对应字节通道，`led_valid_o` 拉高一拍 | `lw` 返回 LED 寄存器当前值 |
地址译码按**字**对齐：同一 32 位寄存器内的任意字节偏移（如 `0x1001`）都算命中， 地址译码按**字**对齐：同一 32 位寄存器内的任意字节偏移（如 `0x1001`）都算命中，
具体修改哪几个字节由 `data_wstrb_o` 决定。`data_addr_o` 在命中 MMIO 时不会 具体修改哪几个字节由 `data_wstrb_o` 决定。`data_addr_o` 在命中 MMIO 时不会
访问外部 RAM；读数据由 `cpu21_mmio` 的输出在顶层与 `data_rdata_i` 做选择。 访问外部 RAM；读数据由 `cpu21_mmio` 的输出在顶层与 `data_rdata_i` 做选择。
典型用法（LED 写 `0x12345678`，可用 `tools/rv_asm.py` 汇编）： 典型用法（LED 写 `0x12345678`，可用 `pipelined-cpu/tools/rv_asm.py` 汇编）：
```asm ```asm
lui t0, 0x1 # t0 = LED_ADDR = 0x00001000 lui t0, 0x1 # t0 = LED_ADDR = 0x00001000
@@ -92,9 +94,9 @@ risc-v/
lw a0, 0(t0) # MMIO 读回 lw a0, 0(t0) # MMIO 读回
``` ```
`testbench/programs/mmio_test.asm`（期望值见 `mmio_test.expected`）覆盖了 `pipelined-cpu/programs/mmio_test.asm`（期望值见 `mmio_test.expected`）覆盖了
全字写、读回、字节写三种情况。加入新外设（拨码开关、UART 等）时只需在 全字写、读回、字节写三种情况。加入新外设（拨码开关、UART 等）时只需在
`rtl/cpu21_mmio.v` 里扩展地址译码，处理器流水线无需改动。 `pipelined-cpu/srcs/rtl/cpu21_mmio.v` 里扩展地址译码，处理器流水线无需改动。
## 顶层端口约定 ## 顶层端口约定
@@ -115,33 +117,35 @@ risc-v/
4. 默认 BPB 新表项采用弱不跳转/弱跳转状态：首次更新为不跳转时计数器为 `01`，首次更新为跳转时为 `10`；命中后按 2 位饱和规则增减。 4. 默认 BPB 新表项采用弱不跳转/弱跳转状态：首次更新为不跳转时计数器为 `01`，首次更新为跳转时为 `10`；命中后按 2 位饱和规则增减。
5. `bpb_predict_hit_o`、`bpb_predict_taken_o`、`bpb_mispredict_o` 和 `irq_*_o` 是观测端口，不参与外部控制，可以直接接逻辑分析仪或测试平台。 5. `bpb_predict_hit_o`、`bpb_predict_taken_o`、`bpb_mispredict_o` 和 `irq_*_o` 是观测端口，不参与外部控制，可以直接接逻辑分析仪或测试平台。
6. `cycle_count_o` 在 `halted_o` 为高时暂停；load-use 每次计入一个气泡，重定向或中断清空 IF/ID 与当前 IF 时计入两个气泡。 6. `cycle_count_o` 在 `halted_o` 为高时暂停；load-use 每次计入一个气泡，重定向或中断清空 IF/ID 与当前 IF 时计入两个气泡。
7. 乘除法是多周期指令：结果算完之前 `ex_md_stall` 有效，ID/EX 保持（指令继续占用 EX）、EX/MEM 插气泡、取指/译码冻结，同时屏蔽中断（避免结果未定型就写回）。一次乘/除共占用 34 拍（1 拍装载 + 32 拍迭代 + 1 拍定型），这些等待周期也计入 `stall_count_o` / `bubble_count_o`。乘除法迭代期间不会把错误值写进 rd，也不会因为中断被打断。
原 `.circ` 文件中的 ROM、MIPS RAM、按钮、LED 和调试显示器属于 Logisim 外围，不直接搬入 RTL；其功能分别由指令接口、数据接口、`go_i`、MMIO（`led_data_o`/`led_valid_o`）和调试端口替代。 原 `.circ` 文件中的 ROM、MIPS RAM、按钮、LED 和调试显示器属于 Logisim 外围，不直接搬入 RTL；其功能分别由指令接口、数据接口、`go_i`、MMIO（`led_data_o`/`led_valid_o`）和调试端口替代。
## 文件与模块划分 ## 文件与模块划分
| 文件 | 模块 | 职责 | | 文件 | 模块 | 职责 |
| ----------------------------------------------- | ----------------------------------- | --------------------------------------------------------------------- | | --------------------------------------------------------- | --------------------------------- | ---------------------------------------------------------------------------------- |
| `rtl/cpu21_riscv_redirect_int_bpb.v` | `cpu21_riscv_redirect_int_bpb` | 顶层：五级流水寄存器、子模块例化、PC/IF-ID/ID-EX 控制、对外输出 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_redirect_int_bpb.v` | `cpu21_riscv_redirect_int_bpb` | 顶层：五级流水寄存器、子模块例化、PC/IF-ID/ID-EX 控制、对外输出 |
| `rtl/cpu21_riscv_alu.v` | `cpu21_riscv_alu` | 组合 ALU（`result2` 用于 MUL 高位 / DIVU 余数） | | `pipelined-cpu/srcs/rtl/cpu21_riscv_alu.v` | `cpu21_riscv_alu` | 组合 ALU（加减/移位/逻辑/比较，不做乘除） |
| `rtl/cpu21_bpb_8.v` | `cpu21_bpb_8` | 8 项全相联分支目标缓冲（2 位饱和计数器 + 近似 LRU） | | `pipelined-cpu/srcs/rtl/cpu21_riscv_muldiv.v` | `cpu21_riscv_muldiv` | 多周期乘除法单元：32 拍移位迭代，mul/mulh/mulhsu/mulhu/divu/remu |
| `rtl/cpu21_riscv_decoder.v` | `cpu21_riscv_decoder` | ID 级组合译码器（操作码`IR[6:2]`） | | `pipelined-cpu/srcs/rtl/cpu21_bpb_8.v` | `cpu21_bpb_8` | 8 项全相联分支目标缓冲（2 位饱和计数器 + 近似 LRU） |
| `rtl/cpu21_riscv_regfile.v` | `cpu21_riscv_regfile` | 寄存器堆，`x0` 恒为 0，同周期 WB 写优先旁路 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_decoder.v` | `cpu21_riscv_decoder` | ID 级组合译码器（操作码`IR[6:2]`） |
| `rtl/cpu21_riscv_forward_unit.v` | `cpu21_riscv_forward_unit` | EX 级前递网络（EX/MEM 优先于 MEM/WB） | | `pipelined-cpu/srcs/rtl/cpu21_riscv_regfile.v` | `cpu21_riscv_regfile` | 寄存器堆，`x0` 恒为 0，同周期 WB 写优先旁路 |
| `rtl/cpu21_riscv_store_unit.v` | `cpu21_riscv_store_unit` | EX 级存储数据对齐：`sw`/`sb` 的写数据与字节写掩码 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_forward_unit.v` | `cpu21_riscv_forward_unit` | EX 级前递网络（EX/MEM 优先于 MEM/WB） |
| `rtl/cpu21_riscv_branch_unit.v` | `cpu21_riscv_branch_unit` | EX 级控制流裁决：分支方向/目标、JAL/JALR 重定向 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_store_unit.v` | `cpu21_riscv_store_unit` | EX 级存储数据对齐：`sw`/`sb` 的写数据与字节写掩码 |
| `rtl/cpu21_riscv_hazard_unit.v` | `cpu21_riscv_hazard_unit` | load-use 冒险、停顿（stall）与冲刷（flush）判定 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_branch_unit.v` | `cpu21_riscv_branch_unit` | EX 级控制流裁决：分支方向/目标、JAL/JALR 重定向 |
| `rtl/cpu21_riscv_irq_ctrl.v` | `cpu21_riscv_irq_ctrl` | 中断采样与优先级、`ustatus`/`uepc` CSR、嵌套返回栈 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_hazard_unit.v` | `cpu21_riscv_hazard_unit` | load-use 冒险、停顿（stall）与冲刷（flush）判定 |
| `rtl/cpu21_riscv_perf_counters.v` | `cpu21_riscv_perf_counters` | 周期/停顿/气泡/分支/预测成功率等统计计数器 | | `pipelined-cpu/srcs/rtl/cpu21_riscv_irq_ctrl.v` | `cpu21_riscv_irq_ctrl` | 中断采样与优先级、`ustatus`/`uepc` CSR、嵌套返回栈 |
| `rtl/cpu21_mmio.v` | `cpu21_mmio` | MMIO 外设：LED 数据寄存器（可写、可读回，支持字节写） | | `pipelined-cpu/srcs/rtl/cpu21_riscv_perf_counters.v` | `cpu21_riscv_perf_counters` | 周期/停顿/气泡/分支/预测成功率等统计计数器 |
| `board/cpu21_board_top.v` | `cpu21_board_top` | 板级顶层：时钟分频、复位同步、片内 ROM/RAM、引脚外设连接 | | `pipelined-cpu/srcs/rtl/cpu21_mmio.v` | `cpu21_mmio` | MMIO 外设：LED 数据寄存器（可写、可读回，支持字节写） |
| `board/cpu21_board_top.xdc` | — | Nexys4DDR 引脚约束 + 分频时钟（`create_generated_clock`） | | `pipelined-cpu/srcs/board/cpu21_board_top.v` | `cpu21_board_top` | 板级顶层：时钟分频、复位同步、片内 ROM/RAM、引脚外设连接 |
| `board/cpu21_board_rom.vh` | — | 片内 ROM 内容（生成文件，`rom[i] = 32'h…;`） | | `pipelined-cpu/srcs/constrs/cpu21_board_top.xdc` | — | Nexys4DDR 引脚约束 + 分频时钟（`create_generated_clock`） |
| `testbench/tb_board_top.v` | `tb_board_top` | 板级顶层的 RTL 仿真（观察 LED 跑马灯与写入指示） | | `pipelined-cpu/srcs/board/cpu21_board_rom.vh` | — | 片内 ROM 内容（生成文件，`rom[i] = 32'h…;`） |
| `testbench/tb_no_intr.v` | `tb_no_intr` | 无中断测试平台（指令集/MMIO 测试，默认加载 benchmark 镜像） | | `pipelined-cpu/srcs/tb/tb_board_top.v` | `tb_board_top` | 板级顶层的 RTL 仿真（观察 LED 跑马灯与写入指示） |
| `testbench/tb_cpu21_riscv_redirect_int_bpb.v` | `tb_cpu21_riscv_redirect_int_bpb` | 中断与分支预测测试平台（默认加载中断测试镜像） | | `pipelined-cpu/srcs/tb/tb_no_intr.v` | `tb_no_intr` | 无中断测试平台（指令集/MMIO 测试，默认加载 benchmark 镜像） |
| `tools/rv_asm.py` | — | 迷你汇编器：`.asm` → 机器码 hex（`.lst` 带反汇编清单） | | `pipelined-cpu/srcs/tb/tb_cpu21_riscv_redirect_int_bpb.v` | `tb_cpu21_riscv_redirect_int_bpb` | 中断与分支预测测试平台（默认加载中断测试镜像） |
| `tools/hex2vh.py` | — | hex →`board/cpu21_board_rom.vh`（`rom[i] = 32'h…;` 初始化语句） | | `pipelined-cpu/tools/rv_asm.py` | — | 迷你汇编器：`.asm` → 机器码 hex（`.lst` 带反汇编清单） |
| `pipelined-cpu/tools/hex2vh.py` | — | hex →`pipelined-cpu/srcs/board/cpu21_board_rom.vh`（`rom[i] = 32'h…;` 初始化语句） |
拆分只调整了模块边界与文件组织，端口、时序与行为完全等价：使用同一 ROM 程序 拆分只调整了模块边界与文件组织，端口、时序与行为完全等价：使用同一 ROM 程序
在 xsim 下对拆分前后逐周期对比，波形输出与最终统计（周期、停顿、气泡、分支 在 xsim 下对拆分前后逐周期对比，波形输出与最终统计（周期、停顿、气泡、分支
@@ -157,35 +161,41 @@ BPB/中断观测值）。如果直接把它设为实现顶层，这些端口会
### 引脚分配（`cpu21_board_top.xdc`） ### 引脚分配（`cpu21_board_top.xdc`）
| 端口 | 引脚 | 板上元件 | 说明 | | 端口 | 引脚 | 板上元件 | 说明 |
| --------------- | ----------- | ------------------------- | -------------------------------------------------- | | ------------- | ----------- | ------------------------- | ---------------------------------------------- |
| `clk100` | E3 | 100 MHz 晶振 | 经`CLK_DIV` 分频后给 CPU | | `clk100` | E3 | 100 MHz 晶振 | 经`CLK_DIV` 分频后给 CPU |
| `rst_n` | C12 | 按键 CPU_RESETN（低有效） | 异步置位、与 CPU 时钟同步释放 | | `rst_n` | C12 | 按键 CPU_RESETN（低有效） | 异步置位、与 CPU 时钟同步释放 |
| `go` | N17 | 按键 BTNC | 对应原电路“继续运行”（`ecall` 停机后恢复执行） | | `go` | N17 | 按键 BTNC | 对应原电路“继续运行”（`ecall` 停机后恢复执行） |
| `irq_sw[2:0]` | J15/L16/M13 | 拨码开关 SW0–SW2 | 三路中断源，拨动即触发（内部同步并锁存） | | `irq_sw[2:0]` | J15/L16/M13 | 拨码开关 SW0–SW2 | 三路中断源，拨动即触发（内部同步并锁存） |
| `led[15:0]` | H17…V11 | LED0–LED15 | MMIO（`LED_ADDR`）写入值的低 16 位 | | `led[15:0]` | H17…V11 | LED0–LED15 | MMIO（`LED_ADDR`）写入值的低 16 位 |
| `led_we` | R12 | LED16_B | MMIO 写入指示，每写一次拉长约 2.7 s | | `led_we` | R12 | LED16_B | MMIO 写入指示，每写一次拉长约 2.7 s |
### 时钟：为什么要把 100 MHz 分频 ### 时钟：为什么还保留 2 分频
ALU 里的除法/取余（`a % b`）和 MUL 高位是纯组合电路。实测综合后在 乘除法原本是 ALU 里的组合运算（`a*b`、`a%b`），实测关键路径约 94 ns（325 级逻辑、
100 MHz 下 `WNS = -84.126 ns`（关键路径 `ex_mem_pc → ex_mem_alu_result2`， 286 个 CARRY4），在 100 MHz 下必然不收敛，所以之前只能把时钟 16 分频到 6.25 MHz。
325 级逻辑、286 个 CARRY4），不可能收敛。因此 `cpu21_board_top` 用 现在乘除法改成了 `pipelined-cpu/srcs/rtl/cpu21_riscv_muldiv.v` 里的 **32 拍迭代多周期单元**，关键路径上
`CLK_DIV = 16` 把 100 MHz 分频到 6.25 MHz（周期 160 ns）给 CPU， 不再有组合乘/除，也不需要再分频了；但把所有加法器/比较器都换成迭代后，在 100 MHz
`clk100` 只用于分频器本身： 下仍有约 1.1 ns 的违例——那是 **EX 级“分支判决 / 中断保存 → BPB 更新”这条与乘除法
无关的组合路径**（逻辑只占约 3 ns，剩下 7~8 ns 全是布线）。
```verilog 因此在 `cpu21_board_top` 里保留一个参数化的分频器 `CLK_DIV`，默认取 **2（50 MHz，
cpu21_board_top #(.CLK_DIV(16)) u_board ( ... ); 周期 20 ns）**，既比原来的 16 分频快 8 倍，又留出充足余量：
```
| 配置 | CPU 时钟 | 实测 WNS（xc7a100tcsg324-1） | 说明 |
| ------------ | -------- | ---------------------------- | ------------------------------------- |
| `CLK_DIV=1` | 100 MHz | -1.1 ns ✗ | 违例路径与乘除法无关（分支/中断/BPB） |
| `CLK_DIV=2` | 50 MHz | **+5.1 ns** ✓ | 默认，余量约 25% |
| `CLK_DIV=16` | 6.25 MHz | +6.1 ns ✓ | 改造前的设置，现在没必要了 |
分频后的时钟在综合/实现时由 Vivado 自动插入 BUFG 走全局时钟网络（RTL 里不例化 分频后的时钟在综合/实现时由 Vivado 自动插入 BUFG 走全局时钟网络（RTL 里不例化
`BUFG` 原语，这样在不认识 Xilinx 原语的仿真器里也能直接仿真）。XDC 中必须用 `BUFG` 原语，这样在不认识 Xilinx 原语的仿真器里也能直接仿真）。XDC 中必须用
`create_generated_clock` 声明这个分频时钟，否则时序分析仍按 10 ns 去要求 CPU `create_generated_clock` 声明这个分频时钟，否则时序分析会按 10 ns 去要求 CPU
内部路径而误报大量违例： 内部路径而误报大量违例：
```tcl ```tcl
create_generated_clock -name cpu_clk -source [get_ports { clk100 }] \ create_generated_clock -name cpu_clk -source [get_ports { clk100 }] \
-divide_by 16 [get_pins { clk_div_reg/Q }] -divide_by 2 [get_pins { clk_div_reg/Q }]
``` ```
改分频比时 RTL 的 `CLK_DIV` 与 XDC 的 `-divide_by` 要同时改。 改分频比时 RTL 的 `CLK_DIV` 与 XDC 的 `-divide_by` 要同时改。
@@ -204,34 +214,39 @@ create_generated_clock -name cpu_clk -source [get_ports { clk100 }] \
### 演示程序的生成与仿真 ### 演示程序的生成与仿真
```powershell ```powershell
# 1) 汇编 + 生成 ROM 初始化文件（在仓库根目录执行） # 在工程目录 pipelined-cpu/ 下执行：
python tools/rv_asm.py testbench/programs/board_demo.asm _tmp/board_demo.hex # 1) 汇编 + 生成 ROM 初始化文件
python tools/hex2vh.py _tmp/board_demo.hex board/cpu21_board_rom.vh 1024 python tools/rv_asm.py programs/board_demo.asm _tmp/board_demo.hex
python tools/hex2vh.py _tmp/board_demo.hex srcs/board/cpu21_board_rom.vh 1024
# 2) 上板顶层的 RTL 仿真（默认程序延时约 20 ms，只需确认第一次写入 LED=0001） # 2) 上板顶层的 RTL 仿真（默认程序延时约 20 ms，只需确认第一次写入 LED=0001）
xvlog rtl/*.v board/cpu21_board_top.v testbench/tb_board_top.v xvlog srcs/rtl/*.v srcs/board/cpu21_board_top.v srcs/tb/tb_board_top.v
xelab -top tb_board_top -snapshot board_sim xelab -top tb_board_top -snapshot board_sim
xsim board_sim -tclbatch run_quit.tcl xsim board_sim -tclbatch run_quit.tcl
``` ```
`board_demo.asm` 是一段 16 步跑马灯（`0001 → 0002 → … → 8000 → 0001`）， `board_demo.asm` 是一段 16 步跑马灯（`0001 → 0002 → … → 8000 → 0001`），
每步之间用软件循环延时约 20 ms（6.25 MHz 下）。仓库里同时提供了两份 ROM 初始化 每步之间用软件循环延时约 20 ms（50 MHz 下）。仓库里同时提供了两份 ROM 初始化
文件，由 `BOARD_ROM_FAST` 宏选择（综合流程不会定义该宏）： 文件，由 `BOARD_ROM_FAST` 宏选择（综合流程不会定义该宏）：
| 文件 | 用途 | 每步耗时 | | 文件 | 用途 | 每步耗时 |
| --------------------------------- | ------------------------------ | -------- | | -------------------------------------------------- | ------------------------------ | -------- |
| `board/cpu21_board_rom.vh` | 综合/上板（默认） | 约 20 ms | | `pipelined-cpu/srcs/board/cpu21_board_rom.vh` | 综合/上板（默认） | 约 20 ms |
| `board/cpu21_board_rom_fast.vh` | 仅仿真：一次跑完整个跑马灯序列 | 4.8 µs | | `pipelined-cpu/srcs/board/cpu21_board_rom_fast.vh` | 仅仿真：一次跑完整个跑马灯序列 | 2.6 µs |
```powershell ```powershell
# 快速版仿真：编译时加上 -d BOARD_ROM_FAST（注意 xvlog/elaborate 都要带） # 快速版仿真：编译时加上 -d BOARD_ROM_FAST（xvlog 与 xelab 都要带）
xvlog -d BOARD_ROM_FAST rtl/*.v board/cpu21_board_top.v testbench/tb_board_top.v xvlog -d BOARD_ROM_FAST srcs/rtl/*.v srcs/board/cpu21_board_top.v srcs/tb/tb_board_top.v
xelab -top tb_board_top -snapshot board_sim_fast -d BOARD_ROM_FAST xelab -top tb_board_top -snapshot board_sim_fast -d BOARD_ROM_FAST
``` ```
两份文件都由同样的两步生成，只有延时循环的初值不同（把 `board_demo.asm` 里的 两份 ROM 初始化文件由 `programs/board_demo.asm`（默认，≈ 20 ms/步）与
`lui t2, 0xf` 换成 `addi t2, zero, 8` 再照上面两步走一遍，输出到 `programs/board_demo_fast.asm`（快速版，≈ 2.6 µs/步，只差延时循环的初值）生成：
`board/cpu21_board_rom_fast.vh`）。
```powershell
python tools/rv_asm.py programs/board_demo_fast.asm _tmp/board_demo_fast.hex
python tools/hex2vh.py _tmp/board_demo_fast.hex srcs/board/cpu21_board_rom_fast.vh 1024
```
### Vivado 工程设置与实现结果 ### Vivado 工程设置与实现结果
@@ -239,22 +254,110 @@ Vivado 工程 `pipelined-cpu/pipelined-cpu.xpr` 被 `.gitignore` 排除，需要
1. `sources_1` 顶层设为 `cpu21_board_top`（纯 RTL 仿真时也可切回 1. `sources_1` 顶层设为 `cpu21_board_top`（纯 RTL 仿真时也可切回
`cpu21_riscv_redirect_int_bpb`）； `cpu21_riscv_redirect_int_bpb`）；
2. 加入 `board/cpu21_board_top.v`、`board/cpu21_board_top.xdc`， 2. 加入 `pipelined-cpu/srcs/board/cpu21_board_top.v`、`pipelined-cpu/srcs/constrs/cpu21_board_top.xdc`，
`board/cpu21_board_rom.vh` 的文件类型设成 `Verilog Header`（不能当普通源码， `pipelined-cpu/srcs/board/cpu21_board_rom.vh` 的文件类型设成 `Verilog Header`（不能当普通源码，
否则会被当成顶层候选）； 否则会被当成顶层候选）；
3. 三个 testbench（`testbench/tb_cpu21_riscv_redirect_int_bpb.v`、`tb_no_intr.v`、 3. 三个 testbench 放在**仿真 fileset**（`sim_1` 顶层 `tb_cpu21_riscv_redirect_int_bpb`、
`tb_board_top.v`）的 `USED_IN_SYNTHESIS` / `USED_IN_IMPLEMENTATION` 设为 `0`， `sim_2` 顶层 `tb_no_intr`），不参与综合，因此不会再出现“testbench 被当成顶层”
否则综合可能把 testbench 当顶层，报 `[Place 30-494] The design is empty`。 导致的 `[Place 30-494] The design is empty`。
`xc7a100tcsg324-1` 上的实现结果（`CLK_DIV=16`）： `xc7a100tcsg324-1` 上的实现结果（乘除法改为多周期单元、`CLK_DIV=2` = 50 MHz）：
| 项目 | 结果 | | 项目 | 结果 |
| -------- | --------------------------------------------------------------------------- | | -------- | -------------------------------------------------------------------------------------------- |
| 综合 | `synth_design Complete!` | | 综合 | `synth_design Complete!` |
| 实现 | `route_design Complete!`，`WNS = +6.083 ns`（无 Failed Timing） | | 实现 | `route_design Complete!`、`write_bitstream Complete!`，`WNS = +5.109 ns`（无 Failed Timing） |
| 资源 | LUT 5400 (8.52%)、LUTRAM 512、FF 2507 (1.98%)、DSP 12 (5%)、IOB 23 (10.95%) | | 资源 | LUT 3420 (5.39%)、FF 2507、**DSP 0**（组合乘法器已消失）、IOB 23 (10.95%) |
| bit 文件 | `pipelined-cpu/pipelined-cpu.runs/impl_1/cpu21_board_top.bit` | | bit 文件 | `pipelined-cpu/pipelined-cpu.runs/impl_1/cpu21_board_top.bit` |
对比改造前（组合乘除法 + `CLK_DIV=16`）：LUT 5400 → 3420、DSP 12 → 0、
CPU 时钟 6.25 MHz → 50 MHz（快 8 倍），并且乘除法不再位于关键路径上。
上板操作：用 Vivado 打开工程 → `Open Hardware Manager` → `Program Device`，选上述 上板操作：用 Vivado 打开工程 → `Open Hardware Manager` → `Program Device`，选上述
`.bit`。复位后跑马灯立即从 `0001` 开始逐位左移（演示程序不执行 `ecall`，所以不用 `.bit`。复位后跑马灯立即从 `0001` 开始逐位左移（演示程序不执行 `ecall`，所以不用
按 `go`；`go` 只对执行了 `ecall` 停机、等待继续运行的程序有意义），LED16_B 每次写入时点亮。 按 `go`；`go` 只对执行了 `ecall` 停机、等待继续运行的程序有意义），LED16_B 每次写入时点亮。
## 回归测试
工程里带了一个 xsim 回归脚本，在 `pipelined-cpu/` 目录下运行：
```powershell
powershell -ExecutionPolicy Bypass -File tools\run_regress.ps1
```
它会按顺序做四件事：
1. 编译 `srcs/rtl/` 下的处理器源码；
2. 跑 4 个指令测试（`muldiv_test`、`isa_test`、`lui_test`、`mmio_test`），把测试平台
打印的 LED 序列与 `programs/*.expected` 逐值比对；
3. 跑两个流水基线（`tb_no_intr`、`tb_cpu21_riscv_redirect_int_bpb`），打印 FINAL 统计行；
4. 跑板级顶层（`-d BOARD_ROM_FAST`），检查跑马灯 LED 序列。
最后汇总 PASS/FAIL，并以失败数作为退出码。编译与仿真的中间文件都写在
`%TEMP%\cpu21_regress` 下，不会污染工程目录；需要 `xvlog`/`xelab`/`xsim` 在 PATH 上。
期望结果（2026-09，多周期乘除法 + `CLK_DIV=2`）：
| 测试 | 期望 |
| ---- | ---- |
| muldiv_test / isa_test / lui_test / mmio_test | 13 / 24 / 4 / 5 个 LED 值全部匹配 |
| tb_no_intr（benchmark，5560 周期） | `stalls=1528 bubbles=1830 cond_taken=639 uncond=71 pred_ok=687 pred_fail=80` |
| tb_cpu21_riscv_redirect_int_bpb（中断，6003 周期） | `stalls=963 bubbles=1205 cond_taken=547 uncond=28 pred_ok=557 pred_fail=87` |
| 板级（快速 ROM） | 跑马灯 `0001 → … → 8000` 循环，每步约 2.6 µs |
## 工程分享（Tcl 一键重建）
`pipelined-cpu/` 已整理成“自包含 + 可直接分享”的工程目录，设计文件都在里面，
别人拿到整个文件夹后**不需要改任何路径**：
```text
pipelined-cpu/
├─ create_project.tcl 一键重建脚本（用 [info script] 定位自身目录）
├─ srcs/rtl/*.v 处理器 RTL（13 个文件）
├─ srcs/board/*.v|*.vh 板级顶层、片内 ROM 初始化（含 __FAST 仿真版本）
├─ srcs/constrs/*.xdc 引脚约束 + 板级母版
├─ srcs/tb/*.v 三个测试平台
├─ srcs/rom/*.hex 测试平台加载的 ROM 镜像
├─ tools/、programs/ 迷你汇编器与测试程序（重生成 ROM 用）
├─ cpu21_riscv_redirect_int_bpb说明.md
└─ pipelined-cpu.xpr（+ *.runs/…） 本机工程，分享时可删
```
用法（在 Vivado Tcl Shell 里，或命令行 `vivado -mode batch -source create_project.tcl`）：
```tcl
cd <pipelined-cpu 所在目录>
source create_project.tcl
```
脚本会就地创建 `pipelined-cpu.xpr`，并配好：
- `sources_1` 顶层 `cpu21_board_top`（处理器 RTL + 板级顶层 + 片内 ROM 初始化，
`cpu21_board_rom.vh` 标记为 `Verilog Header`）；
- `constrs_1`：`cpu21_board_top.xdc`（引脚 + `CLK_DIV` 分频时钟）与板级母版；
- `sim_1`（顶层 `tb_cpu21_riscv_redirect_int_bpb`）与 `sim_2`（顶层 `tb_no_intr`）；
测试平台会依次探测 ROM 镜像，其中 `../../../../../srcs/rom/` 对应 GUI 仿真的
工作目录（`<proj>.sim/sim_1/behav/xsim`），所以创建完就能直接 `Run Simulation`；
- 两个仿真 fileset 的 `xsim.simulate.runtime` 设为 `all`，避免 GUI 仿真只跑 1000 ns
就停下（看起来像卡死）。
分享前建议删掉生成目录：`*.xpr`、`*.runs`、`*.sim`、`*.cache`、`*.hw`、`*.gen`、
`*.ip_user_files`、`.Xil`。实测只带 `create_project.tcl` + `srcs/` + `pipelined-cpu/tools/` +
`programs/` + 说明文档约 **0.3 MB**，在任意路径重建工程并综合成功。
> 源文件只有一份，就在 `pipelined-cpu/srcs/`（`tools/`、`programs/` 同理），
> 直接在工程目录里改即可，没有需要同步的副本。
也可以用 Vivado 自动生成：
```tcl
write_project_tcl -force -paths_relative_to <工程目录> <工程目录>/create_project.tcl
```
注意自动生成的版本会把源路径写成**生成时的绝对路径**、并且要求 `origin_dir` 指向
工程目录，所以要手动改两行才能给别人用：
```tcl
set origin_dir [file dirname [file normalize [info script]]]
create_project ${_xil_proj_name_} $origin_dir -part xc7a100tcsg324-1
```
pipelined-cpu/create_project.tcl
+106
View File
@@ -0,0 +1,106 @@
# ============================================================================
# cpu21-riscv 流水线 CPU —— 一键重建 Vivado 工程
# FPGA：Nexys4DDR / xc7a100tcsg324-1（Vivado 2025.2 实测通过）
#
# 目录结构（本脚本所在目录就是工程目录）：
# create_project.tcl 本脚本
# srcs/rtl/*.v 处理器 RTL（顶层 cpu21_riscv_redirect_int_bpb）
# srcs/board/*.v|*.vh 板级顶层、片内 ROM 初始化（含 __FAST 仿真版本）
# srcs/constrs/*.xdc 引脚约束与板级母版
# srcs/tb/*.v 测试平台（中断/分支预测、无中断、板级）
# srcs/rom/*.hex 测试平台加载的 ROM 镜像
# tools/、programs/ 迷你汇编器与测试程序（改程序、重生成 ROM 用）
# 说明文档：cpu21_riscv_redirect_int_bpb说明.md
#
# 用法：
# 1) 建议先删掉本目录下的 pipelined-cpu.xpr，以及 *.runs / *.sim / *.cache /
# *.hw / *.gen / *.ip_user_files 等生成目录（不删会在下面报错提示）；
# 2) 在 Vivado Tcl Shell 里执行： source create_project.tcl
# 或命令行： vivado -mode batch -source create_project.tcl -log create.log
# 3) 工程就地创建：pipelined-cpu.xpr（源文件仍在 srcs/ 下，不会被搬动）。
#
# 脚本用 [info script] 定位自身目录，所以整个文件夹拷到任何路径都能直接用。
# 若想用 Vivado 自动生成的版本，见说明文档“工程分享”一节。
# ============================================================================
set origin_dir [file dirname [file normalize [info script]]]
set proj_name "pipelined-cpu"
set part_name "xc7a100tcsg324-1"
# ---------------------------------------------------------------- 自检
set required [list \
"$origin_dir/srcs/board/cpu21_board_top.v" \
"$origin_dir/srcs/board/cpu21_board_rom.vh" \
"$origin_dir/srcs/board/cpu21_board_rom_fast.vh" \
"$origin_dir/srcs/constrs/cpu21_board_top.xdc" \
"$origin_dir/srcs/tb/tb_cpu21_riscv_redirect_int_bpb.v" \
"$origin_dir/srcs/tb/tb_no_intr.v" \
"$origin_dir/srcs/tb/tb_board_top.v"]
set missing {}
foreach f $required { if {![file exists $f]} { lappend missing $f } }
if {[llength [glob -nocomplain "$origin_dir/srcs/rtl/*.v"]] == 0} {
lappend missing "$origin_dir/srcs/rtl/*.v"
}
if {[llength $missing] > 0} {
puts "ERROR: 缺少下列文件，请确认 srcs/ 目录完整："
foreach f $missing { puts " $f" }
return 1
}
if {[file exists "$origin_dir/$proj_name.xpr"]} {
puts "ERROR: 工程已存在：$origin_dir/$proj_name.xpr"
puts " 请先删除 .xpr（以及 *.runs / *.sim 等生成目录）后重跑本脚本。"
return 1
}
# ---------------------------------------------------------------- 建工程
create_project $proj_name $origin_dir -part $part_name
# 设计源文件：处理器 RTL + 板级顶层 + 片内 ROM 初始化
add_files -norecurse -fileset sources_1 [glob "$origin_dir/srcs/rtl/*.v"]
add_files -norecurse -fileset sources_1 [list \
"$origin_dir/srcs/board/cpu21_board_top.v" \
"$origin_dir/srcs/board/cpu21_board_rom.vh"]
set_property file_type {Verilog Header} \
[get_files "$origin_dir/srcs/board/cpu21_board_rom.vh"]
# 约束（cpu21_board_top.xdc 是引脚与分频时钟约束）
add_files -norecurse -fileset constrs_1 [glob "$origin_dir/srcs/constrs/*.xdc"]
# 仿真文件：测试平台 + ROM 镜像 + 快速版 ROM 头文件
add_files -norecurse -fileset sim_1 [list \
"$origin_dir/srcs/tb/tb_cpu21_riscv_redirect_int_bpb.v" \
"$origin_dir/srcs/tb/tb_no_intr.v" \
"$origin_dir/srcs/tb/tb_board_top.v" \
"$origin_dir/srcs/board/cpu21_board_rom_fast.vh"]
add_files -norecurse -fileset sim_1 [glob "$origin_dir/srcs/rom/*.hex"]
set_property file_type {Verilog Header} \
[get_files "$origin_dir/srcs/board/cpu21_board_rom_fast.vh"]
# 第二个仿真 fileset：无中断测试平台（tb_no_intr）
create_fileset -simset sim_2
add_files -norecurse -fileset sim_2 [list \
"$origin_dir/srcs/tb/tb_no_intr.v" \
"$origin_dir/srcs/tb/tb_cpu21_riscv_redirect_int_bpb.v"]
# ---------------------------------------------------------------- 顶层与顺序
set_property top cpu21_board_top [get_filesets sources_1]
set_property top tb_cpu21_riscv_redirect_int_bpb [get_filesets sim_1]
set_property top tb_no_intr [get_filesets sim_2]
update_compile_order -fileset sources_1
update_compile_order -fileset sim_1
update_compile_order -fileset sim_2
# GUI 仿真默认只跑 1000 ns，这里改成跑完（否则看起来像卡住）
foreach fs {sim_1 sim_2} {
catch { set_property -name {xsim.simulate.runtime} -value {all} -objects [get_filesets $fs] }
}
# ---------------------------------------------------------------- 结果汇总
puts "工程已创建：$origin_dir/$proj_name.xpr"
puts " sources_1 顶层 = cpu21_board_top（上板：时钟分频 + 片内 ROM/RAM + 引脚）"
puts " sim_1 顶层 = tb_cpu21_riscv_redirect_int_bpb（中断/分支预测）"
puts " sim_2 顶层 = tb_no_intr（指令集测试，ROM 镜像在 srcs/rom/）"
puts " 下一步：Run Synthesis → Run Implementation → Generate Bitstream，或 Run Simulation"
puts " 提示：CPU 时钟 = 100 MHz / CLK_DIV（默认 2）= 50 MHz；改分频比时"
puts " cpu21_board_top.v 的 CLK_DIV 与 cpu21_board_top.xdc 的 -divide_by 要一起改。"
testbench/programs/board_demo.asm → pipelined-cpu/programs/board_demo.asm
+2 -2
View File
@@ -13,8 +13,8 @@ main_loop:
restart: restart:
addi t1, zero, 1 addi t1, zero, 1
delay: # 软件延时，让人眼能看到跑马灯（6.25 MHz 下约 20 ms） delay: # 软件延时，让人眼能看到跑马灯（50 MHz 下约 20 ms）
lui t2, 0xf # 延时计数 0x0000F000 lui t2, 0x7a # 延时计数 0x0007A000 ≈ 5e5 次循环
addi t3, zero, 1 addi t3, zero, 1
delay_loop: delay_loop:
sub t2, t2, t3 sub t2, t2, t3
pipelined-cpu/programs/board_demo_fast.asm
+25
View File
@@ -0,0 +1,25 @@
# 上板演示程序的**快速版**（仅仿真用）：与 board_demo.asm 只差延时循环的初值——
# 从 `lui t2, 0x7a`（≈ 20 ms/步）改成 `addi t2, zero, 64`（≈ 2.6 µs/步 @50 MHz），
# 这样一次仿真（tb_board_top，300 µs 窗口）就能看完整个跑马灯序列。
# 重新生成：python tools/rv_asm.py programs/board_demo_fast.asm _tmp/board_demo_fast.hex
# python tools/hex2vh.py _tmp/board_demo_fast.hex srcs/board/cpu21_board_rom_fast.vh 1024
# 综合时用 -d BOARD_ROM_FAST 才会选到它（见 srcs/board/cpu21_board_top.v）。
lui t0, 0x1 # t0 = LED_ADDR = 0x00001000
addi t1, zero, 1 # 跑马灯初值：bit0
main_loop:
sw t1, 0(t0) # MMIO 写 LED -> 板载 LED[15:0]
slli t1, t1, 1 # 左移一位
lui t4, 0x8 # t4 = 0x00008000
bltu t4, t1, restart # 移出 16 位后重新开始
jal zero, delay
restart:
addi t1, zero, 1
delay: # 短延时（仿真用，人眼看不见）
addi t2, zero, 64 # 延时计数 64 次循环
addi t3, zero, 1
delay_loop:
sub t2, t2, t3
bne t2, zero, delay_loop
jal zero, main_loop
testbench/programs/isa_test.asm → pipelined-cpu/programs/isa_test.asm
View File
testbench/programs/isa_test.expected → pipelined-cpu/programs/isa_test.expected
View File
testbench/programs/lui_test.asm → pipelined-cpu/programs/lui_test.asm
View File
testbench/programs/lui_test.expected → pipelined-cpu/programs/lui_test.expected
View File
testbench/programs/mmio_test.asm → pipelined-cpu/programs/mmio_test.asm
View File
testbench/programs/mmio_test.expected → pipelined-cpu/programs/mmio_test.expected
View File
pipelined-cpu/programs/muldiv_test.asm
+95
View File
@@ -0,0 +1,95 @@
# 乘除法（多周期单元）测试：每个结果都写给 MMIO 的 LED 寄存器，供测试平台比对。
# 期望输出顺序见同目录 muldiv_test.expected（共 13 个值）。
#
# ① mul 7 * 6 = 42 -> 0000002a
# ② mul -5 * 4 = -20 -> ffffffec
# ③ mulh 0x40000000 * 4 高 32 位 -> 00000001
# ④ mulhu 0xffffffff * 2 高 32 位 -> 00000001
# ⑤ mulhsu -1 * 0xffffffff 高 32 位 -> ffffffff
# ⑥ divu 100 / 7 = 14 -> 0000000e
# ⑦ remu 100 % 7 = 2 -> 00000002
# ⑧ divu 0xffffffff / 2 = 2147483647 -> 7fffffff
# ⑨ divu 12345 / 0 除零约定 -> ffffffff
# ⑩ remu 12345 % 0 除零约定 -> 00003039
# ⑪ remu 0xffffffff % 16 = 15 -> 0000000f
# ⑫ mul 0x12345678 * 16 低 32 位 -> 23456780
# ⑬ mulh 0x12345678 * 0x1000 高 32 位 -> 00000123
#
# 用法：python tools/rv_asm.py testbench/programs/muldiv_test.asm testbench/rom/muldiv_test.hex
# ① mul：有符号乘法的低 32 位
addi t1, zero, 7
addi t2, zero, 6
mul a0, t1, t2
print
# ② mul：负乘数（低 32 位）
addi t1, zero, -5
addi t2, zero, 4
mul a0, t1, t2
print
# ③ mulh：正数相乘，高 32 位不为 0
lui t1, 0x40000
addi t2, zero, 4
mulh a0, t1, t2
print
# ④ mulhu：无符号高位（0xffffffff * 2 = 0x1_fffffffe）
addi t1, zero, -1
addi t2, zero, 2
mulhu a0, t1, t2
print
# ⑤ mulhsu：有符号 x 无符号（-1 * 4294967295 = 0xffffffff_00000001）
addi t1, zero, -1
addi t2, zero, -1
mulhsu a0, t1, t2
print
# ⑥ divu：普通除法
addi t1, zero, 100
addi t2, zero, 7
divu a0, t1, t2
print
# ⑦ remu：普通取余
remu a0, t1, t2
print
# ⑧ divu：无符号大数
addi t1, zero, -1
addi t2, zero, 2
divu a0, t1, t2
print
# ⑨ divu：除零（商为全 1）
lui t1, 0x3
addi t1, t1, 0x39 # t1 = 12345
addi t2, zero, 0
divu a0, t1, t2
print
# ⑩ remu：除零（余数为被除数）
remu a0, t1, t2
print
# ⑪ remu：0xffffffff % 16
addi t1, zero, -1
addi t2, zero, 16
remu a0, t1, t2
print
# ⑫ mul：0x12345678 * 16 的低 32 位
lui t1, 0x12345
addi t1, t1, 0x678
addi t2, zero, 16
mul a0, t1, t2
print
# ⑬ mulh：0x12345678 * 0x1000 的高 32 位
lui t2, 0x1
mulh a0, t1, t2
print
halt
pipelined-cpu/programs/muldiv_test.expected
+13
View File
@@ -0,0 +1,13 @@
0000002a
ffffffec
00000001
00000001
ffffffff
0000000e
00000002
7fffffff
ffffffff
00003039
0000000f
23456780
00000123
testbench/programs/rars_f0c874c.jar → pipelined-cpu/programs/rars_f0c874c.jar
View File
testbench/programs/risc-v-benchmark_ccab.asm → pipelined-cpu/programs/risc-v-benchmark_ccab.asm
View File
testbench/programs/risc-v-benchmark_ccab.hex → pipelined-cpu/programs/risc-v-benchmark_ccab.hex
View File
testbench/programs/risc-v-分支预测测试.hex → pipelined-cpu/programs/risc-v-分支预测测试.hex
View File
testbench/programs/risc-v多级中断测试(EPC内存堆栈保护) - ccab.asm → pipelined-cpu/programs/risc-v多级中断测试(EPC内存堆栈保护) - ccab.asm
View File
testbench/programs/risc-v多级中断测试(EPC内存堆栈保护) - ccab.hex → pipelined-cpu/programs/risc-v多级中断测试(EPC内存堆栈保护) - ccab.hex
View File
testbench/programs/真值表.txt → pipelined-cpu/programs/真值表.txt
View File
board/cpu21_board_rom.vh → pipelined-cpu/srcs/board/cpu21_board_rom.vh
+2 -2
View File
@@ -1,5 +1,5 @@
// generated by tools/hex2vh.py - do not edit by hand // generated by tools/hex2vh.py - do not edit by hand
// source: _tmp\board_demo.hex (13 words, remaining entries filled with NOP) // source: _tmp/board_demo.hex (13 words, remaining entries filled with NOP)
rom[0] = 32'h000012B7; rom[0] = 32'h000012B7;
rom[1] = 32'h00100313; rom[1] = 32'h00100313;
rom[2] = 32'h0062A023; rom[2] = 32'h0062A023;
@@ -8,7 +8,7 @@
rom[5] = 32'h006EE463; rom[5] = 32'h006EE463;
rom[6] = 32'h0080006F; rom[6] = 32'h0080006F;
rom[7] = 32'h00100313; rom[7] = 32'h00100313;
rom[8] = 32'h0000F3B7; rom[8] = 32'h0007A3B7;
rom[9] = 32'h00100E13; rom[9] = 32'h00100E13;
rom[10] = 32'h41C383B3; rom[10] = 32'h41C383B3;
rom[11] = 32'hFE039EE3; rom[11] = 32'hFE039EE3;
board/cpu21_board_rom_fast.vh → pipelined-cpu/srcs/board/cpu21_board_rom_fast.vh
+2 -2
View File
@@ -1,5 +1,5 @@
// generated by tools/hex2vh.py - do not edit by hand // generated by tools/hex2vh.py - do not edit by hand
// source: _tmp\board_demo_fast.hex (13 words, remaining entries filled with NOP) // source: _tmp/board_demo_fast.hex (13 words, remaining entries filled with NOP)
rom[0] = 32'h000012B7; rom[0] = 32'h000012B7;
rom[1] = 32'h00100313; rom[1] = 32'h00100313;
rom[2] = 32'h0062A023; rom[2] = 32'h0062A023;
@@ -8,7 +8,7 @@
rom[5] = 32'h006EE463; rom[5] = 32'h006EE463;
rom[6] = 32'h0080006F; rom[6] = 32'h0080006F;
rom[7] = 32'h00100313; rom[7] = 32'h00100313;
rom[8] = 32'h00800393; rom[8] = 32'h04000393;
rom[9] = 32'h00100E13; rom[9] = 32'h00100E13;
rom[10] = 32'h41C383B3; rom[10] = 32'h41C383B3;
rom[11] = 32'hFE039EE3; rom[11] = 32'hFE039EE3;
board/cpu21_board_top.v → pipelined-cpu/srcs/board/cpu21_board_top.v
+22 -15
View File
@@ -9,12 +9,12 @@
// （[Place 30-415] IO Placement failed due to overutilization）。本模块只把 // （[Place 30-415] IO Placement failed due to overutilization）。本模块只把
// 开发板真正需要的外设引出来，其余调试端口不连接，因此不占用引脚： // 开发板真正需要的外设引出来，其余调试端口不连接，因此不占用引脚：
// //
// clk100 (E3) -> CPU 时钟（100 MHz） // clk100 (E3) -> CPU 时钟（100 MHz，经 CLK_DIV 分频后给 CPU）
// rst_n (C12) -> 复位按键 CPU_RESETN，低有效，经复位同步器 // rst_n (C12) -> 复位按键 CPU_RESETN，低有效，经复位同步器
// go (N17) -> 按键 BTNC：ecall 停机后按下继续运行 // go (N17) -> 按键 BTNC：ecall 停机后按下继续运行
// irq_sw[2:0] -> 拨码开关 SW[2:0]：3 路中断源 // irq_sw[2:0] -> 拨码开关 SW[2:0]：3 路中断源
// led[15:0] -> 板载 LED[15:0]：显示 MMIO（LED_ADDR）写入值的低 16 位 // led[15:0] -> 板载 LED[15:0]：显示 MMIO（LED_ADDR）写入值的低 16 位
// led_we (R12) -> LED16_B：有 MMIO 写入时亮，并拉长约 0.17 s 便于观察 // led_we (R12) -> LED16_B：有 MMIO 写入时亮，并拉长约 0.34 s 便于观察
// //
// 片内存储器： // 片内存储器：
// ROM：ROM_WORDS 字，组合读，内容由 `include "cpu21_board_rom.vh"` 给出 // ROM：ROM_WORDS 字，组合读，内容由 `include "cpu21_board_rom.vh"` 给出
@@ -29,9 +29,15 @@ module cpu21_board_top #(
parameter ROM_WORDS = 1024, parameter ROM_WORDS = 1024,
parameter RAM_WORDS = 1024, parameter RAM_WORDS = 1024,
parameter [31:0] USTATUS_INIT = 32'h0000_0001, parameter [31:0] USTATUS_INIT = 32'h0000_0001,
// 板载 100 MHz 分频给 CPU。ALU 里的除法/取余是组合电路（实测约 94 ns）， // 板载 100 MHz 的分频比（1 = 直用 100 MHz，2 = 50 MHz，…）。
// 100 MHz 下无法收敛；默认 16 分频（6.25 MHz，周期 160 ns）留出足够余量。 // 乘除法改成多周期单元后，原来 ~94 ns 的组合乘法/除法已经不在关键路径上，
parameter integer CLK_DIV = 16 // 实测（xc7a100tcsg324-1）：
// CLK_DIV=1（100 MHz）：WNS = -1.1 ns，违例路径是 EX 级的
// 分支判决/中断保存 → BPB 更新，与乘除法无关（逻辑只占 ~3 ns，
// 7~8 ns 都是布线）；
// CLK_DIV=2（ 50 MHz）：WNS ≈ +8 ns，余量充足。
// 因此默认取 2，既比原来的 16 分频快 8 倍，又能保证时序收敛。
parameter integer CLK_DIV = 2
) ( ) (
input wire clk100, // E3 input wire clk100, // E3
input wire rst_n, // C12：CPU_RESETN，低有效 input wire rst_n, // C12：CPU_RESETN，低有效
@@ -46,9 +52,13 @@ module cpu21_board_top #(
wire arst = ~rst_n; // 异步复位（高有效） wire arst = ~rst_n; // 异步复位（高有效）
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// 时钟分频：100 MHz / CLK_DIV，经 BUFG 走全局时钟网络 // 时钟：100 MHz / CLK_DIV（默认 2 = 50 MHz）给 CPU。
// （XDC 中用 create_generated_clock 声明该分频时钟，否则时序分析会按 //
// 100 MHz 的 10 ns 要求去约束 CPU 内部路径而报大量违例） // 乘除法已经是 cpu21_riscv_muldiv 里的多周期单元，关键路径上不再有组合的
// 32x32 乘法/除法；剩下的违例路径是 EX 级“分支判决/中断保存 → BPB 更新”，
// 与乘除法无关，实测 100 MHz 下 WNS = -1.1 ns，50 MHz 下余量约 +8 ns。
// 分频后的时钟由 Vivado 自动插 BUFG；XDC 里用 create_generated_clock 声明，
// 改分频比时两处要一起改。
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
reg [15:0] clk_cnt; reg [15:0] clk_cnt;
reg clk_div; reg clk_div;
@@ -65,14 +75,12 @@ module cpu21_board_top #(
end end
end end
// 不直接例化 BUFG 原语，保持 RTL 可跨工具仿真； wire clk_cpu = clk_div;
// 综合/实现时 Vivado 会为这条时钟网络自动插入 BUFG（全局时钟缓冲）。
wire clk_cpu = clk_div;
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// 复位同步器（在 CPU 时钟域）：按键异步置位、释放与 clk_cpu 同步 // 复位同步器：按键异步置位、释放与 CPU 时钟同步
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
reg [2:0] rst_sync_q; reg [2:0] rst_sync_q;
always @(posedge clk_cpu or posedge arst) begin always @(posedge clk_cpu or posedge arst) begin
if (arst) rst_sync_q <= 3'b111; if (arst) rst_sync_q <= 3'b111;
@@ -165,8 +173,7 @@ module cpu21_board_top #(
always @(posedge clk_cpu or posedge arst) begin always @(posedge clk_cpu or posedge arst) begin
if (arst) led_we_cnt <= 24'd0; if (arst) led_we_cnt <= 24'd0;
else if (led_valid) else if (led_valid) led_we_cnt <= 24'hFF_FFFF; // 约 0.34 s @50 MHz
led_we_cnt <= 24'hFF_FFFF; // 约 2.7 s @6.25 MHz（分频后的 CPU 时钟）
else if (led_we_cnt != 24'd0) led_we_cnt <= led_we_cnt - 24'd1; else if (led_we_cnt != 24'd0) led_we_cnt <= led_we_cnt - 24'd1;
end end
pipelined-cpu/srcs/constrs/Nexys4DDR_Master.xdc
+265
View File
@@ -0,0 +1,265 @@
## This file is a general .xdc for the Nexys4 DDR Rev. C
## To use it in a project:
## - uncomment the lines corresponding to used pins
## - rename the used ports (in each line, after get_ports) according to the top level signal names in the project
## Clock signal
#set_property -dict { PACKAGE_PIN E3 IOSTANDARD LVCMOS33 } [get_ports { CLK100MHZ }]; #IO_L12P_T1_MRCC_35 Sch=clk100mhz
#create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports {CLK100MHZ}];
##Switches
#set_property -dict { PACKAGE_PIN J15 IOSTANDARD LVCMOS33 } [get_ports { SW[0] }]; #IO_L24N_T3_RS0_15 Sch=sw[0]
#set_property -dict { PACKAGE_PIN L16 IOSTANDARD LVCMOS33 } [get_ports { SW[1] }]; #IO_L3N_T0_DQS_EMCCLK_14 Sch=sw[1]
#set_property -dict { PACKAGE_PIN M13 IOSTANDARD LVCMOS33 } [get_ports { SW[2] }]; #IO_L6N_T0_D08_VREF_14 Sch=sw[2]
#set_property -dict { PACKAGE_PIN R15 IOSTANDARD LVCMOS33 } [get_ports { SW[3] }]; #IO_L13N_T2_MRCC_14 Sch=sw[3]
#set_property -dict { PACKAGE_PIN R17 IOSTANDARD LVCMOS33 } [get_ports { SW[4] }]; #IO_L12N_T1_MRCC_14 Sch=sw[4]
#set_property -dict { PACKAGE_PIN T18 IOSTANDARD LVCMOS33 } [get_ports { SW[5] }]; #IO_L7N_T1_D10_14 Sch=sw[5]
#set_property -dict { PACKAGE_PIN U18 IOSTANDARD LVCMOS33 } [get_ports { SW[6] }]; #IO_L17N_T2_A13_D29_14 Sch=sw[6]
#set_property -dict { PACKAGE_PIN R13 IOSTANDARD LVCMOS33 } [get_ports { SW[7] }]; #IO_L5N_T0_D07_14 Sch=sw[7]
#set_property -dict { PACKAGE_PIN T8 IOSTANDARD LVCMOS18 } [get_ports { SW[8] }]; #IO_L24N_T3_34 Sch=sw[8]
#set_property -dict { PACKAGE_PIN U8 IOSTANDARD LVCMOS18 } [get_ports { SW[9] }]; #IO_25_34 Sch=sw[9]
#set_property -dict { PACKAGE_PIN R16 IOSTANDARD LVCMOS33 } [get_ports { SW[10] }]; #IO_L15P_T2_DQS_RDWR_B_14 Sch=sw[10]
#set_property -dict { PACKAGE_PIN T13 IOSTANDARD LVCMOS33 } [get_ports { SW[11] }]; #IO_L23P_T3_A03_D19_14 Sch=sw[11]
#set_property -dict { PACKAGE_PIN H6 IOSTANDARD LVCMOS33 } [get_ports { SW[12] }]; #IO_L24P_T3_35 Sch=sw[12]
#set_property -dict { PACKAGE_PIN U12 IOSTANDARD LVCMOS33 } [get_ports { SW[13] }]; #IO_L20P_T3_A08_D24_14 Sch=sw[13]
#set_property -dict { PACKAGE_PIN U11 IOSTANDARD LVCMOS33 } [get_ports { SW[14] }]; #IO_L19N_T3_A09_D25_VREF_14 Sch=sw[14]
#set_property -dict { PACKAGE_PIN V10 IOSTANDARD LVCMOS33 } [get_ports { SW[15] }]; #IO_L21P_T3_DQS_14 Sch=sw[15]
## LEDs
#set_property -dict { PACKAGE_PIN H17 IOSTANDARD LVCMOS33 } [get_ports { LED[0] }]; #IO_L18P_T2_A24_15 Sch=led[0]
#set_property -dict { PACKAGE_PIN K15 IOSTANDARD LVCMOS33 } [get_ports { LED[1] }]; #IO_L24P_T3_RS1_15 Sch=led[1]
#set_property -dict { PACKAGE_PIN J13 IOSTANDARD LVCMOS33 } [get_ports { LED[2] }]; #IO_L17N_T2_A25_15 Sch=led[2]
#set_property -dict { PACKAGE_PIN N14 IOSTANDARD LVCMOS33 } [get_ports { LED[3] }]; #IO_L8P_T1_D11_14 Sch=led[3]
#set_property -dict { PACKAGE_PIN R18 IOSTANDARD LVCMOS33 } [get_ports { LED[4] }]; #IO_L7P_T1_D09_14 Sch=led[4]
#set_property -dict { PACKAGE_PIN V17 IOSTANDARD LVCMOS33 } [get_ports { LED[5] }]; #IO_L18N_T2_A11_D27_14 Sch=led[5]
#set_property -dict { PACKAGE_PIN U17 IOSTANDARD LVCMOS33 } [get_ports { LED[6] }]; #IO_L17P_T2_A14_D30_14 Sch=led[6]
#set_property -dict { PACKAGE_PIN U16 IOSTANDARD LVCMOS33 } [get_ports { LED[7] }]; #IO_L18P_T2_A12_D28_14 Sch=led[7]
#set_property -dict { PACKAGE_PIN V16 IOSTANDARD LVCMOS33 } [get_ports { LED[8] }]; #IO_L16N_T2_A15_D31_14 Sch=led[8]
#set_property -dict { PACKAGE_PIN T15 IOSTANDARD LVCMOS33 } [get_ports { LED[9] }]; #IO_L14N_T2_SRCC_14 Sch=led[9]
#set_property -dict { PACKAGE_PIN U14 IOSTANDARD LVCMOS33 } [get_ports { LED[10] }]; #IO_L22P_T3_A05_D21_14 Sch=led[10]
#set_property -dict { PACKAGE_PIN T16 IOSTANDARD LVCMOS33 } [get_ports { LED[11] }]; #IO_L15N_T2_DQS_DOUT_CSO_B_14 Sch=led[11]
#set_property -dict { PACKAGE_PIN V15 IOSTANDARD LVCMOS33 } [get_ports { LED[12] }]; #IO_L16P_T2_CSI_B_14 Sch=led[12]
#set_property -dict { PACKAGE_PIN V14 IOSTANDARD LVCMOS33 } [get_ports { LED[13] }]; #IO_L22N_T3_A04_D20_14 Sch=led[13]
#set_property -dict { PACKAGE_PIN V12 IOSTANDARD LVCMOS33 } [get_ports { LED[14] }]; #IO_L20N_T3_A07_D23_14 Sch=led[14]
#set_property -dict { PACKAGE_PIN V11 IOSTANDARD LVCMOS33 } [get_ports { LED[15] }]; #IO_L21N_T3_DQS_A06_D22_14 Sch=led[15]
#set_property -dict { PACKAGE_PIN R12 IOSTANDARD LVCMOS33 } [get_ports { LED16_B }]; #IO_L5P_T0_D06_14 Sch=led16_b
#set_property -dict { PACKAGE_PIN M16 IOSTANDARD LVCMOS33 } [get_ports { LED16_G }]; #IO_L10P_T1_D14_14 Sch=led16_g
#set_property -dict { PACKAGE_PIN N15 IOSTANDARD LVCMOS33 } [get_ports { LED16_R }]; #IO_L11P_T1_SRCC_14 Sch=led16_r
#set_property -dict { PACKAGE_PIN G14 IOSTANDARD LVCMOS33 } [get_ports { LED17_B }]; #IO_L15N_T2_DQS_ADV_B_15 Sch=led17_b
#set_property -dict { PACKAGE_PIN R11 IOSTANDARD LVCMOS33 } [get_ports { LED17_G }]; #IO_0_14 Sch=led17_g
#set_property -dict { PACKAGE_PIN N16 IOSTANDARD LVCMOS33 } [get_ports { LED17_R }]; #IO_L11N_T1_SRCC_14 Sch=led17_r
##7 segment display
#set_property -dict { PACKAGE_PIN T10 IOSTANDARD LVCMOS33 } [get_ports { CA }]; #IO_L24N_T3_A00_D16_14 Sch=ca
#set_property -dict { PACKAGE_PIN R10 IOSTANDARD LVCMOS33 } [get_ports { CB }]; #IO_25_14 Sch=cb
#set_property -dict { PACKAGE_PIN K16 IOSTANDARD LVCMOS33 } [get_ports { CC }]; #IO_25_15 Sch=cc
#set_property -dict { PACKAGE_PIN K13 IOSTANDARD LVCMOS33 } [get_ports { CD }]; #IO_L17P_T2_A26_15 Sch=cd
#set_property -dict { PACKAGE_PIN P15 IOSTANDARD LVCMOS33 } [get_ports { CE }]; #IO_L13P_T2_MRCC_14 Sch=ce
#set_property -dict { PACKAGE_PIN T11 IOSTANDARD LVCMOS33 } [get_ports { CF }]; #IO_L19P_T3_A10_D26_14 Sch=cf
#set_property -dict { PACKAGE_PIN L18 IOSTANDARD LVCMOS33 } [get_ports { CG }]; #IO_L4P_T0_D04_14 Sch=cg
#set_property -dict { PACKAGE_PIN H15 IOSTANDARD LVCMOS33 } [get_ports { DP }]; #IO_L19N_T3_A21_VREF_15 Sch=dp
#set_property -dict { PACKAGE_PIN J17 IOSTANDARD LVCMOS33 } [get_ports { AN[0] }]; #IO_L23P_T3_FOE_B_15 Sch=an[0]
#set_property -dict { PACKAGE_PIN J18 IOSTANDARD LVCMOS33 } [get_ports { AN[1] }]; #IO_L23N_T3_FWE_B_15 Sch=an[1]
#set_property -dict { PACKAGE_PIN T9 IOSTANDARD LVCMOS33 } [get_ports { AN[2] }]; #IO_L24P_T3_A01_D17_14 Sch=an[2]
#set_property -dict { PACKAGE_PIN J14 IOSTANDARD LVCMOS33 } [get_ports { AN[3] }]; #IO_L19P_T3_A22_15 Sch=an[3]
#set_property -dict { PACKAGE_PIN P14 IOSTANDARD LVCMOS33 } [get_ports { AN[4] }]; #IO_L8N_T1_D12_14 Sch=an[4]
#set_property -dict { PACKAGE_PIN T14 IOSTANDARD LVCMOS33 } [get_ports { AN[5] }]; #IO_L14P_T2_SRCC_14 Sch=an[5]
#set_property -dict { PACKAGE_PIN K2 IOSTANDARD LVCMOS33 } [get_ports { AN[6] }]; #IO_L23P_T3_35 Sch=an[6]
#set_property -dict { PACKAGE_PIN U13 IOSTANDARD LVCMOS33 } [get_ports { AN[7] }]; #IO_L23N_T3_A02_D18_14 Sch=an[7]
##Buttons
#set_property -dict { PACKAGE_PIN C12 IOSTANDARD LVCMOS33 } [get_ports { CPU_RESETN }]; #IO_L3P_T0_DQS_AD1P_15 Sch=cpu_resetn
#set_property -dict { PACKAGE_PIN N17 IOSTANDARD LVCMOS33 } [get_ports { BTNC }]; #IO_L9P_T1_DQS_14 Sch=btnc
#set_property -dict { PACKAGE_PIN M18 IOSTANDARD LVCMOS33 } [get_ports { BTNU }]; #IO_L4N_T0_D05_14 Sch=btnu
#set_property -dict { PACKAGE_PIN P17 IOSTANDARD LVCMOS33 } [get_ports { BTNL }]; #IO_L12P_T1_MRCC_14 Sch=btnl
#set_property -dict { PACKAGE_PIN M17 IOSTANDARD LVCMOS33 } [get_ports { BTNR }]; #IO_L10N_T1_D15_14 Sch=btnr
#set_property -dict { PACKAGE_PIN P18 IOSTANDARD LVCMOS33 } [get_ports { BTND }]; #IO_L9N_T1_DQS_D13_14 Sch=btnd
##Pmod Headers
##Pmod Header JA
#set_property -dict { PACKAGE_PIN C17 IOSTANDARD LVCMOS33 } [get_ports { JA[1] }]; #IO_L20N_T3_A19_15 Sch=ja[1]
#set_property -dict { PACKAGE_PIN D18 IOSTANDARD LVCMOS33 } [get_ports { JA[2] }]; #IO_L21N_T3_DQS_A18_15 Sch=ja[2]
#set_property -dict { PACKAGE_PIN E18 IOSTANDARD LVCMOS33 } [get_ports { JA[3] }]; #IO_L21P_T3_DQS_15 Sch=ja[3]
#set_property -dict { PACKAGE_PIN G17 IOSTANDARD LVCMOS33 } [get_ports { JA[4] }]; #IO_L18N_T2_A23_15 Sch=ja[4]
#set_property -dict { PACKAGE_PIN D17 IOSTANDARD LVCMOS33 } [get_ports { JA[7] }]; #IO_L16N_T2_A27_15 Sch=ja[7]
#set_property -dict { PACKAGE_PIN E17 IOSTANDARD LVCMOS33 } [get_ports { JA[8] }]; #IO_L16P_T2_A28_15 Sch=ja[8]
#set_property -dict { PACKAGE_PIN F18 IOSTANDARD LVCMOS33 } [get_ports { JA[9] }]; #IO_L22N_T3_A16_15 Sch=ja[9]
#set_property -dict { PACKAGE_PIN G18 IOSTANDARD LVCMOS33 } [get_ports { JA[10] }]; #IO_L22P_T3_A17_15 Sch=ja[10]
##Pmod Header JB
#set_property -dict { PACKAGE_PIN D14 IOSTANDARD LVCMOS33 } [get_ports { JB[1] }]; #IO_L1P_T0_AD0P_15 Sch=jb[1]
#set_property -dict { PACKAGE_PIN F16 IOSTANDARD LVCMOS33 } [get_ports { JB[2] }]; #IO_L14N_T2_SRCC_15 Sch=jb[2]
#set_property -dict { PACKAGE_PIN G16 IOSTANDARD LVCMOS33 } [get_ports { JB[3] }]; #IO_L13N_T2_MRCC_15 Sch=jb[3]
#set_property -dict { PACKAGE_PIN H14 IOSTANDARD LVCMOS33 } [get_ports { JB[4] }]; #IO_L15P_T2_DQS_15 Sch=jb[4]
#set_property -dict { PACKAGE_PIN E16 IOSTANDARD LVCMOS33 } [get_ports { JB[7] }]; #IO_L11N_T1_SRCC_15 Sch=jb[7]
#set_property -dict { PACKAGE_PIN F13 IOSTANDARD LVCMOS33 } [get_ports { JB[8] }]; #IO_L5P_T0_AD9P_15 Sch=jb[8]
#set_property -dict { PACKAGE_PIN G13 IOSTANDARD LVCMOS33 } [get_ports { JB[9] }]; #IO_0_15 Sch=jb[9]
#set_property -dict { PACKAGE_PIN H16 IOSTANDARD LVCMOS33 } [get_ports { JB[10] }]; #IO_L13P_T2_MRCC_15 Sch=jb[10]
##Pmod Header JC
#set_property -dict { PACKAGE_PIN K1 IOSTANDARD LVCMOS33 } [get_ports { JC[1] }]; #IO_L23N_T3_35 Sch=jc[1]
#set_property -dict { PACKAGE_PIN F6 IOSTANDARD LVCMOS33 } [get_ports { JC[2] }]; #IO_L19N_T3_VREF_35 Sch=jc[2]
#set_property -dict { PACKAGE_PIN J2 IOSTANDARD LVCMOS33 } [get_ports { JC[3] }]; #IO_L22N_T3_35 Sch=jc[3]
#set_property -dict { PACKAGE_PIN G6 IOSTANDARD LVCMOS33 } [get_ports { JC[4] }]; #IO_L19P_T3_35 Sch=jc[4]
#set_property -dict { PACKAGE_PIN E7 IOSTANDARD LVCMOS33 } [get_ports { JC[7] }]; #IO_L6P_T0_35 Sch=jc[7]
#set_property -dict { PACKAGE_PIN J3 IOSTANDARD LVCMOS33 } [get_ports { JC[8] }]; #IO_L22P_T3_35 Sch=jc[8]
#set_property -dict { PACKAGE_PIN J4 IOSTANDARD LVCMOS33 } [get_ports { JC[9] }]; #IO_L21P_T3_DQS_35 Sch=jc[9]
#set_property -dict { PACKAGE_PIN E6 IOSTANDARD LVCMOS33 } [get_ports { JC[10] }]; #IO_L5P_T0_AD13P_35 Sch=jc[10]
##Pmod Header JD
#set_property -dict { PACKAGE_PIN H4 IOSTANDARD LVCMOS33 } [get_ports { JD[1] }]; #IO_L21N_T3_DQS_35 Sch=jd[1]
#set_property -dict { PACKAGE_PIN H1 IOSTANDARD LVCMOS33 } [get_ports { JD[2] }]; #IO_L17P_T2_35 Sch=jd[2]
#set_property -dict { PACKAGE_PIN G1 IOSTANDARD LVCMOS33 } [get_ports { JD[3] }]; #IO_L17N_T2_35 Sch=jd[3]
#set_property -dict { PACKAGE_PIN G3 IOSTANDARD LVCMOS33 } [get_ports { JD[4] }]; #IO_L20N_T3_35 Sch=jd[4]
#set_property -dict { PACKAGE_PIN H2 IOSTANDARD LVCMOS33 } [get_ports { JD[7] }]; #IO_L15P_T2_DQS_35 Sch=jd[7]
#set_property -dict { PACKAGE_PIN G4 IOSTANDARD LVCMOS33 } [get_ports { JD[8] }]; #IO_L20P_T3_35 Sch=jd[8]
#set_property -dict { PACKAGE_PIN G2 IOSTANDARD LVCMOS33 } [get_ports { JD[9] }]; #IO_L15N_T2_DQS_35 Sch=jd[9]
#set_property -dict { PACKAGE_PIN F3 IOSTANDARD LVCMOS33 } [get_ports { JD[10] }]; #IO_L13N_T2_MRCC_35 Sch=jd[10]
##Pmod Header JXADC
#set_property -dict { PACKAGE_PIN A14 IOSTANDARD LVDS } [get_ports { XA_N[1] }]; #IO_L9N_T1_DQS_AD3N_15 Sch=xa_n[1]
#set_property -dict { PACKAGE_PIN A13 IOSTANDARD LVDS } [get_ports { XA_P[1] }]; #IO_L9P_T1_DQS_AD3P_15 Sch=xa_p[1]
#set_property -dict { PACKAGE_PIN A16 IOSTANDARD LVDS } [get_ports { XA_N[2] }]; #IO_L8N_T1_AD10N_15 Sch=xa_n[2]
#set_property -dict { PACKAGE_PIN A15 IOSTANDARD LVDS } [get_ports { XA_P[2] }]; #IO_L8P_T1_AD10P_15 Sch=xa_p[2]
#set_property -dict { PACKAGE_PIN B17 IOSTANDARD LVDS } [get_ports { XA_N[3] }]; #IO_L7N_T1_AD2N_15 Sch=xa_n[3]
#set_property -dict { PACKAGE_PIN B16 IOSTANDARD LVDS } [get_ports { XA_P[3] }]; #IO_L7P_T1_AD2P_15 Sch=xa_p[3]
#set_property -dict { PACKAGE_PIN A18 IOSTANDARD LVDS } [get_ports { XA_N[4] }]; #IO_L10N_T1_AD11N_15 Sch=xa_n[4]
#set_property -dict { PACKAGE_PIN B18 IOSTANDARD LVDS } [get_ports { XA_P[4] }]; #IO_L10P_T1_AD11P_15 Sch=xa_p[4]
##VGA Connector
#set_property -dict { PACKAGE_PIN A3 IOSTANDARD LVCMOS33 } [get_ports { VGA_R[0] }]; #IO_L8N_T1_AD14N_35 Sch=vga_r[0]
#set_property -dict { PACKAGE_PIN B4 IOSTANDARD LVCMOS33 } [get_ports { VGA_R[1] }]; #IO_L7N_T1_AD6N_35 Sch=vga_r[1]
#set_property -dict { PACKAGE_PIN C5 IOSTANDARD LVCMOS33 } [get_ports { VGA_R[2] }]; #IO_L1N_T0_AD4N_35 Sch=vga_r[2]
#set_property -dict { PACKAGE_PIN A4 IOSTANDARD LVCMOS33 } [get_ports { VGA_R[3] }]; #IO_L8P_T1_AD14P_35 Sch=vga_r[3]
#set_property -dict { PACKAGE_PIN C6 IOSTANDARD LVCMOS33 } [get_ports { VGA_G[0] }]; #IO_L1P_T0_AD4P_35 Sch=vga_g[0]
#set_property -dict { PACKAGE_PIN A5 IOSTANDARD LVCMOS33 } [get_ports { VGA_G[1] }]; #IO_L3N_T0_DQS_AD5N_35 Sch=vga_g[1]
#set_property -dict { PACKAGE_PIN B6 IOSTANDARD LVCMOS33 } [get_ports { VGA_G[2] }]; #IO_L2N_T0_AD12N_35 Sch=vga_g[2]
#set_property -dict { PACKAGE_PIN A6 IOSTANDARD LVCMOS33 } [get_ports { VGA_G[3] }]; #IO_L3P_T0_DQS_AD5P_35 Sch=vga_g[3]
#set_property -dict { PACKAGE_PIN B7 IOSTANDARD LVCMOS33 } [get_ports { VGA_B[0] }]; #IO_L2P_T0_AD12P_35 Sch=vga_b[0]
#set_property -dict { PACKAGE_PIN C7 IOSTANDARD LVCMOS33 } [get_ports { VGA_B[1] }]; #IO_L4N_T0_35 Sch=vga_b[1]
#set_property -dict { PACKAGE_PIN D7 IOSTANDARD LVCMOS33 } [get_ports { VGA_B[2] }]; #IO_L6N_T0_VREF_35 Sch=vga_b[2]
#set_property -dict { PACKAGE_PIN D8 IOSTANDARD LVCMOS33 } [get_ports { VGA_B[3] }]; #IO_L4P_T0_35 Sch=vga_b[3]
#set_property -dict { PACKAGE_PIN B11 IOSTANDARD LVCMOS33 } [get_ports { VGA_HS }]; #IO_L4P_T0_15 Sch=vga_hs
#set_property -dict { PACKAGE_PIN B12 IOSTANDARD LVCMOS33 } [get_ports { VGA_VS }]; #IO_L3N_T0_DQS_AD1N_15 Sch=vga_vs
##Micro SD Connector
#set_property -dict { PACKAGE_PIN E2 IOSTANDARD LVCMOS33 } [get_ports { SD_RESET }]; #IO_L14P_T2_SRCC_35 Sch=sd_reset
#set_property -dict { PACKAGE_PIN A1 IOSTANDARD LVCMOS33 } [get_ports { SD_CD }]; #IO_L9N_T1_DQS_AD7N_35 Sch=sd_cd
#set_property -dict { PACKAGE_PIN B1 IOSTANDARD LVCMOS33 } [get_ports { SD_SCK }]; #IO_L9P_T1_DQS_AD7P_35 Sch=sd_sck
#set_property -dict { PACKAGE_PIN C1 IOSTANDARD LVCMOS33 } [get_ports { SD_CMD }]; #IO_L16N_T2_35 Sch=sd_cmd
#set_property -dict { PACKAGE_PIN C2 IOSTANDARD LVCMOS33 } [get_ports { SD_DAT[0] }]; #IO_L16P_T2_35 Sch=sd_dat[0]
#set_property -dict { PACKAGE_PIN E1 IOSTANDARD LVCMOS33 } [get_ports { SD_DAT[1] }]; #IO_L18N_T2_35 Sch=sd_dat[1]
#set_property -dict { PACKAGE_PIN F1 IOSTANDARD LVCMOS33 } [get_ports { SD_DAT[2] }]; #IO_L18P_T2_35 Sch=sd_dat[2]
#set_property -dict { PACKAGE_PIN D2 IOSTANDARD LVCMOS33 } [get_ports { SD_DAT[3] }]; #IO_L14N_T2_SRCC_35 Sch=sd_dat[3]
##Accelerometer
#set_property -dict { PACKAGE_PIN E15 IOSTANDARD LVCMOS33 } [get_ports { ACL_MISO }]; #IO_L11P_T1_SRCC_15 Sch=acl_miso
#set_property -dict { PACKAGE_PIN F14 IOSTANDARD LVCMOS33 } [get_ports { ACL_MOSI }]; #IO_L5N_T0_AD9N_15 Sch=acl_mosi
#set_property -dict { PACKAGE_PIN F15 IOSTANDARD LVCMOS33 } [get_ports { ACL_SCLK }]; #IO_L14P_T2_SRCC_15 Sch=acl_sclk
#set_property -dict { PACKAGE_PIN D15 IOSTANDARD LVCMOS33 } [get_ports { ACL_CSN }]; #IO_L12P_T1_MRCC_15 Sch=acl_csn
#set_property -dict { PACKAGE_PIN B13 IOSTANDARD LVCMOS33 } [get_ports { ACL_INT[1] }]; #IO_L2P_T0_AD8P_15 Sch=acl_int[1]
#set_property -dict { PACKAGE_PIN C16 IOSTANDARD LVCMOS33 } [get_ports { ACL_INT[2] }]; #IO_L20P_T3_A20_15 Sch=acl_int[2]
##Temperature Sensor
#set_property -dict { PACKAGE_PIN C14 IOSTANDARD LVCMOS33 } [get_ports { TMP_SCL }]; #IO_L1N_T0_AD0N_15 Sch=tmp_scl
#set_property -dict { PACKAGE_PIN C15 IOSTANDARD LVCMOS33 } [get_ports { TMP_SDA }]; #IO_L12N_T1_MRCC_15 Sch=tmp_sda
#set_property -dict { PACKAGE_PIN D13 IOSTANDARD LVCMOS33 } [get_ports { TMP_INT }]; #IO_L6N_T0_VREF_15 Sch=tmp_int
#set_property -dict { PACKAGE_PIN B14 IOSTANDARD LVCMOS33 } [get_ports { TMP_CT }]; #IO_L2N_T0_AD8N_15 Sch=tmp_ct
##Omnidirectional Microphone
#set_property -dict { PACKAGE_PIN J5 IOSTANDARD LVCMOS33 } [get_ports { M_CLK }]; #IO_25_35 Sch=m_clk
#set_property -dict { PACKAGE_PIN H5 IOSTANDARD LVCMOS33 } [get_ports { M_DATA }]; #IO_L24N_T3_35 Sch=m_data
#set_property -dict { PACKAGE_PIN F5 IOSTANDARD LVCMOS33 } [get_ports { M_LRSEL }]; #IO_0_35 Sch=m_lrsel
##PWM Audio Amplifier
#set_property -dict { PACKAGE_PIN A11 IOSTANDARD LVCMOS33 } [get_ports { AUD_PWM }]; #IO_L4N_T0_15 Sch=aud_pwm
#set_property -dict { PACKAGE_PIN D12 IOSTANDARD LVCMOS33 } [get_ports { AUD_SD }]; #IO_L6P_T0_15 Sch=aud_sd
##USB-RS232 Interface
#set_property -dict { PACKAGE_PIN C4 IOSTANDARD LVCMOS33 } [get_ports { UART_TXD_IN }]; #IO_L7P_T1_AD6P_35 Sch=uart_txd_in
#set_property -dict { PACKAGE_PIN D4 IOSTANDARD LVCMOS33 } [get_ports { UART_RXD_OUT }]; #IO_L11N_T1_SRCC_35 Sch=uart_rxd_out
#set_property -dict { PACKAGE_PIN D3 IOSTANDARD LVCMOS33 } [get_ports { UART_CTS }]; #IO_L12N_T1_MRCC_35 Sch=uart_cts
#set_property -dict { PACKAGE_PIN E5 IOSTANDARD LVCMOS33 } [get_ports { UART_RTS }]; #IO_L5N_T0_AD13N_35 Sch=uart_rts
##USB HID (PS/2)
#set_property -dict { PACKAGE_PIN F4 IOSTANDARD LVCMOS33 } [get_ports { PS2_CLK }]; #IO_L13P_T2_MRCC_35 Sch=ps2_clk
#set_property -dict { PACKAGE_PIN B2 IOSTANDARD LVCMOS33 } [get_ports { PS2_DATA }]; #IO_L10N_T1_AD15N_35 Sch=ps2_data
##SMSC Ethernet PHY
#set_property -dict { PACKAGE_PIN C9 IOSTANDARD LVCMOS33 } [get_ports { ETH_MDC }]; #IO_L11P_T1_SRCC_16 Sch=eth_mdc
#set_property -dict { PACKAGE_PIN A9 IOSTANDARD LVCMOS33 } [get_ports { ETH_MDIO }]; #IO_L14N_T2_SRCC_16 Sch=eth_mdio
#set_property -dict { PACKAGE_PIN B3 IOSTANDARD LVCMOS33 } [get_ports { ETH_RSTN }]; #IO_L10P_T1_AD15P_35 Sch=eth_rstn
#set_property -dict { PACKAGE_PIN D9 IOSTANDARD LVCMOS33 } [get_ports { ETH_CRSDV }]; #IO_L6N_T0_VREF_16 Sch=eth_crsdv
#set_property -dict { PACKAGE_PIN C10 IOSTANDARD LVCMOS33 } [get_ports { ETH_RXERR }]; #IO_L13N_T2_MRCC_16 Sch=eth_rxerr
#set_property -dict { PACKAGE_PIN C11 IOSTANDARD LVCMOS33 } [get_ports { ETH_RXD[0] }]; #IO_L13P_T2_MRCC_16 Sch=eth_rxd[0]
#set_property -dict { PACKAGE_PIN D10 IOSTANDARD LVCMOS33 } [get_ports { ETH_RXD[1] }]; #IO_L19N_T3_VREF_16 Sch=eth_rxd[1]
#set_property -dict { PACKAGE_PIN B9 IOSTANDARD LVCMOS33 } [get_ports { ETH_TXEN }]; #IO_L11N_T1_SRCC_16 Sch=eth_txen
#set_property -dict { PACKAGE_PIN A10 IOSTANDARD LVCMOS33 } [get_ports { ETH_TXD[0] }]; #IO_L14P_T2_SRCC_16 Sch=eth_txd[0]
#set_property -dict { PACKAGE_PIN A8 IOSTANDARD LVCMOS33 } [get_ports { ETH_TXD[1] }]; #IO_L12N_T1_MRCC_16 Sch=eth_txd[1]
#set_property -dict { PACKAGE_PIN D5 IOSTANDARD LVCMOS33 } [get_ports { ETH_REFCLK }]; #IO_L11P_T1_SRCC_35 Sch=eth_refclk
#set_property -dict { PACKAGE_PIN B8 IOSTANDARD LVCMOS33 } [get_ports { ETH_INTN }]; #IO_L12P_T1_MRCC_16 Sch=eth_intn
##Quad SPI Flash
#set_property -dict { PACKAGE_PIN K17 IOSTANDARD LVCMOS33 } [get_ports { QSPI_DQ[0] }]; #IO_L1P_T0_D00_MOSI_14 Sch=qspi_dq[0]
#set_property -dict { PACKAGE_PIN K18 IOSTANDARD LVCMOS33 } [get_ports { QSPI_DQ[1] }]; #IO_L1N_T0_D01_DIN_14 Sch=qspi_dq[1]
#set_property -dict { PACKAGE_PIN L14 IOSTANDARD LVCMOS33 } [get_ports { QSPI_DQ[2] }]; #IO_L2P_T0_D02_14 Sch=qspi_dq[2]
#set_property -dict { PACKAGE_PIN M14 IOSTANDARD LVCMOS33 } [get_ports { QSPI_DQ[3] }]; #IO_L2N_T0_D03_14 Sch=qspi_dq[3]
#set_property -dict { PACKAGE_PIN L13 IOSTANDARD LVCMOS33 } [get_ports { QSPI_CSN }]; #IO_L6P_T0_FCS_B_14 Sch=qspi_csn
board/cpu21_board_top.xdc → pipelined-cpu/srcs/constrs/cpu21_board_top.xdc
+7 -5
View File
@@ -2,14 +2,16 @@
## 引脚编号取自 ConstraintsData/Nexys4DDR_Master.xdc（母版默认全部注释）。 ## 引脚编号取自 ConstraintsData/Nexys4DDR_Master.xdc（母版默认全部注释）。
## 只约束 cpu21_board_top 实际使用的端口。 ## 只约束 cpu21_board_top 实际使用的端口。
## 100 MHz 板载时钟 ## 100 MHz 板载时钟（分频器输入）
set_property -dict { PACKAGE_PIN E3 IOSTANDARD LVCMOS33 } [get_ports { clk100 }] set_property -dict { PACKAGE_PIN E3 IOSTANDARD LVCMOS33 } [get_ports { clk100 }]
create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports { clk100 }] create_clock -add -name sys_clk_pin -period 10.00 -waveform {0 5} [get_ports { clk100 }]
## CPU 时钟：板上 100 MHz 经 CLK_DIV(=16) 分频 ## CPU 时钟：板上 100 MHz 经 CLK_DIV(=2) 分频到 50 MHz
## （与 cpu21_board_top.v 的 CLK_DIV 保持一致；改分频比时这里也要改） ## （与 cpu21_board_top.v 的 CLK_DIV 保持一致；改分频比时这里也要改。
## 乘除法已是多周期单元，不再需要 16 分频；实测 100 MHz 下剩余违例路径是
## EX 级分支判决/中断保存 → BPB 更新，50 MHz 则余量充足）
create_generated_clock -name cpu_clk -source [get_ports { clk100 }] \ create_generated_clock -name cpu_clk -source [get_ports { clk100 }] \
-divide_by 16 [get_pins { clk_div_reg/Q }] -divide_by 2 [get_pins { clk_div_reg/Q }]
## 复位按键（CPU_RESETN，低有效）与"继续运行"按键（BTNC） ## 复位按键（CPU_RESETN，低有效）与"继续运行"按键（BTNC）
set_property -dict { PACKAGE_PIN C12 IOSTANDARD LVCMOS33 } [get_ports { rst_n }] set_property -dict { PACKAGE_PIN C12 IOSTANDARD LVCMOS33 } [get_ports { rst_n }]
@@ -38,7 +40,7 @@ set_property -dict { PACKAGE_PIN V14 IOSTANDARD LVCMOS33 } [get_ports { led[13
set_property -dict { PACKAGE_PIN V12 IOSTANDARD LVCMOS33 } [get_ports { led[14] }] set_property -dict { PACKAGE_PIN V12 IOSTANDARD LVCMOS33 } [get_ports { led[14] }]
set_property -dict { PACKAGE_PIN V11 IOSTANDARD LVCMOS33 } [get_ports { led[15] }] set_property -dict { PACKAGE_PIN V11 IOSTANDARD LVCMOS33 } [get_ports { led[15] }]
## LED16_B：MMIO 写入指示（拉长约 2.7 s，CLK_DIV=16 下的 CPU 时钟） ## LED16_B：MMIO 写入指示（拉长约 0.34 s @50 MHz）
set_property -dict { PACKAGE_PIN R12 IOSTANDARD LVCMOS33 } [get_ports { led_we }] set_property -dict { PACKAGE_PIN R12 IOSTANDARD LVCMOS33 } [get_ports { led_we }]
## 上板调试时可把 MMIO 写入的 LED 寄存器也引到 LED16_R/G， ## 上板调试时可把 MMIO 写入的 LED 寄存器也引到 LED16_R/G，
testbench/rom/board_demo.hex → pipelined-cpu/srcs/rom/board_demo.hex
View File
testbench/rom/cpu21_riscv_redirect_int_bpb_rom.hex → pipelined-cpu/srcs/rom/cpu21_riscv_redirect_int_bpb_rom.hex
View File
testbench/rom/isa_test.hex → pipelined-cpu/srcs/rom/isa_test.hex
View File
testbench/rom/lui_test.hex → pipelined-cpu/srcs/rom/lui_test.hex
View File
testbench/rom/mmio_test.hex → pipelined-cpu/srcs/rom/mmio_test.hex
View File
pipelined-cpu/srcs/rom/muldiv_test.hex
+64
View File
@@ -0,0 +1,64 @@
00700313
00600393
02730533
00001FB7
00AFA023
FFB00313
00400393
02730533
00001FB7
00AFA023
40000337
00400393
02731533
00001FB7
00AFA023
FFF00313
00200393
02733533
00001FB7
00AFA023
FFF00313
FFF00393
02732533
00001FB7
00AFA023
06400313
00700393
02735533
00001FB7
00AFA023
02737533
00001FB7
00AFA023
FFF00313
00200393
02735533
00001FB7
00AFA023
00003337
03930313
00000393
02735533
00001FB7
00AFA023
02737533
00001FB7
00AFA023
FFF00313
01000393
02737533
00001FB7
00AFA023
12345337
67830313
01000393
02730533
00001FB7
00AFA023
000013B7
02731533
00001FB7
00AFA023
00A00893
00000073
testbench/rom/risc-v-benchmark_ccab.hex → pipelined-cpu/srcs/rom/risc-v-benchmark_ccab.hex
View File
testbench/rom/risc-v-branch-predict.hex → pipelined-cpu/srcs/rom/risc-v-branch-predict.hex
View File
rtl/cpu21_bpb_8.v → pipelined-cpu/srcs/rtl/cpu21_bpb_8.v
View File
rtl/cpu21_mmio.v → pipelined-cpu/srcs/rtl/cpu21_mmio.v
View File
rtl/cpu21_riscv_alu.v → pipelined-cpu/srcs/rtl/cpu21_riscv_alu.v
+14 -20
View File
@@ -2,11 +2,14 @@
`default_nettype none `default_nettype none
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// ALU：纯组合运算单元。 // ALU：组合运算单元（只做加减/移位/逻辑/比较等单拍运算）。
// //
// result 为主结果；result2 为第二结果（乘法的无符号高 32 位 / DIVU 的余数）， // 乘法与除法已移到 cpu21_riscv_muldiv.v（时序多周期单元），因为组合的 a*b / a%b
// 由译码器用 wb_sel=3 选取，用于无符号高位乘法 mulhu 与课程约定的 remu。 // 关键路径过长（综合后约 94 ns，100 MHz 下无法收敛）。因此本模块不再实现
// 除法做了除零保护：b==0 时商为 32'hffff_ffff、余数为被除数。 // ALU_MUL / ALU_DIVU：这两个操作码只作为“这是乘除法指令”的标识，对应结果由
// 顶层从 muldiv 的输出选取（result2 的 wb_sel=3 约定保持不变）。
//
// result 为主结果；result2 为第二结果，由译码器用 wb_sel=3 选取。
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
module cpu21_riscv_alu ( module cpu21_riscv_alu (
input wire [ 3:0] op, input wire [ 3:0] op,
@@ -31,37 +34,28 @@ module cpu21_riscv_alu (
localparam ALU_MULH = 4'd13; localparam ALU_MULH = 4'd13;
localparam ALU_MULHSU = 4'd14; localparam ALU_MULHSU = 4'd14;
localparam ALU_PASSB = 4'd15; // 直接输出 B 端（供 LUI 使用） localparam ALU_PASSB = 4'd15; // 直接输出 B 端（供 LUI 使用）
reg [63:0] mult_result; // 无符号 32x32 乘积
reg signed [63:0] mult_ss; // 有符号 x 有符号
reg signed [63:0] mult_su; // 有符号 x 无符号
always @* begin always @* begin
mult_result = a * b; result = 32'b0;
mult_ss = $signed(a) * $signed(b);
mult_su = $signed(a) * $signed({32'b0, b});
result2 = 32'b0; result2 = 32'b0;
case (op) case (op)
ALU_SLL: result = a << b[4:0]; ALU_SLL: result = a << b[4:0];
ALU_SRA: result = $signed(a) >>> b[4:0]; ALU_SRA: result = $signed(a) >>> b[4:0];
ALU_SRL: result = a >> b[4:0]; ALU_SRL: result = a >> b[4:0];
ALU_MUL: begin // 乘法（ALU_MUL）与除法（ALU_DIVU）在本模块内不产生结果：
result = mult_result[31:0]; // 它们由 cpu21_riscv_muldiv 多周期单元完成，顶层用 ex_muldiv 选择其输出。
result2 = mult_result[63:32]; ALU_MUL: ;
end ALU_DIVU: ;
ALU_DIVU: begin
result = (b == 32'b0) ? 32'hffff_ffff : a / b;
result2 = (b == 32'b0) ? a : a % b;
end
ALU_ADD: result = a + b; ALU_ADD: result = a + b;
ALU_SUB: result = a - b; ALU_SUB: result = a - b;
ALU_AND: result = a & b; ALU_AND: result = a & b;
ALU_OR: result = a | b; ALU_OR: result = a | b;
ALU_XOR: result = a ^ b; ALU_XOR: result = a ^ b;
ALU_NOR: result = ~(a | b); ALU_NOR: result = ~(a | b);
ALU_MULH: result = mult_ss[63:32];
ALU_MULHSU: result = mult_su[63:32];
ALU_SLT: result = ($signed(a) < $signed(b)) ? 32'd1 : 32'd0; ALU_SLT: result = ($signed(a) < $signed(b)) ? 32'd1 : 32'd0;
ALU_SLTU: result = (a < b) ? 32'd1 : 32'd0; ALU_SLTU: result = (a < b) ? 32'd1 : 32'd0;
ALU_MULH: ;
ALU_MULHSU: ;
ALU_PASSB: result = b; ALU_PASSB: result = b;
default: result = 32'b0; default: result = 32'b0;
endcase endcase
rtl/cpu21_riscv_branch_unit.v → pipelined-cpu/srcs/rtl/cpu21_riscv_branch_unit.v
View File
rtl/cpu21_riscv_decoder.v → pipelined-cpu/srcs/rtl/cpu21_riscv_decoder.v
+35 -7
View File
@@ -17,6 +17,7 @@ module cpu21_riscv_decoder (
output reg [31:0] imm_o, output reg [31:0] imm_o,
output reg [ 3:0] alu_op_o, output reg [ 3:0] alu_op_o,
output reg [ 2:0] wb_sel_o, output reg [ 2:0] wb_sel_o,
output reg [ 2:0] md_op_o,
output wire [11:0] csr_addr_o, output wire [11:0] csr_addr_o,
output reg uses_rs1_o, output reg uses_rs1_o,
output reg uses_rs2_o, output reg uses_rs2_o,
@@ -68,6 +69,15 @@ module cpu21_riscv_decoder (
localparam ALU_MULHSU = 4'd14; localparam ALU_MULHSU = 4'd14;
localparam ALU_PASSB = 4'd15; // LUI：直接输出 B 端（立即数） localparam ALU_PASSB = 4'd15; // LUI：直接输出 B 端（立即数）
// 乘除法单元（cpu21_riscv_muldiv）的操作编码，MD_NONE 表示非乘除法指令。
localparam [2:0] MD_NONE = 3'd0;
localparam [2:0] MD_MUL = 3'd1;
localparam [2:0] MD_MULH = 3'd2;
localparam [2:0] MD_MULHSU = 3'd3;
localparam [2:0] MD_MULHU = 3'd4;
localparam [2:0] MD_DIVU = 3'd5;
localparam [2:0] MD_REMU = 3'd6;
wire [4:0] opcode = ir_i[6:2]; wire [4:0] opcode = ir_i[6:2];
wire [2:0] funct3 = ir_i[14:12]; wire [2:0] funct3 = ir_i[14:12];
wire [6:0] funct7 = ir_i[31:25]; wire [6:0] funct7 = ir_i[31:25];
@@ -83,6 +93,7 @@ module cpu21_riscv_decoder (
imm_o = {{20{ir_i[31]}}, ir_i[31:20]}; imm_o = {{20{ir_i[31]}}, ir_i[31:20]};
alu_op_o = ALU_ADD; alu_op_o = ALU_ADD;
wb_sel_o = 3'd0; wb_sel_o = 3'd0;
md_op_o = MD_NONE;
uses_rs1_o = 1'b0; uses_rs1_o = 1'b0;
uses_rs2_o = 1'b0; uses_rs2_o = 1'b0;
reg_write_o = 1'b0; reg_write_o = 1'b0;
@@ -111,19 +122,36 @@ module cpu21_riscv_decoder (
uses_rs1_o = 1'b1; uses_rs1_o = 1'b1;
uses_rs2_o = 1'b1; uses_rs2_o = 1'b1;
reg_write_o = 1'b1; reg_write_o = 1'b1;
// M 扩展（funct7=0000001）：mul/mulh/mulhsu/mulhu，外加课程约定的 remu // M 扩展（funct7=0000001）：mul/mulh/mulhsu/mulhu，以及课程真值表里的
// （funct3=111 形式）。mulhu 与 remu 都取 ALU 的 result2（wb_sel=3）。 // divu（funct3=101，商）与 remu（funct3=111，余数）。它们都由多周期
// 乘除法单元完成，这里只给出操作类型 md_op_o；mulhu 与 remu 依旧用
// wb_sel=3 取 result2（高位乘积 / 余数）。
if (funct7 == 7'b0000001) begin if (funct7 == 7'b0000001) begin
case (funct3) case (funct3)
3'b000: alu_op_o = ALU_MUL; // mul：无符号乘积低 32 位 3'b000: begin // mul：低 32 位
3'b001: alu_op_o = ALU_MULH; // mulh：有符号乘积高 32 位
3'b010: alu_op_o = ALU_MULHSU; // mulhsu：有符号 x 无符号高 32 位
3'b011: begin // mulhu：无符号乘积高 32 位
alu_op_o = ALU_MUL; alu_op_o = ALU_MUL;
md_op_o = MD_MUL;
end
3'b001: begin // mulh：有符号高 32 位
alu_op_o = ALU_MULH;
md_op_o = MD_MULH;
end
3'b010: begin // mulhsu：有符号 x 无符号高 32 位
alu_op_o = ALU_MULHSU;
md_op_o = MD_MULHSU;
end
3'b011: begin // mulhu：无符号高 32 位
alu_op_o = ALU_MUL;
md_op_o = MD_MULHU;
wb_sel_o = 3'd3; wb_sel_o = 3'd3;
end end
3'b111: begin // remu（课程约定）：取余数 3'b101: begin // divu：无符号商
alu_op_o = ALU_DIVU; alu_op_o = ALU_DIVU;
md_op_o = MD_DIVU;
end
3'b111: begin // remu：无符号余数
alu_op_o = ALU_DIVU;
md_op_o = MD_REMU;
wb_sel_o = 3'd3; wb_sel_o = 3'd3;
end end
default: reg_write_o = 1'b0; default: reg_write_o = 1'b0;
rtl/cpu21_riscv_forward_unit.v → pipelined-cpu/srcs/rtl/cpu21_riscv_forward_unit.v
View File
rtl/cpu21_riscv_hazard_unit.v → pipelined-cpu/srcs/rtl/cpu21_riscv_hazard_unit.v
+4 -1
View File
@@ -37,7 +37,10 @@ module cpu21_riscv_hazard_unit (
assign flush_younger_o = take_irq_i || uret_redirect_i || halt_event_i || redirect_valid_i; assign flush_younger_o = take_irq_i || uret_redirect_i || halt_event_i || redirect_valid_i;
assign pipeline_stall_o = load_use_hazard_o && !flush_younger_o && !halted_i; // 停顿条件里不再包含 flush_younger：冲刷时 valid 位会被清 0、PC/IF-ID 也由
// 冲刷分支（优先级高于停顿）处理，同时发生停顿只会多保持一拍 payload，
// 不影响正确性。这样可以避免把“冲刷”这条长路径引到 payload 的时钟使能上。
assign pipeline_stall_o = load_use_hazard_o && !halted_i;
endmodule endmodule
`default_nettype wire `default_nettype wire
rtl/cpu21_riscv_irq_ctrl.v → pipelined-cpu/srcs/rtl/cpu21_riscv_irq_ctrl.v
View File
pipelined-cpu/srcs/rtl/cpu21_riscv_muldiv.v
+169
View File
@@ -0,0 +1,169 @@
`timescale 1ns / 1ps
`default_nettype none
// -----------------------------------------------------------------------------
// 多周期乘除法单元（时序逻辑，32 拍迭代）
//
// 原来乘除法直接写在 ALU 里（组合的 a*b / a%b）：综合后关键路径约 94 ns
// （325 级逻辑、286 个 CARRY4），100 MHz 下无法收敛，只能把板上 100 MHz 分频
// 到 6.25 MHz 再跑。这里改成移位迭代：
// * 乘法：32 拍移位加法得到 64 位乘积；有符号变体先取操作数绝对值，
// 迭代结束后按符号对 64 位乘积取负。
// * 除法：32 拍恢复余数法得到商与余数；除零按 RISC-V 约定处理
// （商为全 1、余数为被除数）。DIVU/REMU 都是无符号运算，不需要符号修正。
//
// 顶层的 EX 级会停留若干拍（往 EX/MEM 插气泡）等待 done_o 有效，然后照常写回。
// 迭代期间顶层会屏蔽中断，避免在结果未定型时提前推进流水线。
//
// op_i 编码（由 cpu21_riscv_decoder 给出，MD_NONE 表示不是乘除法指令）：
// MD_MUL mul ：无符号乘积低 32 位（有符号乘法的低 32 位与之相同）
// MD_MULH mulh ：有符号 x 有符号，取高 32 位
// MD_MULHSU mulhsu ：有符号 x 无符号，取高 32 位
// MD_MULHU mulhu ：无符号 x 无符号，取高 32 位
// MD_DIVU divu ：无符号商
// MD_REMU remu ：无符号余数
//
// result_o / result2_o 的含义与原来的 ALU 保持一致：乘法时 result_o 为低 32 位、
// result2_o 为高 32 位；除法时 result_o 为商、result2_o 为余数。译码器用 wb_sel
// 决定写回哪一个（mulhu、remu 用 wb_sel=3 取 result2），因此顶层只需把这一对
// 结果接到原来的 EX 结果总线上，其余流水逻辑不用改。
// -----------------------------------------------------------------------------
module cpu21_riscv_muldiv (
input wire clk,
input wire reset, // 异步复位，高有效（与顶层一致）
input wire start_i, // 指令在 EX 级且是乘除法（电平，模块内部只在空闲时响应）
input wire [2:0] op_i, // 乘除法操作类型
input wire [31:0] a_i, // EX 级 src1
input wire [31:0] b_i, // EX 级 src2（ALU 的 B 端）
output wire busy_o, // 迭代中（不含结果定型那一拍）
output wire done_o, // 结果有效（单拍，此时顶层推进流水线）
output wire [31:0] result_o, // 主结果
output wire [31:0] result2_o // 第二结果（乘法高 32 位 / 除法余数）
);
localparam [2:0] MD_NONE = 3'd0;
localparam [2:0] MD_MUL = 3'd1;
localparam [2:0] MD_MULH = 3'd2;
localparam [2:0] MD_MULHSU = 3'd3;
localparam [2:0] MD_MULHU = 3'd4;
localparam [2:0] MD_DIVU = 3'd5;
localparam [2:0] MD_REMU = 3'd6;
localparam [1:0] S_IDLE = 2'd0;
localparam [1:0] S_RUN = 2'd1;
localparam [1:0] S_DONE = 2'd2;
reg [ 1:0] state_q;
reg [ 5:0] cnt_q; // 0..32：0..31 为迭代，32 为结果定型
reg [ 2:0] op_q;
reg is_div_q;
// 乘法数据通路：64 位被乘数（每拍左移）、32 位乘数（每拍右移）、64 位累加器。
reg [63:0] mcand_q;
reg [31:0] mplier_q;
reg [63:0] prod_q;
reg sign_q;
// 除法数据通路：32 位除数、32 位商/被除数移位寄存器、33 位余数。
reg [31:0] dvsr_q;
reg [31:0] quo_q;
reg [32:0] rem_q;
reg [31:0] dvd_q; // 原始被除数（除零时原样返回）
reg div_zero_q;
// 结果寄存器。
reg [31:0] res_q;
reg [31:0] res2_q;
assign busy_o = (state_q == S_RUN);
assign done_o = (state_q == S_DONE);
assign result_o = res_q;
assign result2_o = res2_q;
// 乘法操作数准备：按操作类型决定是否取绝对值，并给出结果符号。
wire a_signed = (op_i == MD_MULH) || (op_i == MD_MULHSU);
wire b_signed = (op_i == MD_MULH);
wire [31:0] a_mag = (a_signed && a_i[31]) ? (~a_i + 32'd1) : a_i;
wire [31:0] b_mag = (b_signed && b_i[31]) ? (~b_i + 32'd1) : b_i;
wire sign_in = ((op_i == MD_MULH) && (a_i[31] ^ b_i[31])) || ((op_i == MD_MULHSU) && a_i[31]);
// 除法的一步（恢复余数法）：把被除数最高位移进余数，够减则减并把商位置 1。
wire [32:0] rem_shift = {rem_q[31:0], quo_q[31]};
wire rem_ge = (rem_shift >= {1'b0, dvsr_q});
wire [32:0] rem_next = rem_ge ? (rem_shift - {1'b0, dvsr_q}) : rem_shift;
wire [31:0] quo_next = {quo_q[30:0], rem_ge};
// 迭代结束时的符号修正：prod_mag 为无符号乘积，sign_q 为 1 时取负。
wire [63:0] prod_fix = sign_q ? (~prod_q + 64'd1) : prod_q;
always @(posedge clk or posedge reset) begin
if (reset) begin
state_q <= S_IDLE;
cnt_q <= 6'd0;
op_q <= MD_NONE;
is_div_q <= 1'b0;
mcand_q <= 64'd0;
mplier_q <= 32'd0;
prod_q <= 64'd0;
sign_q <= 1'b0;
dvsr_q <= 32'd0;
quo_q <= 32'd0;
rem_q <= 33'd0;
dvd_q <= 32'd0;
div_zero_q <= 1'b0;
res_q <= 32'd0;
res2_q <= 32'd0;
end else begin
case (state_q)
// 空闲：指令进入 EX 且是乘除法时装载操作数，下一拍开始迭代。
S_IDLE: begin
if (start_i) begin
state_q <= S_RUN;
cnt_q <= 6'd0;
op_q <= op_i;
is_div_q <= (op_i == MD_DIVU) || (op_i == MD_REMU);
// 乘法初始化（先取绝对值，符号留到最后修正）。
mcand_q <= {32'b0, a_mag};
mplier_q <= b_mag;
prod_q <= 64'd0;
sign_q <= sign_in;
// 除法初始化（无符号）。
dvsr_q <= b_i;
quo_q <= a_i;
rem_q <= 33'd0;
dvd_q <= a_i;
div_zero_q <= (b_i == 32'd0);
end
end
// 迭代：cnt 0..31 各走一步，32 拍后把结果定型。
S_RUN: begin
if (cnt_q == 6'd32) begin
state_q <= S_DONE;
if (is_div_q) begin
res_q <= div_zero_q ? 32'hffff_ffff : quo_q;
res2_q <= div_zero_q ? dvd_q : rem_q[31:0];
end else begin
res_q <= (op_q == MD_MULHU || op_q == MD_MUL) ? prod_fix[31:0] : prod_fix[63:32];
res2_q <= prod_fix[63:32];
end
end else begin
cnt_q <= cnt_q + 6'd1;
if (is_div_q) begin
rem_q <= rem_next;
quo_q <= quo_next;
end else begin
prod_q <= mplier_q[0] ? (prod_q + mcand_q) : prod_q;
mcand_q <= {mcand_q[62:0], 1'b0};
mplier_q <= {1'b0, mplier_q[31:1]};
end
end
end
// 结果有效一拍，顶层据此推进流水线；随后回到空闲。
default: state_q <= S_IDLE;
endcase
end
end
endmodule
`default_nettype wire
rtl/cpu21_riscv_perf_counters.v → pipelined-cpu/srcs/rtl/cpu21_riscv_perf_counters.v
+1 -1
View File
@@ -12,7 +12,7 @@ module cpu21_riscv_perf_counters (
input wire clk, input wire clk,
input wire reset, input wire reset,
input wire inc_cycle_i, // 未停机时周期数 +1 input wire inc_cycle_i, // 未停机时周期数 +1
input wire stall_i, // load-use 停顿 input wire stall_i, // load-use 停顿或多周期乘除法停留
input wire flush_i, // 冲刷年轻指令 input wire flush_i, // 冲刷年轻指令
input wire cond_taken_i, // EX 级条件分支实际跳转 input wire cond_taken_i, // EX 级条件分支实际跳转
input wire cond_valid_i, // EX 级条件分支有效 input wire cond_valid_i, // EX 级条件分支有效
rtl/cpu21_riscv_redirect_int_bpb.v → pipelined-cpu/srcs/rtl/cpu21_riscv_redirect_int_bpb.v
+108 -32
View File
@@ -131,6 +131,7 @@ module cpu21_riscv_redirect_int_bpb #(
reg idex_mem_write_q; reg idex_mem_write_q;
reg idex_mem_byte_q; reg idex_mem_byte_q;
reg [2:0] idex_wb_sel_q; reg [2:0] idex_wb_sel_q;
reg [2:0] idex_md_op_q; // 乘除法操作类型（0=非乘除法）
reg [11:0] idex_csr_addr_q; reg [11:0] idex_csr_addr_q;
reg idex_branch_q; reg idex_branch_q;
reg idex_beq_q; reg idex_beq_q;
@@ -234,6 +235,7 @@ module cpu21_riscv_redirect_int_bpb #(
wire [31:0] d_imm; wire [31:0] d_imm;
wire [3:0] d_aluop; wire [3:0] d_aluop;
wire [2:0] d_wb_sel; wire [2:0] d_wb_sel;
wire [2:0] d_md_op;
wire [11:0] d_csr_addr; wire [11:0] d_csr_addr;
wire d_uses_rs1; wire d_uses_rs1;
wire d_uses_rs2; wire d_uses_rs2;
@@ -265,6 +267,7 @@ module cpu21_riscv_redirect_int_bpb #(
.imm_o (d_imm), .imm_o (d_imm),
.alu_op_o (d_aluop), .alu_op_o (d_aluop),
.wb_sel_o (d_wb_sel), .wb_sel_o (d_wb_sel),
.md_op_o (d_md_op),
.csr_addr_o (d_csr_addr), .csr_addr_o (d_csr_addr),
.uses_rs1_o (d_uses_rs1), .uses_rs1_o (d_uses_rs1),
.uses_rs2_o (d_uses_rs2), .uses_rs2_o (d_uses_rs2),
@@ -289,11 +292,10 @@ module cpu21_riscv_redirect_int_bpb #(
.csr_write_o (d_csr_write) .csr_write_o (d_csr_write)
); );
// 写回值选择：wb_sel 0=ALU 结果，1=访存数据，2=PC+4，3=MUL 高位/余数， // 写回值选择：wb_sel 0=ALU 结果，1=访存数据，2=PC+4（已存在 alu_result 里），
// 4=CSR 旧值。 // 3=MUL 高位/余数，4=CSR 旧值。
wire [31:0] wb_value; wire [31:0] wb_value;
assign wb_value = (memwb_wb_sel_q == 3'd1) ? memwb_mem_data_q : assign wb_value = (memwb_wb_sel_q == 3'd1) ? memwb_mem_data_q :
(memwb_wb_sel_q == 3'd2) ? (memwb_pc_q + 32'd4) :
(memwb_wb_sel_q == 3'd3) ? memwb_alu_result2_q : (memwb_wb_sel_q == 3'd3) ? memwb_alu_result2_q :
(memwb_wb_sel_q == 3'd4) ? memwb_csr_old_q : (memwb_wb_sel_q == 3'd4) ? memwb_csr_old_q :
memwb_alu_result_q; memwb_alu_result_q;
@@ -329,9 +331,10 @@ module cpu21_riscv_redirect_int_bpb #(
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// EX 级：前递网络、ALU 运算、存储对齐与控制流裁决 // EX 级：前递网络、ALU 运算、存储对齐与控制流裁决
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// EX/MEM 级要前递的值（按 wb_sel 选取）。 // EX/MEM 级要前递的值（按 wb_sel 选取）。JAL/JALR 的链接地址（PC+4）已在
// EX 级预先算好并存入 exmem_alu_result_q，所以这里 wb_sel=2 直接取该寄存器，
// 前递路径上不再有 PC+4 加法器（100 MHz 下这是最长路径之一）。
wire [31:0] exmem_forward_value = wire [31:0] exmem_forward_value =
(exmem_wb_sel_q == 3'd2) ? (exmem_pc_q + 32'd4) :
(exmem_wb_sel_q == 3'd3) ? exmem_alu_result2_q : (exmem_wb_sel_q == 3'd3) ? exmem_alu_result2_q :
(exmem_wb_sel_q == 3'd4) ? exmem_csr_old_q : (exmem_wb_sel_q == 3'd4) ? exmem_csr_old_q :
exmem_alu_result_q; exmem_alu_result_q;
@@ -368,7 +371,7 @@ module cpu21_riscv_redirect_int_bpb #(
(idex_csr_addr_q == 12'h004) ? ustatus_value : (idex_csr_addr_q == 12'h004) ? ustatus_value :
(idex_csr_addr_q == 12'h041) ? uepc_value : 32'b0; (idex_csr_addr_q == 12'h041) ? uepc_value : 32'b0;
// ALU 实例（纯组合逻辑）。 // ALU 实例（只做单拍运算；乘除法见下面的多周期单元）。
cpu21_riscv_alu u_ex_alu ( cpu21_riscv_alu u_ex_alu (
.op (idex_aluop_q), .op (idex_aluop_q),
.a (ex_src1), .a (ex_src1),
@@ -377,6 +380,42 @@ module cpu21_riscv_redirect_int_bpb #(
.result2(ex_alu_result2) .result2(ex_alu_result2)
); );
// -------------------------------------------------------------------------
// 多周期乘除法单元：EX 级停留若干拍等待结果，不再把 32x32 乘法/除法
// 放在组合路径上（原来这部分的组合延时约 94 ns，100 MHz 下无法收敛）。
// 指令在 EX 级期间 ex_md_stall 有效：ID/EX 保持不变、EX/MEM 插气泡、
// 取指/译码冻结；迭代结束（md_done）后照常推进。
// -------------------------------------------------------------------------
wire md_busy;
wire md_done;
wire [31:0] md_result;
wire [31:0] md_result2;
wire ex_is_muldiv = idex_valid_q && (idex_md_op_q != 3'd0);
wire ex_md_stall = ex_is_muldiv && !md_done;
cpu21_riscv_muldiv u_muldiv (
.clk (clk),
.reset (reset),
.start_i (ex_is_muldiv),
.op_i (idex_md_op_q),
.a_i (ex_src1),
.b_i (ex_alu_b),
.busy_o (md_busy),
.done_o (md_done),
.result_o (md_result),
.result2_o(md_result2)
);
// EX 级最终结果：乘除法取多周期单元的输出；JAL/JALR（wb_sel=2）的链接地址
// PC+4 在这里算好随流水寄存器传下去，避免“写回值 → 前递 → 停机判定 →
// 流水寄存器时钟使能”这条组合路径上出现 32 位加法器。
wire [31:0] ex_result =
ex_is_muldiv ? md_result :
(idex_wb_sel_q == 3'd2) ? (idex_pc_q + 32'd4) :
ex_alu_result;
wire [31:0] ex_result2 = ex_is_muldiv ? md_result2 : ex_alu_result2;
// 控制流裁决：条件分支方向/目标、JAL/JALR 目标、是否需要重定向。 // 控制流裁决：条件分支方向/目标、JAL/JALR 目标、是否需要重定向。
cpu21_riscv_branch_unit u_branch_unit ( cpu21_riscv_branch_unit u_branch_unit (
.valid_i (idex_valid_q), .valid_i (idex_valid_q),
@@ -450,8 +489,14 @@ module cpu21_riscv_redirect_int_bpb #(
// 中断 / CSR / 嵌套返回栈 // 中断 / CSR / 嵌套返回栈
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
wire ex_uret_redirect = idex_valid_q && idex_uret_q; wire ex_uret_redirect = idex_valid_q && idex_uret_q;
// EX 级正在重定向/URET/停机时不允许响应中断。 // EX 级正在 URET，或乘除法还没算完时，不响应中断：前者与中断同时发生会丢掉
wire ex_block_irq = ex_redirect_valid || ex_uret_redirect || ex_halt_event; // URET 的返回地址，后者会在结果未定型时推进流水线，向 rd 写回错误值。
// 这里不再包含 ex_redirect_valid / ex_halt_event：它们本身就会让
// flush_younger 有效（流水线照常被冲刷），而中断优先于重定向时返回地址由
// irq_save_pc 给出（已正确跳转的分支取目标地址）。这样就把
// “分支判决 → 中断控制器 → flush → 流水寄存器控制”这条 100 MHz 下的
// 关键路径切断了（原来要绕经中断控制器再回到 flush）。
wire ex_block_irq = ex_uret_redirect || ex_md_stall;
// 中断发生时要保存的返回地址取"下一个架构 PC"：若 EX 是一条预测正确 // 中断发生时要保存的返回地址取"下一个架构 PC"：若 EX 是一条预测正确
// 且已跳转的分支，则该 PC 就是它的目标地址；若 EX 为空，则 IF/ID 中 // 且已跳转的分支，则该 PC 就是它的目标地址；若 EX 为空，则 IF/ID 中
// 保存的就是尚未执行的最老指令。 // 保存的就是尚未执行的最老指令。
@@ -581,6 +626,7 @@ module cpu21_riscv_redirect_int_bpb #(
idex_mem_write_q <= 1'b0; idex_mem_write_q <= 1'b0;
idex_mem_byte_q <= 1'b0; idex_mem_byte_q <= 1'b0;
idex_wb_sel_q <= 3'b0; idex_wb_sel_q <= 3'b0;
idex_md_op_q <= 3'b0;
idex_csr_addr_q <= 12'b0; idex_csr_addr_q <= 12'b0;
idex_branch_q <= 1'b0; idex_branch_q <= 1'b0;
idex_beq_q <= 1'b0; idex_beq_q <= 1'b0;
@@ -643,29 +689,48 @@ module cpu21_riscv_redirect_int_bpb #(
memwb_mem_to_reg_q <= exmem_mem_to_reg_q; memwb_mem_to_reg_q <= exmem_mem_to_reg_q;
memwb_wb_sel_q <= exmem_wb_sel_q; memwb_wb_sel_q <= exmem_wb_sel_q;
// EX/MEM 流水寄存器捕获。 // EX/MEM 流水寄存器捕获。乘除法迭代期间（ex_md_stall）往 EX/MEM 插气泡，
exmem_valid_q <= idex_valid_q; // 让乘除法指令继续占用 EX，结果在 md_done 那一拍才写入 EX/MEM。
exmem_pc_q <= idex_pc_q; if (ex_md_stall) begin
exmem_ir_q <= idex_ir_q; exmem_valid_q <= 1'b0;
exmem_alu_result_q <= ex_alu_result; exmem_pc_q <= 32'b0;
exmem_alu_result2_q <= ex_alu_result2; exmem_ir_q <= 32'b0;
exmem_csr_old_q <= ex_csr_old_value; exmem_alu_result_q <= 32'b0;
exmem_write_data_q <= ex_store_data; exmem_alu_result2_q <= 32'b0;
exmem_rd_q <= idex_rd_q; exmem_csr_old_q <= 32'b0;
exmem_reg_write_q <= idex_reg_write_q; exmem_write_data_q <= 32'b0;
exmem_mem_to_reg_q <= idex_mem_to_reg_q; exmem_rd_q <= 5'b0;
exmem_mem_write_q <= idex_mem_write_q; exmem_reg_write_q <= 1'b0;
exmem_wstrb_q <= ex_store_wstrb; exmem_mem_to_reg_q <= 1'b0;
exmem_wb_sel_q <= idex_wb_sel_q; exmem_mem_write_q <= 1'b0;
exmem_wstrb_q <= 4'b0;
// 控制优先级：中断 > URET > ecall 停机 > 分支重定向 > exmem_wb_sel_q <= 3'b0;
// load-use 停顿 > 正常流水推进。
if (flush_younger || pipeline_stall || halted_q) begin
idex_valid_q <= 1'b0;
idex_pred_taken_q <= 1'b0;
idex_pred_target_q <= 32'b0;
end else begin end else begin
idex_valid_q <= ifid_valid_q; exmem_valid_q <= idex_valid_q;
exmem_pc_q <= idex_pc_q;
exmem_ir_q <= idex_ir_q;
exmem_alu_result_q <= ex_result;
exmem_alu_result2_q <= ex_result2;
exmem_csr_old_q <= ex_csr_old_value;
exmem_write_data_q <= ex_store_data;
exmem_rd_q <= idex_rd_q;
exmem_reg_write_q <= idex_reg_write_q;
exmem_mem_to_reg_q <= idex_mem_to_reg_q;
exmem_mem_write_q <= idex_mem_write_q;
exmem_wstrb_q <= ex_store_wstrb;
exmem_wb_sel_q <= idex_wb_sel_q;
end
// ---------------------------------------------------------------------
// ID/EX 装载。
//
// payload（PC/IR/控制位/预测位）只在 load-use 停顿、乘除法迭代、停机时
// 保持（时钟使能与“冲刷”无关），其余情况一律装载；只有 valid 位受冲刷
// 控制，冲刷时清 0。这样“EX 级组合判决（分支/中断）→ 流水寄存器时钟
// 使能”这条 100 MHz 下最长的路径就只剩下一个触发器（valid），payload
// 即使装进错误路径的数据也无害——所有使用者都以 idex_valid_q 为前提。
// ---------------------------------------------------------------------
if (!(pipeline_stall || halted_q || ex_md_stall)) begin
idex_pc_q <= ifid_pc_q; idex_pc_q <= ifid_pc_q;
idex_ir_q <= ifid_ir_q; idex_ir_q <= ifid_ir_q;
idex_rs1_value_q <= d_rs1_value; idex_rs1_value_q <= d_rs1_value;
@@ -681,6 +746,7 @@ module cpu21_riscv_redirect_int_bpb #(
idex_mem_write_q <= d_mem_write; idex_mem_write_q <= d_mem_write;
idex_mem_byte_q <= d_mem_byte; idex_mem_byte_q <= d_mem_byte;
idex_wb_sel_q <= d_wb_sel; idex_wb_sel_q <= d_wb_sel;
idex_md_op_q <= d_md_op;
idex_csr_addr_q <= d_csr_addr; idex_csr_addr_q <= d_csr_addr;
idex_branch_q <= d_branch; idex_branch_q <= d_branch;
idex_beq_q <= d_beq; idex_beq_q <= d_beq;
@@ -700,6 +766,16 @@ module cpu21_riscv_redirect_int_bpb #(
idex_pred_target_q <= ifid_pred_target_q; idex_pred_target_q <= ifid_pred_target_q;
end end
if (halted_q || ex_md_stall) begin
// 停机 / 乘除法迭代：valid 保持不变（指令继续占用 EX）。
end else if (pipeline_stall || flush_younger) begin
// load-use 停顿：load 已经进 EX/MEM，这里给 EX 装一个气泡（payload 保持
// 原值，valid=0 时无害）；冲刷同理。
idex_valid_q <= 1'b0;
end else begin
idex_valid_q <= ifid_valid_q;
end
if (take_irq) begin if (take_irq) begin
pc_q <= irq_vector; pc_q <= irq_vector;
ifid_valid_q <= 1'b0; ifid_valid_q <= 1'b0;
@@ -720,7 +796,7 @@ module cpu21_riscv_redirect_int_bpb #(
ifid_valid_q <= 1'b0; ifid_valid_q <= 1'b0;
ifid_pred_taken_q <= 1'b0; ifid_pred_taken_q <= 1'b0;
ifid_pred_target_q <= 32'b0; ifid_pred_target_q <= 32'b0;
end else if (pipeline_stall) begin end else if (pipeline_stall || ex_md_stall) begin
pc_q <= pc_q; pc_q <= pc_q;
ifid_valid_q <= ifid_valid_q; ifid_valid_q <= ifid_valid_q;
ifid_pc_q <= ifid_pc_q; ifid_pc_q <= ifid_pc_q;
@@ -748,7 +824,7 @@ module cpu21_riscv_redirect_int_bpb #(
.clk (clk), .clk (clk),
.reset (reset), .reset (reset),
.inc_cycle_i (!halted_q), .inc_cycle_i (!halted_q),
.stall_i (pipeline_stall), .stall_i (pipeline_stall || ex_md_stall),
.flush_i (flush_younger), .flush_i (flush_younger),
.cond_taken_i (idex_valid_q && idex_branch_q && ex_branch_taken), .cond_taken_i (idex_valid_q && idex_branch_q && ex_branch_taken),
.cond_valid_i (idex_valid_q && idex_branch_q), .cond_valid_i (idex_valid_q && idex_branch_q),
rtl/cpu21_riscv_regfile.v → pipelined-cpu/srcs/rtl/cpu21_riscv_regfile.v
View File
rtl/cpu21_riscv_store_unit.v → pipelined-cpu/srcs/rtl/cpu21_riscv_store_unit.v
View File
testbench/tb_board_top.v → pipelined-cpu/srcs/tb/tb_board_top.v
+1 -1
View File
@@ -49,7 +49,7 @@ module tb_board_top;
$display("NOTE: 复位后观察 LED（默认程序首次写入应为 0001）"); $display("NOTE: 复位后观察 LED（默认程序首次写入应为 0001）");
repeat (10) @(posedge clk100); repeat (10) @(posedge clk100);
rst_n = 1'b1; rst_n = 1'b1;
repeat (30000) @(posedge clk100); // 300 us（CPU 时钟经 16 分频，需要更长窗口） repeat (30000) @(posedge clk100); // 300 us（CPU 时钟为 clk100/2 = 50 MHz）
$display("FINAL: LED 变化次数=%0d 当前 LED=%04h", changes, led); $display("FINAL: LED 变化次数=%0d 当前 LED=%04h", changes, led);
$finish; $finish;
end end
testbench/tb_cpu21_riscv_redirect_int_bpb.v → pipelined-cpu/srcs/tb/tb_cpu21_riscv_redirect_int_bpb.v
+5
View File
@@ -235,6 +235,11 @@ module tb_cpu21_riscv_redirect_int_bpb #(
if (!rom_loaded) load_rom_image({"../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../testbench/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../../../testbench/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../../../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../../../../../testbench/rom/", ROM_FILE}, rom_loaded);
// 分享出去的 Vivado 工程里的镜像目录（工程目录/srcs/rom/），GUI 仿真的工作
// 目录是 <proj>.sim/sim_1/behav/xsim，所以需要向上 5 层。
if (!rom_loaded) load_rom_image({"srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../../../srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) if (!rom_loaded)
$display( $display(
"WARNING: no ROM image found for \"%0s\" - the ROM stays filled with NOPs (0x00000013).", "WARNING: no ROM image found for \"%0s\" - the ROM stays filled with NOPs (0x00000013).",
testbench/tb_no_intr.v → pipelined-cpu/srcs/tb/tb_no_intr.v
+5
View File
@@ -238,6 +238,11 @@ module tb_no_intr #(
if (!rom_loaded) load_rom_image({"../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../testbench/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../../../testbench/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../../../testbench/rom/", ROM_FILE}, rom_loaded); if (!rom_loaded) load_rom_image({"../../../../../testbench/rom/", ROM_FILE}, rom_loaded);
// 分享出去的 Vivado 工程里的镜像目录（工程目录/srcs/rom/），GUI 仿真的工作
// 目录是 <proj>.sim/sim_1/behav/xsim，所以需要向上 5 层。
if (!rom_loaded) load_rom_image({"srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) load_rom_image({"../../../../../srcs/rom/", ROM_FILE}, rom_loaded);
if (!rom_loaded) if (!rom_loaded)
$display( $display(
"WARNING: no ROM image found for \"%0s\" - the ROM stays filled with NOPs (0x00000013).", "WARNING: no ROM image found for \"%0s\" - the ROM stays filled with NOPs (0x00000013).",
tools/hex2vh.py → pipelined-cpu/tools/hex2vh.py
+1 -1
View File
@@ -8,7 +8,7 @@
rom[0] = 32'h00001037; rom[0] = 32'h00001037;
rom[1] = 32'h00100093; rom[1] = 32'h00100093;
配套 RTL 用法（见 board/cpu21_board_top.v，两者同目录，所以 include 能直接解析）： 配套 RTL 用法（见 srcs/board/cpu21_board_top.v，两者同目录，所以 include 能直接解析）：
initial begin initial begin
for (i = 0; i < ROM_WORDS; i = i + 1) rom[i] = 32'h0000_0013; // NOP 填充 for (i = 0; i < ROM_WORDS; i = i + 1) rom[i] = 32'h0000_0013; // NOP 填充
pipelined-cpu/tools/run_regress.ps1
+109
View File
@@ -0,0 +1,109 @@
# ============================================================================
# cpu21-riscv 回归脚本（Vivado xsim）
#
# 在工程目录 pipelined-cpu/ 下运行：
# powershell -ExecutionPolicy Bypass -File tools\run_regress.ps1
#
# 做四件事：
# 1) 逐个跑指令测试：muldiv_test / isa_test / lui_test / mmio_test，
# 把测试平台打印的 LED 序列与 programs/<名字>.expected 逐值比对；
# 2) 跑两个流水基线（默认 ROM）：tb_no_intr、tb_cpu21_riscv_redirect_int_bpb，
# 只打印 FINAL 统计行，便于和已知基线核对；
# 3) 跑板级顶层（-d BOARD_ROM_FAST），检查跑马灯 LED 序列；
# 4) 最后汇总 PASS/FAIL 并按失败数设置退出码。
#
# 编译与仿真都放在 $env:TEMP\cpu21_regress 下，不会往工程目录写中间文件。
# 需要 xvlog / xelab / xsim 在 PATH 上（Vivado 安装目录的 bin）。
# ============================================================================
$ErrorActionPreference = 'Stop'
$proj = Split-Path -Parent $PSScriptRoot # tools/ 的上一级就是工程目录
$projF = ($proj -replace '\\', '/') # Verilog 字符串里要用正斜杠
$sim = Join-Path $env:TEMP 'cpu21_regress'
$enc = New-Object System.Text.UTF8Encoding($false)
foreach ($tool in 'xvlog', 'xelab', 'xsim') {
if (-not (Get-Command $tool -ErrorAction SilentlyContinue)) {
Write-Output "ERROR: 找不到 $tool，请把 Vivado 的 bin 目录加到 PATH"
exit 1
}
}
New-Item -ItemType Directory -Force $sim | Out-Null
Set-Content -Path "$sim\run.tcl" -Value @('run all', 'quit') -Encoding ascii
$RTL = @(Get-ChildItem "$proj\srcs\rtl\*.v" | ForEach-Object FullName)
$fail = 0
# TB 里的 ROM_FILE 参数默认是文件名，这里替换成绝对路径（PowerShell 传参有坑，
# 直接改副本最稳）
function Sim-Top {
param($Top, $TbFile, $DefaultRom, $RealRom, $Snap)
$txt = [System.IO.File]::ReadAllText($TbFile, $enc)
$new = $txt.Replace('"' + $DefaultRom + '"', '"' + $projF + '/srcs/rom/' + $RealRom + '"')
[System.IO.File]::WriteAllText("$sim\$Snap.v", $new, $enc)
Remove-Item -Recurse -Force "$sim\xsim.dir" -ErrorAction SilentlyContinue
& xvlog @RTL "$sim\$Snap.v" 2>&1 | Out-File -Encoding ascii "$sim\xvlog_$Snap.txt"
& xelab -top $Top -snapshot $Snap 2>&1 | Out-File -Encoding ascii "$sim\xelab_$Snap.txt"
& xsim $Snap -tclbatch run.tcl 2>&1 | Out-File -Encoding ascii "$sim\run_$Snap.txt"
$err = Select-String -Path "$sim\xvlog_$Snap.txt", "$sim\xelab_$Snap.txt" -Pattern 'ERROR' |
Select-Object -First 1 -ExpandProperty Line
if ($err) { Write-Output "!! $Snap : $err"; $script:fail++ }
}
Push-Location $sim
try {
Write-Output '===== 1) 指令测试（tb_no_intr，与 programs/*.expected 比对）====='
foreach ($t in 'muldiv_test', 'isa_test', 'lui_test', 'mmio_test') {
Sim-Top -Top tb_no_intr -TbFile "$proj\srcs\tb\tb_no_intr.v" `
-DefaultRom 'risc-v-benchmark_ccab.hex' -RealRom "$t.hex" -Snap "sim_$t"
$log = "$sim\run_sim_$t.txt"
$obs = @(Select-String -Path $log -Pattern 'LEDv=1 LED=([0-9a-fA-F]{8})' -AllMatches |
ForEach-Object { $_.Matches[0].Groups[1].Value.ToLower() })
$exp = @(Get-Content "$proj\programs\$t.expected" |
ForEach-Object { $_.Trim().ToLower() } | Where-Object { $_ -ne '' })
if (($obs -join ',') -eq ($exp -join ',')) {
Write-Output (" {0,-13} PASS ({1} 个 LED 值)" -f $t, $obs.Count)
} else {
Write-Output (" {0,-13} FAIL 期望 {1} / 观测 {2}" -f $t, $exp.Count, $obs.Count)
Write-Output (" 期望: " + ($exp -join ' '))
Write-Output (" 观测: " + ($obs -join ' '))
$fail++
}
Write-Output (' ' + (Select-String -Path $log -Pattern 'FINAL:' |
Select-Object -First 1 -ExpandProperty Line))
}
Write-Output '===== 2) 流水基线（默认 ROM）====='
Sim-Top -Top tb_no_intr -TbFile "$proj\srcs\tb\tb_no_intr.v" `
-DefaultRom 'risc-v-benchmark_ccab.hex' -RealRom 'risc-v-benchmark_ccab.hex' -Snap 'base_no_intr'
Write-Output (' tb_no_intr : ' + (Select-String -Path "$sim\run_base_no_intr.txt" -Pattern 'FINAL:' |
Select-Object -First 1 -ExpandProperty Line))
Sim-Top -Top tb_cpu21_riscv_redirect_int_bpb -TbFile "$proj\srcs\tb\tb_cpu21_riscv_redirect_int_bpb.v" `
-DefaultRom 'cpu21_riscv_redirect_int_bpb_rom.hex' -RealRom 'cpu21_riscv_redirect_int_bpb_rom.hex' `
-Snap 'base_intr'
Write-Output (' tb_intr : ' + (Select-String -Path "$sim\run_base_intr.txt" -Pattern 'FINAL:' |
Select-Object -First 1 -ExpandProperty Line))
Write-Output '===== 3) 板级顶层（-d BOARD_ROM_FAST，跑马灯）====='
Remove-Item -Recurse -Force "$sim\xsim.dir" -ErrorAction SilentlyContinue
& xvlog -d BOARD_ROM_FAST @RTL "$proj\srcs\board\cpu21_board_top.v" "$proj\srcs\tb\tb_board_top.v" 2>&1 |
Out-File -Encoding ascii "$sim\xvlog_board.txt"
& xelab -top tb_board_top -snapshot board -d BOARD_ROM_FAST 2>&1 | Out-File -Encoding ascii "$sim\xelab_board.txt"
& xsim board -tclbatch run.tcl 2>&1 | Out-File -Encoding ascii "$sim\run_board.txt"
$seq = @(Select-String -Path "$sim\run_board.txt" -Pattern 'LED=([0-9a-f]{4})' -AllMatches |
ForEach-Object { $_.Matches[0].Groups[1].Value })
Write-Output (' 前 18 个 LED: ' + (($seq[0..17]) -join ' '))
Write-Output (" 变化次数: " + $seq.Count)
if (($seq[0..17] -join ' ') -ne '0000 0001 0002 0004 0008 0010 0020 0040 0080 0100 0200 0400 0800 1000 2000 4000 8000 0001') {
Write-Output ' FAIL：跑马灯序列与预期不符'; $fail++
} else {
Write-Output ' PASS'
}
} finally {
Pop-Location
}
Write-Output ''
if ($fail -eq 0) { Write-Output '全部通过 (所有回归 PASS)' } else { Write-Output "有 $fail 项失败" }
exit $fail
tools/rv_asm.py → pipelined-cpu/tools/rv_asm.py
+3 -1
View File
@@ -9,7 +9,7 @@
lw/sw/sb、beq/bne/blt/bge/bltu/bgeu、lui、jal/jalr、ecall、标签、# 注释 lw/sw/sb、beq/bne/blt/bge/bltu/bgeu、lui、jal/jalr、ecall、标签、# 注释
伪指令：print（= lui t6,LED_ADDR>>12 + sw a0,0(t6)，向 MMIO 的 LED 寄存器写入 a0）、 伪指令：print（= lui t6,LED_ADDR>>12 + sw a0,0(t6)，向 MMIO 的 LED 寄存器写入 a0）、
halt（= addi a7,zero,10 + ecall），各占两个字。 halt（= addi a7,zero,10 + ecall），各占两个字。
示例：python tools/rv_asm.py testbench/programs/isa_test.asm out.hex 示例：python tools/rv_asm.py programs/isa_test.asm srcs/rom/isa_test.hex
""" """
import re import re
@@ -130,6 +130,8 @@ RTYPE = {
"mulh": (0x01, 1), "mulh": (0x01, 1),
"mulhsu": (0x01, 2), "mulhsu": (0x01, 2),
"mulhu": (0x01, 3), "mulhu": (0x01, 3),
"divu": (0x01, 5),
"remu": (0x01, 7),
} }
ITYPE = {"addi": 0, "slti": 2, "sltiu": 3, "xori": 4, "ori": 6, "andi": 7} ITYPE = {"addi": 0, "slti": 2, "sltiu": 3, "xori": 4, "ori": 6, "andi": 7}
SHIFT = {"slli": 1, "srli": 5, "srai": 5} SHIFT = {"slli": 1, "srli": 5, "srai": 5}