Verilog/SystemVerilog 程序语句详解

Verilog 和 SystemVerilog 中的程序语句（Procedural Statements）是指用于描述电路行为的代码结构，主要用于过程块（procedural blocks）中，如always、initial、task、function等。这些语句允许设计师用顺序执行的方式描述逻辑（类似于软件编程），但在硬件中会被综合为并行电路。程序语句与连续赋值（assign）不同，后者是声明式（declarative），而程序语句是过程式（procedural）。

程序语句的核心目的是：

• 描述时序逻辑（时钟驱动）。
• 描述组合逻辑（敏感列表驱动）。
• 支持仿真初始化、测试激励。
• SystemVerilog 扩展了更多高级语句，如foreach、do-while。

关键概念（2026 年主流实践）：

• 阻塞赋值（=）：顺序执行，用于组合逻辑或测试台。
• 非阻塞赋值（<=）：并行执行，用于时序逻辑，避免竞争冒险。
• 过程块：语句必须在always、initial等块内。
• 可综合性：RTL 设计中，避免非硬件结构（如无限循环）；工具（如 Vivado）会推断为门/触发器。
• 注意事项：敏感列表不全会导致锁存器；SystemVerilog 用always_comb、always_ff提升安全性。

下面用表格总结常见程序语句，然后提供示例代码和完整例子。

1. 常见程序语句总结表

• SystemVerilog 扩展：foreach（数组迭代）、disable（中断块）、return（早退函数）等，提高表达力。

2. 示例代码：基本程序语句使用

以下是一个简单模块，展示多种语句的组合。

// procedural_statements_example.v (SystemVerilog 风格) module procedural_example ( input logic clk, input logic rst_n, input logic [3:0] data_in, output logic [3:0] data_out, output logic done ); typedef enum logic [1:0] {IDLE, PROC, FINISH} state_t; // enum 结合 case state_t state; logic [3:0] sum; // initial: 初始化（非综合） initial begin state = IDLE; end // always_ff: 时序过程块 always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin state <= IDLE; data_out <= 4'b0; done <= 1'b0; end else begin case (state) // case 语句 IDLE: begin if (data_in > 0) state <= PROC; end PROC: begin state <= FINISH; done <= 1'b1; end FINISH: state <= IDLE; default: state <= IDLE; endcase end end // always_comb: 组合过程块 always_comb begin sum = 0; for (int i=0; i<4; i++) begin // for 循环 sum += data_in[i]; end end // assign: 连续赋值 assign data_out = (state == PROC) ? sum : 4'b0; // 条件运算符 // task 示例（非综合，用于测试） task automatic print_state(); $display("Current state: %s", state.name); endtask // function 示例 function logic [3:0] add_one(logic [3:0] val); return val + 1; endfunction endmodule

• 解释：
  • always_ff：时序 FSM，使用 case 和 if。
  • always_comb：组合求和，使用 for。
  • assign：条件输出。
  • task/function：子程序示例。

3. 完整例子：带测试台的计数器（使用多种语句）

这是一个 4 位计数器，使用 always、if、repeat 等。包括 testbench。

• DUT 模块（counter.v）：

module counter ( input logic clk, input logic rst_n, input logic en, output logic [3:0] count ); always @(posedge clk or negedge rst_n) begin // always 块 if (!rst_n) begin // if 语句 count <= 4'b0; end else if (en) begin if (count == 4'b1111) begin // 嵌套 if count <= 4'b0; end else begin count <= count + 1; end end end endmodule

• 测试台（tb_counter.v）：

module tb_counter; logic clk = 0; logic rst_n = 1; logic en = 0; logic [3:0] count; counter dut (.clk(clk), .rst_n(rst_n), .en(en), .count(count)); always #5 clk = ~clk; // always + forever 隐式 initial begin // initial 块 rst_n = 0; #10; rst_n = 1; en = 1; repeat(20) begin // repeat 循环 #10; $display("count = %b", count); end $finish; end // fork-join: 并行执行（可选示例） initial fork #50 en = 0; // 暂停计数 #100 en = 1; // 恢复 join endmodule

• 仿真结果示例：

  count = 0000 count = 0001 ... count = 1111 count = 0000 // 溢出复位

• 解释：结合 always（时序）、if-else（决策）、repeat（重复）、fork-join（并行）。

4. 最佳实践与注意事项

• 阻塞 vs 非阻塞：时序用<=，组合用=。
• SystemVerilog 优势：用always_ff强制时序，工具检查敏感列表。
• 调试：用 $display 在 initial 中打印；波形查看执行顺序。
• 常见错误：for 无限循环导致仿真挂起；case 无 default 推断锁存。
• 工具：ModelSim 支持所有语句；Vivado 综合报告推断硬件。

Verilog / SystemVerilog 中阻塞赋值与非阻塞赋值的详解

阻塞赋值（Blocking Assignment）和非阻塞赋值（Non-blocking Assignment）是 Verilog/SystemVerilog 中最重要、最容易出错的两个赋值操作符。它们直接决定了代码的仿真行为和综合后硬件的正确性。

核心对比表（2026 年最常用总结）

1. 直观理解：一句话比喻

• 阻塞赋值=：像写软件程序，上一行算完才执行下一行（顺序、立即生效）。
• 非阻塞赋值<=：像硬件并行，所有寄存器在同一个时钟上升沿同时更新（像一群人同时跳水，不是一个接一个）。

2. 经典错误案例对比（强烈建议每个人都跑一遍仿真）

module race_condition_example ( input logic clk, input logic rst_n, input logic en, output logic [3:0] count_wrong, // 用 = 写，会出问题 output logic [3:0] count_right // 用 <= 写，正确 ); // 错误写法：用阻塞赋值实现计数器 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin count_wrong <= 4'b0; // 这里用 <= 也没问题 end else if (en) begin count_wrong = count_wrong + 1; // ← 用 = ！！ end end // 正确写法：用非阻塞赋值 always @(posedge clk or negedge rst_n) begin if (!rst_n) begin count_right <= 4'b0; end else if (en) begin count_right <= count_right + 1; // ← 用 <= ！！ end end endmodule

为什么 count_wrong 会错？

在同一个 always 块中，如果把count_wrong = count_wrong + 1写成阻塞赋值，仿真器会：

1. 读取旧的 count_wrong 值
2. 立即计算 +1
3. 立即把新值写回去

→ 下一周期读取的永远是已经更新后的值，导致计数永远只加 1，但如果有多个寄存器互相依赖，顺序就乱了，出现竞争冒险。

而非阻塞<=：

1. 读取所有旧值
2. 计算所有新值
3. 在时间步结束时统一更新所有寄存器

→ 所有寄存器看到的是上一周期的旧值，行为与真实 D 触发器一致。

3. 推荐使用规范（2026 年业界共识）

1. 任何描述**时钟驱动寄存器**的 always 块 → 一律写成 always_ff + 非阻塞赋值 <= 2. 任何描述**纯组合逻辑**的块 → 一律写成 always_comb + 阻塞赋值 = 3. 测试台（testbench）里 → 随意（但建议激励用阻塞，等待用非阻塞） 4. **永远不要**在同一个 always 块中混用 = 和 <=（极易出问题） 5. 现代工具强烈建议用： - always_ff @(posedge clk ...) → 只写 <= - always_comb → 只写 = - always_latch → 只写 =（锁存器场景）

4. 组合逻辑 vs 时序逻辑对比示例

// 组合逻辑：用阻塞赋值 = always_comb begin if (sel) y = a; else y = b; // 阻塞，顺序执行，正确 end // 时序逻辑：用非阻塞赋值 <= always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin q1 <= 0; q2 <= 0; end else begin q1 <= d; // 所有 <= 在时钟沿同时更新 q2 <= q1; // q2 得到的是上一周期的 q1（正确） // 如果这里用 =，q2 会得到当前周期的新 q1（错误！） end end

5. 一句话总结（背下来能少踩无数坑）

时钟驱动的寄存器 → 必须用 <=（非阻塞） 纯组合逻辑 → 必须用 =（阻塞） 测试台激励 → 爱怎么写怎么写，但建议统一风格

最重要铁律（写在键盘上都行）：
always_ff里面只许用<=，写=就打自己手！

Verilog / SystemVerilog 中流水线（Pipeline）赋值顺序的典型示例与详解

在设计多级流水线时，非阻塞赋值<=的使用顺序和行为是决定流水线是否正确工作的核心。
下面通过几个经典的例子，从简单到复杂，完整说明“赋值顺序”对流水线行为的影响。

1. 最经典的错误写法 vs 正确写法对比（2级流水线加法器）

module pipeline_adder_wrong ( input logic clk, input logic rst_n, input logic signed [7:0] a, b, output logic signed [8:0] result ); logic signed [8:0] stage1_sum; // 第一级：a + b logic signed [8:0] stage2_sum; // 第二级：加一个常数 // 错误写法：用了阻塞赋值 = always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin stage1_sum <= 0; stage2_sum <= 0; result <= 0; end else begin stage1_sum = a + b; // ← 用 = 阻塞 stage2_sum = stage1_sum + 5; // ← 立即看到新值！ result = stage2_sum; // ← 最终输出错位 end end endmodule

上面这段代码的实际行为（错误）：

• stage1_sum 立即更新为 a + b（新值）
• stage2_sum 立即看到新的 stage1_sum → 相当于 stage2_sum = (a + b) + 5
• result 立即看到新的 stage2_sum
• 结果：整个流水线被“压扁”成了一级组合逻辑，失去了流水线延迟的效果

正确写法（使用非阻塞赋值 <=）

module pipeline_adder_correct ( input logic clk, input logic rst_n, input logic signed [7:0] a, b, output logic signed [8:0] result ); logic signed [8:0] stage1_sum; logic signed [8:0] stage2_sum; always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin stage1_sum <= 0; stage2_sum <= 0; result <= 0; end else begin stage1_sum <= a + b; // ← 非阻塞 stage2_sum <= stage1_sum + 5; // ← 看到的是上一周期的 stage1_sum result <= stage2_sum; // ← 看到的是上一周期的 stage2_sum end end endmodule

正确行为（时序图理解）：

周期 n : 输入 a_n, b_n 周期 n+1 : stage1_sum = a_n + b_n 周期 n+2 : stage2_sum = (a_n + b_n) + 5 周期 n+3 : result = (a_n + b_n) + 5

→ 完美的 3 周期延迟（输入到输出延迟 2 个时钟周期）

2. 3级流水线乘法器（带寄存器流水）

module pipeline_multiplier ( input logic clk, input logic rst_n, input logic signed [7:0] a, b, output logic signed [15:0] result ); // 流水线寄存器 logic signed [7:0] a_r1, b_r1; // 第1级寄存 logic signed [15:0] prod_r2; // 第2级：乘法结果 logic signed [15:0] result_r3; // 第3级：输出寄存 always_ff @(posedge clk or negedge rst_n) begin if (!rst_n) begin a_r1 <= 0; b_r1 <= 0; prod_r2 <= 0; result_r3 <= 0; result <= 0; end else begin // 第1级：寄存输入 a_r1 <= a; b_r1 <= b; // 第2级：执行乘法（使用上一周期的寄存值） prod_r2 <= a_r1 * b_r1; // 第3级：输出寄存（可用于进一步处理或打拍） result_r3 <= prod_r2; // 最终输出（也可以直接用 prod_r2，看延迟需求） result <= result_r3; end end endmodule

时序分析：

• 周期 n → 输入 a_n, b_n
• 周期 n+1 → a_r1 = a_n, b_r1 = b_n
• 周期 n+2 → prod_r2 = a_n × b_n
• 周期 n+3 → result_r3 = a_n × b_n
• 周期 n+4 → result = a_n × b_n

→ 典型 3 周期流水线延迟（从输入到输出延迟 3 个周期）

3. 常见流水线赋值错误总结表

4. 终极口诀（写在工位上都行）

流水线设计铁律： 1. 所有寄存器更新（带时钟的） → 一律用 <= 2. 所有寄存器的下一级输入 → 来自上一级的寄存器输出（而非组合逻辑直通） 3. 同一个 always_ff 块里 → 全部用非阻塞赋值 <=，绝不混用 = 4. 如果看到流水线延迟不对、数据错位、提前/滞后一拍 → 99% 是赋值顺序问题

掌握了这些，你在写任何多级流水线（加法器、乘法器、FIR、卷积、神经网络加速器等）时，都能避免最常见的致命错误。

需要更复杂的例子吗？
例如：

• 带数据有效信号的流水线
• 多路选择 + 流水线冲突处理
• 3-5 级经典 MIPS 流水线片段
• 错误写法导致时序爆炸的真实案例