组合逻辑与时序逻辑：锁存器为什么是个坑、= 和 <= 别用错

更新时间：2026-09-05。本文是「集成电路大类 · 芯片设计」入门层（beginner）第八篇新正文。从代码到门电路 里我们见过 assign（没时钟）和 always @(posedge clk)（有时钟）两种写法。这一篇把数字电路最根本的二分法——组合逻辑 vs 时序逻辑——讲透，并解决两个让新手掉坑最多的问题：莫名其妙综合出的锁存器（latch），以及 = 和 <= 的赋值区别。它们背后的节拍原理见 时钟与复位。

本文要回答的问题

• 怎么一眼判断一段逻辑是组合还是时序？
• 为什么 always @(*) 里漏一个分支，就会「长出锁存器」？锁存器为什么不好？
• =（阻塞）和 <=（非阻塞）到底什么区别，用错会怎样？
• 写组合逻辑和时序逻辑，各自的安全模板是什么？

一、两类逻辑的本质区别

	组合逻辑（combinational）	时序逻辑（sequential）
输出取决于	仅当前输入	当前输入 + 过去状态
有没有记忆	无（不含触发器）	有（含触发器/寄存器）
有没有时钟	无	有，时钟沿更新
Verilog 写法	assign 连续赋值 / always @(*)	always @(posedge clk)
赋值符号	阻塞 =	非阻塞 <=
典型元件	与/或/非门、加法器、MUX、比较器	触发器、寄存器、计数器、状态机
延迟来源	门延迟（信号传播）	时钟周期（沿到沿）

一句话：组合逻辑是「算」，时序逻辑是「记 + 在节拍上更新」。 真实芯片几乎都是「组合逻辑算结果 → 触发器在时钟沿存下 → 反馈给下一级组合逻辑」的反复拼接（见 时钟与复位 的反馈环图）。

二、组合逻辑：务必「输出在所有情况下都被赋值」

组合逻辑用 always @(*) 或 assign 写。铁律是：每个被赋值的输出，在所有输入组合下都必须被赋值，否则它在「没被赋值的那些情况」下就得保持原值——而「保持」需要记忆，综合工具就会给你变出一个锁存器（latch）。

// ❌ 危险：sel=11 时 out 没赋值 → 综合出隐式锁存器
always @(*) begin
  case (sel)
    2'd0: out = a;
    2'd1: out = b;
    2'd2: out = c;
  endcase            // 缺 default！sel=3 时 out 只能「保持」
end

// ✅ 安全：补全 default（或开头先给 out 一个默认值）
always @(*) begin
  out = 8'd0;        // 先给默认值，所有分支都有归宿
  case (sel)
    2'd0: out = a;
    2'd1: out = b;
    2'd2: out = c;
    default: out = 8'd0;
  endcase
end

if 也一样：always @(*) 里只有 if 没有 else，条件不满足时输出就要保持，同样长出 latch。

三、锁存器为什么是个坑

锁存器（latch）和触发器（flip-flop）都能存 1 比特，但触发方式不同：触发器在时钟沿那一瞬间更新，锁存器是电平敏感的——使能有效期间输出「透明」、跟着输入走，关闭时才锁住。这种「一段时间内直通」的行为带来一堆麻烦：

• 时序分析困难：latch 借用时间（time borrowing）、电平敏感，STA 工具分析起来比沿触发触发器复杂，容易藏时序问题（见 静态时序分析入门）。
• 易受毛刺影响：透明期间输入上的毛刺会直接穿到输出。
• 通常非预期：新手写组合逻辑时「不小心」综合出的 latch，几乎都不是设计本意，而是漏分支的 bug。

所以标准实践是：同步设计里一律用触发器，组合逻辑里绝不允许隐式 latch。综合工具和 lint 检查会专门报「inferred latch」警告，看到就要回去补全分支。真正有意使用 latch 的场景（如某些低功耗/高速电路）属于进阶话题，初学者先做到「组合逻辑零 latch」。

四、= 与 <=：阻塞 vs 非阻塞

Verilog 有两种赋值，用错会导致仿真结果和综合出的硬件不一致——最隐蔽的一类 bug：

• 阻塞赋值 =：像普通程序语言，立即赋值，语句按书写顺序「一行做完再做下一行」。用于组合逻辑。
• 非阻塞赋值 <=：块开始时先把右边的值都「记下」，块结束时统一更新左边。用于时序逻辑——它模拟了「所有触发器在同一时钟沿同时更新」的硬件行为。

// 时序逻辑：用 <=，两个触发器在同一沿各自拿到对方的「旧值」
always @(posedge clk) begin
  b <= a;     // b 得到这一拍之前的 a
  c <= b;     // c 得到这一拍之前的 b（不是刚更新的 b）
end

// 若误用 =：b 先被赋成 a，c 又赋成「新的 b」= a
// 结果仿真里 c 和 b 都等于 a，与实际两级寄存器硬件不符！

记忆规则（业界共识）：

1. 时序逻辑（always @(posedge clk)）里，输出赋值一律用 <=；
2. 组合逻辑（always @(*) / assign）里，一律用 =；
3. 不要在同一个 always 块里混用两种赋值；
4. 组合逻辑用 always @(*) + 阻塞 =，时序逻辑用 always @(posedge clk) + 非阻塞 <=。

五、两张安全模板

// 【组合逻辑模板】@(*) + 阻塞 = + 先给默认值（防 latch）
always @(*) begin
  y = 1'b0;                 // 默认值，保证所有路径都赋值
  if (sel) y = a;
  else     y = b;
end

// 【时序逻辑模板】@(posedge clk) + 非阻塞 <= + 复位
always @(posedge clk or negedge rst_n) begin
  if (!rst_n) begin
    q <= 8'd0;
  end else begin
    q <= d;                 // 沿上更新
  end
end

把这两段刻进肌肉记忆，就能避开 80% 的新手 RTL 事故。更多写法规范见 RTL 设计入门、Verilog 语法速览。

六、同步设计的世界观：寄存器与组合逻辑的分层

把两类逻辑放到一起看，整个同步数字系统只有一种统一结构，就是反复出现的寄存器—组合逻辑—寄存器环：

      ┌──────────────┐      ┌─────────────────┐      ┌──────────────┐
时钟→│ 寄存器 R1    │──D──▶│ 组合逻辑 F(x)    │──Y──▶│ 寄存器 R2    │
      └──────────────┘      └─────────────────┘      └──────────────┘
            ▲                                             │
            └────────────── 反馈/下一拍状态 ◀─────────────┘

每个时钟上升沿，所有寄存器同时把输入端 D 的当前值"拍下"变成 Q；两沿之间，组合逻辑根据这些 Q 算出新结果，送到下一级 D 端等待下一个沿。于是：

• 系统的状态只存在寄存器里，组合逻辑不保存任何东西，只是输入到输出的瞬时函数；
• 时钟周期必须足够长，让信号"沿触发 R1 → 穿过 F → 在 R2 的建立时间前稳定"——这就是 setup 检查 T ≥ t_co + t_logic + t_route + t_setup 的来源（见 时序为什么不满足、建立保持与亚稳态）；
• 只要所有状态变化都对齐到时钟沿，整个系统的行为就能按"拍"离散分析，不依赖每一级门的精确延迟——这正是同步设计为什么成为主流：用统一节拍屏蔽了模拟延迟的复杂性。

理解这个模型，你就能给任意一段 RTL"对号入座"：always @(*) 描述的是中间那块 F，always @(posedge clk) 描述的是两边的寄存器以及"何时把 F 的结果收下"。所谓数据通路（datapath）是宽的组合逻辑（加法器、MUX、移位），所谓控制通路（control）是一组寄存器（状态机）加少量组合译码（见 有限状态机入门）。

七、锁存器专题：它到底是什么、什么时候才有意用

既然同步设计要"零意外 latch"，为什么标准单元库里还有 DLH/DLR 这类锁存器单元？因为锁存器本身不是错误，意外推断出的锁存器才是错误。

**D 锁存器（D-latch，电平敏感）**有一个使能 E（有时叫 G）：

• E = 1（透明期）：Q = D，输出像一根导线一样跟随输入，所以又叫"透明锁存器"；
• E = 0（保持期）：Q 冻结在 E 下降那一刻的 D 值，与之后 D 的变化无关。

对应 RTL 是电平敏感的 always：

// D 锁存器：en 高电平时 q 跟随 d，en 拉低后保持
always @(*) begin
  if (en) q_lat = d;     // 注意：没有 else！en=0 时 q_lat 保持 → 正是 latch
end

对比边沿 D 触发器：它只在 clk 上升沿采一下 D，其余时间 D 怎么变都不影响 Q（触发器内部其实是"主锁存器 + 从锁存器"两级、两相互补时钟串联，保证只在边沿开一条瞬时缝）。

特性	锁存器 latch	触发器 flip-flop
敏感方式	电平（一段时间透明）	边沿（一瞬间）
时间模型	借用时间 time borrowing	明确的沿到沿
STA 分析	复杂（需锁存器专用分析）	简单、工具默认
面积/速度	略小、可吸收抖动	规整、友好
同步设计立场	默认避免，仅有意使用	主力状态元件

什么时候才有意用 latch：① 高速/低功耗定制数据通路中用锁存器做时间借用（让长路径多占一点相邻周期的余量）；② 时钟门控单元（ICG）内部用锁存器防止使能信号在时钟高电平期间产生毛刺；③ 某些保持型宏单元。这些都由有经验的设计者显式实例化，而不是靠 always @(*) 漏分支"长"出来。新手阶段的纪律只有一条：组合块输出在所有分支都赋值，让"inferred latch"警告数量永远是 0。

八、非阻塞赋值的仿真细节：为什么同一沿读到的是旧值

<= 的"统一更新"不是玄学，它对应 Verilog 仿真器的调度区域（scheduling regions）：一个时间步内，所有活动事件先在"活动区"按顺序执行 RHS 采样、把更新排进"非阻塞更新区"，等这一步所有 RHS 都算完，才在更新区统一落地 LHS。因此：

always @(posedge clk) begin
  b <= a;   // RHS：取本拍开始时的 a，安排 b 的更新
  c <= b;   // RHS：取本拍开始时的 b（旧值！），安排 c 的更新
end
// 更新区：b、c 同时变成各自 RHS 记录的值 → 真实两级移位寄存器

这精确模拟了硬件：时钟沿到来前，各门输入已稳定；沿上所有触发器同时翻转，没有谁"先翻"。用 = 会在活动区立刻改 b，第二条语句读到新 b，于是仿真把两级寄存器缩成一级——仿真波形与综合网表行为分叉，是最难查的那类 bug。

由此得到几条推论（也是 lint 规则）：

1. 时序 always 内只用 <=；组合 always/assign 内只用 =。
2. 不要在一个 always 里既描述时钟沿又用 = 给中间变量算组合结果——要算组合值就拆到单独的 always @(*) 或用 assign。
3. 不要在多个 always 块里对同一个变量赋值（多驱动），时序逻辑一个寄存器只由一个块维护。
4. 用 <= 做复位与加载：if (!rst_n) q<=0; else if (en) q<=d;——同一寄存器的复位、使能、数据写都集中在一个块里，综合结果就是"带复位/使能的 DFF"。

九、自检清单：把一段 RTL 归类并排雷

拿到一段设计，按下面顺序问自己，基本能覆盖新手 90% 的问题：

1. 这段有时钟吗？ 有沿 → 时序；完全没时钟 → 组合。先分类，再选符号和模板。
2. 输出在所有输入组合下都有值吗？ 组合块逐分支检查：if 有没有配对 else、case 有没有 default、多输出是不是每个都被默认赋值。没有 → latch 警告。
3. 敏感列表完整吗？ 用 always @(*) 让工具自动补全，永远不要手写 @(a or b)（漏一个就会仿真/综合不一致）。
4. 赋值符号对吗？ 沿块找 <=、组合块找 =，全块统一。
5. 有没有组合环路？ 某信号不经寄存器又反馈回自己（assign x = en ? x : y 且无时钟）会形成振荡的环，综合报 combinational loop，必须打断（加寄存器或改逻辑）。
6. 复位是同步还是异步、是否同步释放？ 沿块敏感列表里有没有 negedge rst_n 要与设计意图一致（见 复位设计）。

十、和语言/软件思维的差别（给有编程背景的读者）

• 软件的 = 是"此刻改变变量"，硬件的 <= 是"下个沿改变硬件状态"；always @(posedge clk) 块不是"每个沿执行一次的函数"，而是描述一块一直存在的硬件，块内代码是这块硬件在沿上的行为规则。
• if/case 不产生分支跳转，而是综合成门和 MUX；同一段 case 综合后是恒定存在的电路，不是被"选中才执行"。
• 改变一个寄存器位宽、漏一个 default，不会报错也能跑仿真，却改变了硬件面积/时序甚至行为——硬件没有"运行时异常"兜底，错误会变成硅片上永久的逻辑，所以靠的是纪律（模板、lint、评审、覆盖率），这与 仿真是什么、验证与测试 的方法论一脉相承。

十一、SystemVerilog 下的现代写法：always_comb / always_ff / always_latch

语言后来用 SystemVerilog 把"这块到底是组合还是时序"从注释变成了编译器可检查的承诺，强烈建议在支持 SV 的项目里使用：

// 组合逻辑：always_comb 自动补全敏感列表，且强制检查"所有分支都赋值"，
// 一旦推断出 latch，仿真直接报错（而不是默默生成）
always_comb begin
  y = '0;                 // 默认值
  unique case (sel)       // unique：分支互斥且必须覆盖，违例仿真报警
    2'd0: y = a;
    2'd1: y = b;
    default: y = '0;
  endcase
end

// 时序逻辑：always_ff 明确只能有时钟沿行为，块内规范用 <=
always_ff @(posedge clk or negedge rst_n) begin
  if (!rst_n) q <= '0;
  else        q <= d;
end

三个关键字的价值在"让错误写法过不了编译/仿真"：

• always_comb 内部若存在某路径未赋值，工具按 latch 处理并告警，把老 Verilog 里"inferred latch 只在综合 warning 里能看到"提前到更早的阶段；它还保证仿真在零时刻自动求值一次，避免 x 初态。
• always_ff 里若误用阻塞赋值、或写了非沿触发的敏感条件，lint 会报——把"=/<= 用错"这类最隐蔽的 bug 变成语法级警告。
• always_latch 专门留给有意的锁存器，等于在代码里显式声明"这里就是要 latch"，review 时一眼可辨，和"不小心长出来"的区分开。
• unique case / priority case 把"分支互斥（→并行 MUX）"和"有优先级（→级联 MUX）"的意图写明，综合器据此优化、仿真器据此检查重叠/遗漏分支。

老 Verilog 项目仍要用 always @(*) + 纪律，但理解 SV 这三个关键字背后的意图，能让你在两种代码里都写出正确的东西。

十二、一个完整例子：从波形 bug 反推模板

看一个把本篇知识点全串起来的真实排错故事。某模块代码大意如下，上板后发现计数器偶尔"跳一拍"：

// ❌ 问题代码（已简化）
always @(posedge clk) begin
  if (en) begin
    a = calc(x);      // 误用阻塞 =
    b = a;            // 仿真里 b 立刻拿到新 a，两级打拍被压成一级
  end
end

排查过程：①波形里 b 和 a 同拍变化，而设计本意是 a 先打一拍、b 再打一拍（典型的两级同步/流水线寄存器）；②对照「沿块用 <=」的规则，发现两处都写成了 =，导致 RHS 顺序求值；③改成 a <= calc(x); b <= a; 后，b 取到的是本拍开始时的旧 a，硬件恢复成两级寄存器；④回归时再确认 calc(x) 本身是组合逻辑（独立 always_comb、全分支赋值、无 latch）。这个例子同时用到了：区分组合/时序、=/<=、寄存器打拍、沿上采样旧值——全是本篇的模板。硬件 bug 的特点是"能综合、能下载、只是行为微妙地错"，所以这些"笨纪律"才值钱。

十三、复位设计：同步、异步与"异步断言同步释放"

复位是时序设计里仅次于时钟的第二条全局网络，细节很多，这里建立最小够用的认知。复位要回答三个问题：什么时候生效、怎么传遍全芯片、什么时候撤销。

同步复位（复位只出现在沿块条件里、不进敏感列表）的好处是干净：没有复位毛刺风险、不需要特殊时序、综合出的只是 D 端前的 MUX；代价是复位必须有时钟才能生效——上电时 PLL 还没锁定、时钟不存在，寄存器就清不掉；另外复位 MUX 占在数据路径上，会略微吃时序。异步复位（敏感列表里有 negedge rst_n）立刻生效、不依赖时钟、不占数据路径，但有两个著名的坑：一是复位网络上的毛刺可能随时清寄存器（所以复位树本身要无毛刺，一般走专用复位缓冲）；二更危险——复位撤销（release）时刻若正好落在时钟沿的建立/保持窗内，一部分触发器这一沿看到复位还在、另一部分看到已撤销，结果同一次释放把芯片清成了不一致状态，而且可能有触发器进入亚稳态。

标准折中方案叫异步断言、同步释放（async assert, sync deassert）：复位信号直接异步接到各单元的复位脚保证"一按就清"，但撤销时让它先经过一个小小的复位同步器（两个触发器在本地时钟下打两拍后再分发），保证复位释放沿与时钟沿对齐、且给所有触发器留出恢复时间。再配合"等 PLL lock → 释放复位 → 开始工作"的上电序列，复位问题就基本闭环（完整做法见 复位设计）。

对 RTL 编码的直接含义：一个项目里要统一复位风格（全部同步或全部异步断言同步释放），敏感列表、复位极性、复位值保持一致；只复位真正需要已知态的寄存器（控制状态机、指针、有效位），数据流水线寄存器可以不复位以省面积和布线——但这个取舍要全组一致。

十四、跨时钟域：当两套节奏的逻辑要对话

本篇的所有纪律都建立在"全芯片一个时钟"上。真实系统里常有多个时钟：CPU 总线 200 MHz、音频接口 12 MHz、SerDes 几百 MHz，彼此频率不同、相位无关。A 时钟域的信号直接进 B 时钟域的触发器，就相当于在"随机时刻"采样，违反建立保持几乎是必然——这就是跨时钟域（CDC）问题。最小知识集：

• 单 bit 控制信号：用两级（必要时三级）触发器同步器。第一级可能亚稳，但给它一整个周期去收敛，第二级采到合法值的概率极高。代价是延迟两拍、且事件脉冲可能因太窄而被漏掉——所以跨域的应是电平而不是单拍脉冲，经典做法是"toggle 握手"：发送方翻转一个请求电平，接收方同步、边沿检测、处理完再回翻应答，发送方据此清请求。
• 多 bit 数据：两级同步器绝对不能逐位用，因为各位延迟不一，接收方可能采到新旧值的拼装组合。三条正路：①握手（请求-应答，一次传一批，慢但简单）；②异步 FIFO（双口 RAM 加跨域的读写指针，指针用格雷码保证每次只翻一位，见 异步 FIFO）；③DMUX/双跳方案（只在特定约束下使用）。
• 复位跨域同样要同步处理，慢时钟域对快复位脉冲可能完全无感。

CDC 在仿真里几乎测不出来（零延迟模型下信号总是"恰好稳定"），所以它靠专门的 CDC 静态检查工具（SpyGlass/Meridian 等）在结构上扫描：每一处跨域连接都必须被工具识别为"已采用认可的同步结构"，否则报 violation。对初学者最重要的一条直觉是：跨时钟域不是"加两级触发器"的口头禅，而是按信号类型（单 bit/多 bit/脉冲/电平/复位）选择结构，并让检查工具能认出它。

十五、四个高频面试题的标准答法

把本篇知识压缩成面试中最常出现的四个问题，答案都能在前面章节找到依据，这里给出组织语言的骨架。

一问：阻塞和非阻塞赋值的区别，为什么时序逻辑必须用非阻塞？ 要点是"调度语义模拟硬件并行"：非阻塞在时间步开始时统一计算 RHS、结束时统一更新 LHS，所有触发器读到的都是沿前旧值，正好对应硬件同一沿并发翻转；阻塞立即生效，在沿块里会让后一条语句读到前一条的新值，综合出的寄存器顺序依赖书写次序，仿真和综合可能不一致。给结论：组合 always @(*)/assign 用 =，时序 always @(posedge clk) 用 <=，二者不混在同一块。

二问：什么情况会综合出锁存器，为什么要避免？ 组合逻辑中某输出在某输入路径下未被赋值（if 无 else、case 无 default、敏感列表不全），工具只能为它保持旧值，于是推断电平敏感锁存器；它透明期透传毛刺、时序分析复杂、与统一沿触发的同步方法学不兼容。避免靠"组合块开头给所有输出默认值 + 分支写全"。有意的锁存器（时间借用、ICG 内）要用 always_latch 显式表达。

三问：亚稳态是什么，怎么处理，能彻底消除吗？ 建立保持窗内采样变化中的数据，交叉耦合节点可能长时间停在中间电平、收敛时刻随机；单时钟同步系统满足时序就不会发生，问题来自异步输入和跨时钟域；用两级或多级同步器给决断时间，按 MTBF 公式选型，不能消除只能把概率降到寿命尺度以下。多 bit 不能逐位同步，要用握手、格雷码或异步 FIFO。

四问：给定一段代码，判断它综合成组合还是时序、有没有 latch、关键路径在哪。 这是综合题，方法是看有没有沿触发（有时序寄存器）、看每个输出是否在所有分支赋值（查 latch）、再沿"寄存器输出→组合云→下一寄存器输入"找最长组合链。能把这道流程讲清楚，比背定义更能证明你真的理解了组合与时序的分界。

十六、这一篇在知识体系里的位置

• 想回看一段代码综合出什么门 → 从代码到门电路；
• 想理解触发器为什么沿触发、复位怎么接 → 时钟与复位；
• 想知道 latch/时序为什么影响时序收敛 → 时序为什么不满足、静态时序分析入门；
• 想要系统可综合风格与可综合性规则 → RTL 设计入门、FPGA 线的 组合与时序逻辑实践。

总结

一句话总结：数字电路只有组合逻辑（输出仅由当前输入决定、无记忆、无时钟，用 assign/always @(*) 写）和时序逻辑（含触发器、记住状态、在时钟沿更新，用 always @(posedge clk) 写）两类；写组合逻辑必须让输出在所有输入分支下都被赋值，否则漏写 else/缺 default 会让工具综合出电平敏感的隐式锁存器，它时序难分析、易透传毛刺，是同步设计里要极力消除的事故；赋值符号上，时序逻辑统一用非阻塞 <=（模拟所有触发器同沿并行更新）、组合逻辑统一用阻塞 =（立即顺序生效），混用会造成仿真与综合不一致——记住「组合 @(*)+=+先给默认值、时序 @(posedge clk)+<=+复位」两张模板，即可避开绝大多数入门坑。