Synthesis of Combinational Logic組合邏輯的合成組合せ論理の合成

1. Logic Synthesis in the Design Flow1. 設計流程中的邏輯合成1. 設計フローにおける論理合成

1.1 HDL-based design flow1.1 以 HDL 為主的設計流程1.1 HDL ベースの設計フロー

The designer writes an HDL behavioral model (design entry) and checks it with functional simulation. Physical optimization and implementation then map it to a target technology, after which timing simulation verifies the implemented design against the original intent.設計者先寫出 HDL 行為模型（design entry），再以功能模擬檢查。接著由實體最佳化與實作把它映射到目標製程，最後以時序模擬驗證實作結果是否仍符合原始設計意圖。設計者はまず HDL の動作モデル（design entry）を書き、機能シミュレーションで確認する。続いて物理最適化と実装がそれをターゲット・テクノロジへマッピングし、最後にタイミング・シミュレーションで実装結果が当初の意図どおりかを検証する。

1.2 Simulation-based verification1.2 以模擬為基礎的驗證1.2 シミュレーションによる検証

One test bench drives both the Verilog behavioral description and the gate-level description produced by synthesis. A stimulus generator feeds both, a response comparator compares their outputs, and a check signal flags mismatches. This is the post-synthesis check that the netlist behaves like the RTL.同一個測試平台（test bench）同時驅動 Verilog 行為描述與合成產生的閘層描述。激勵產生器把相同輸入餵給兩者，響應比較器比對兩邊的輸出，check 訊號則標示出不一致之處。這就是合成後用來確認 netlist 行為與 RTL 相同的檢查。一つのテストベンチが、Verilog の動作記述と合成で生成されたゲートレベル記述の両方を駆動する。刺激生成器が同じ入力を両者に与え、応答比較器が出力を突き合わせ、check 信号が不一致を知らせる。これが、ネットリストが RTL と同じ振る舞いをするかを確かめる合成後のチェックである。

1.3 What logic synthesis does1.3 邏輯合成做了什麼1.3 論理合成は何をするか

Logic synthesis operates on Boolean equations and produces optimized combinational logic, in three stages:邏輯合成以布林方程式為操作對象，分三個階段產生最佳化後的組合邏輯：論理合成はブール式を対象に動作し、三つの段階を経て最適化された組合せ論理を生成する。

2. Synthesizable and Un-synthesizable Constructs2. 可合成與不可合成的語法2. 合成可能な構文と合成不可能な構文

2.1 Commonly supported (synthesizable)2.1 一般都支援（可合成）2.1 一般にサポートされる（合成可能）

* No timing or event control allowed inside a synthesizable task.* 可合成的 task 內不得出現時序控制或事件控制。* 合成可能な task の中では時間制御・イベント制御は使えない。

2.2 Not generally supported (un-synthesizable)2.2 一般不支援（不可合成）2.2 一般にサポートされない（合成不可）

3. Logic Minimization3. 邏輯最小化3. 論理最小化

3.1 Two-level vs multi-level3.1 兩層 vs 多層3.1 2 段 vs 多段

Synthesis target: minimize area, delay or power.合成的目標：最小化面積、延遲或功耗。合成の目標は面積・遅延・電力の最小化である。

• Two-level minimization: sum-of-products (SOP), e.g. K-map / Quine-McCluskey / Espresso.兩層最小化：積之和（sum-of-products, SOP），例如卡諾圖 / Quine-McCluskey / Espresso。2 段最小化：積和形（SOP）。カルノー図 / Quine-McCluskey / Espresso など。
• Multi-level minimization: decomposition, extraction, factoring, substitution, elimination. Fewer literals usually means less area, at the cost of more logic levels (delay).多層最小化：分解、抽取、因式分解、代換、消去。literal 數變少通常代表面積變小，代價是邏輯層數（延遲）增加。多段最小化：分解・抽出・因数分解・置換・消去。リテラル数が減れば通常は面積も減るが、論理段数（遅延）は増える。

3.2 The five multi-level operations3.2 五種多層最小化運算3.2 多段最小化の 5 つの操作

4. Synthesizable Descriptions of Combinational Logic4. 組合邏輯的可合成描述方式4. 組合せ論理の合成可能な記述

The following map successfully to circuits: a netlist of Verilog primitives, combinational UDPs, continuous assignments, behavioral always blocks, functions, tasks without delay or event control, and interconnected modules of these. All of §4.1 – §4.6 describe the same function and synthesize to the same two cells.以下幾種寫法都能順利映射成電路：Verilog 基本元件組成的 netlist、組合邏輯 UDP、連續指定、行為式 always 區塊、function、不含延遲或事件控制的 task，以及由這些互連而成的模組。§4.1 – §4.6 描述的其實是同一個函數，也合成出同樣的兩顆 cell。次のものはいずれも回路へ問題なくマッピングされる。Verilog プリミティブのネットリスト、組合せ UDP、連続代入、動作レベルの always ブロック、function、遅延やイベント制御を含まない task、そしてそれらを相互接続したモジュールである。§4.1 – §4.6 はすべて同じ関数を記述しており、合成結果も同じ 2 つのセルになる。

4.1 Netlist of primitives4.1 基本元件組成的 netlist4.1 プリミティブのネットリスト

module or_nand_1 (enable, x1, x2, x3, x4, y);
  input  enable, x1, x2, x3, x4;
  output y;
  wire   w1, w2, w3;
  or   (w1, x1, x2);
  or   (w2, x3, x4);
  or   (w3, x3, x4);              // redundant
  nand (y, w1, w2, w3, enable);
endmodule

Synthesis removes the redundant w3 gate and maps the rest to one oai22 (OR-AND-invert) cell followed by a nand2 with enable.合成會移除多餘的 w3 閘，其餘映射成一顆 oai22（OR-AND-invert）cell，後面再接一個吃 enable 的 nand2。合成は冗長な w3 のゲートを取り除き、残りを oai22（OR-AND-invert）セル 1 個と、enable を受ける nand2 にマッピングする。

4.2 Combinational UDP4.2 組合邏輯 UDP4.2 組合せ UDP

primitive boolean_eqs (y, a, b, c);
  output y;
  input  a, b, c;
  table
  //  a b c : y
      0 1 ? : 1;
      0 0 ? : 0;
      1 ? 1 : 1;
      1 ? 0 : 0;
  endtable
endprimitive

Reading the table: $a = 0 \Rightarrow y = b$, $a = 1 \Rightarrow y = c$, i.e. $y = a'b + ac$ — a 2:1 mux, synthesized as two ANDs and an OR.讀這張表：$a = 0 \Rightarrow y = b$、$a = 1 \Rightarrow y = c$，也就是 $y = a'b + ac$ — 一個 2:1 多工器，合成成兩個 AND 加一個 OR。表を読むと $a = 0 \Rightarrow y = b$、$a = 1 \Rightarrow y = c$、すなわち $y = a'b + ac$ である — 2:1 マルチプレクサであり、AND 2 個と OR 1 個に合成される。

4.3 Continuous assignment4.3 連續指定4.3 連続代入

module or_nand_2 (enable, x1, x2, x3, x4, y);
  input  enable, x1, x2, x3, x4;
  output y;
  assign y = ~(enable & (x1 | x2) & (x3 | x4));
endmodule

4.4 Rules for a combinational always block4.4 組合邏輯 always 區塊的規則4.4 組合せ always ブロックの規則

4.5 always block examples4.5 always 區塊範例4.5 always ブロックの例

Example 1 — or_nand_3範例 1 — or_nand_3例 1 — or_nand_3

module or_nand_3 (enable, x1, x2, x3, x4, y);
  input  enable, x1, x2, x3, x4;
  output y;
  reg    y;

  always @ (enable or x1 or x2 or x3 or x4)
    begin
      y = ~(enable & (x1 | x2) & (x3 | x4));
    end
endmodule

Same oai22 + nand2 circuit as §4.1.與 §4.1 相同的 oai22 + nand2 電路。§4.1 と同じ oai22 + nand2 の回路になる。

Example 2 — 4-input AND with a loop and disable範例 2 — 用迴圈與 disable 寫的 4 輸入 AND例 2 — ループと disable による 4 入力 AND

module and4_behav (y, x_in);
  parameter word_length = 4;
  input  [word_length - 1:0] x_in;
  output y;
  reg    y;
  integer k;

  always @ x_in
    begin: check_for_0
      y = 1;
      for (k = 0; k <= word_length - 1; k = k + 1)
        if (x_in[k] == 0)
          begin
            y = 0;
            disable check_for_0;      // early exit
          end
    end
endmodule

The loop has a constant bound so it unrolls; the disable only shortens simulation. Result: a single 4-input AND gate.迴圈的界限是常數，所以會被展開；disable 只是縮短模擬時間。結果就是一個 4 輸入的 AND 閘。ループの上限は定数なので展開される。disable はシミュレーションを短くするだけである。結果は 4 入力 AND ゲート 1 個になる。

Example 3 — comparator (alternative algorithm)範例 3 — 比較器（另一種演算法）例 3 — 比較器（別のアルゴリズム）

module comparator (a, b, a_gt_b, a_lt_b, a_eq_b);
  parameter size = 2;
  input  [size:1] a, b;
  output a_gt_b, a_lt_b, a_eq_b;
  reg    a_gt_b, a_lt_b, a_eq_b;
  integer k;

  always @ (a or b)
    begin: compare_loop
      for (k = size; k > 0; k = k - 1)     // MSB first
        begin
          if (a[k] != b[k])
            begin
              a_gt_b = a[k];
              a_lt_b = ~a[k];
              a_eq_b = 0;
              disable compare_loop;
            end  // if
        end      // for loop
      a_gt_b = 0;
      a_lt_b = 0;
      a_eq_b = 1;
    end          // compare_loop
endmodule

Scanning from the MSB, the first differing bit decides: if a[k] = 1 then $a > b$. Synthesis builds XOR/XNOR bit comparators, an equality AND, and muxes that select the decision bit by priority.由 MSB 往下掃，第一個不相同的位元就決定結果：若 a[k] = 1 則 $a > b$。合成會產生逐位元的 XOR/XNOR 比較器、一個做相等判斷的 AND，以及依優先權挑出決定位元的多工器。MSB から順に見ていき、最初に異なるビットで結果が決まる。a[k] = 1 なら $a > b$ である。合成はビットごとの XOR/XNOR 比較器、一致判定の AND、そして優先順位で決定ビットを選ぶマルチプレクサを生成する。

4.6 Function and task4.6 function 與 task4.6 function と task

• Function: no incomplete case statements or conditionals.function：不可出現不完整的 case 或條件判斷。function：不完全な case 文や条件分岐を書いてはならない。
• Task: the same restrictions as functions, plus no timing control constructs.task：與 function 相同的限制，另外還不可有時序控制語法。task：function と同じ制限に加えて、時間制御の構文も使えない。

module or_nand_4 (enable, x1, x2, x3, x4, y);
  input  enable, x1, x2, x3, x4;
  output y;

  assign y = or_nand(enable, x1, x2, x3, x4);

  function or_nand;
    input enable, x1, x2, x3, x4;
    begin
      or_nand = ~(enable & (x1 | x2)
                         & (x3 | x4));
    end
  endfunction
endmodule

module or_nand_5 (enable, x1, x2, x3, x4, y);
  input  enable, x1, x2, x3, x4;
  output y;
  reg    y;

  always @ (enable or x1 or x2 or x3 or x4)
    or_nand(enable, x1, x2, x3, x4, y);

  task or_nand;
    input  enable, x1, x2, x3, x4;
    output y;
    begin
      y = !(enable & (x1 | x2) & (x3 | x4));
    end
  endtask
endmodule

Both synthesize to the oai22 + nand2 pair. The task uses logical ! instead of bitwise ~; for a 1-bit operand they are the same, for vectors they are not.兩者都合成成 oai22 + nand2 這一對。task 版用的是邏輯 ! 而不是位元 ~；對 1 位元運算元兩者相同，對向量則不同。どちらも oai22 + nand2 の組に合成される。task 版はビット単位の ~ ではなく論理否定の ! を使っている。1 ビットのオペランドなら同じだが、ベクタでは異なる。

4.7 Constructs to be avoided4.7 應避免的語法4.7 避けるべき構文

5. Control Logic for Multiplexed Datapaths5. 多工資料路徑的控制邏輯5. マルチプレクス・データパスの制御論理

5.1 A 4-channel, 4-bit mux three ways5.1 四通道 4 位元多工器的三種寫法5.1 4 チャネル 4 ビット・マルチプレクサの三通りの書き方

module syn1_mux_4bits (y, sel, a, b, c, d);
  input  [3:0] a, b, c, d;
  input  [1:0] sel;
  output [3:0] y;

  assign y = (sel == 0) ? a :
             (sel == 1) ? b :
             (sel == 2) ? c :
             (sel == 3) ? d : 4'bx;
endmodule

module syn2_mux_4bits (y, sel, a, b, c, d);
  input  [3:0] a, b, c, d;
  input  [1:0] sel;
  output [3:0] y;
  reg    [3:0] y;

  always @ (sel or a or b or c or d)
    case (sel)
      0: y = a;
      1: y = b;
      2: y = c;
      3: y = d;
      default: y = 4'bx;
    endcase
endmodule

module syn3_mux_4bits (y, sel, a, b, c, d);
  input  [3:0] a, b, c, d;
  input  [1:0] sel;
  output [3:0] y;
  reg    [3:0] y;

  always @ (sel or a or b or c or d)
    if      (sel == 0) y = a;
    else if (sel == 1) y = b;
    else if (sel == 2) y = c;
    else if (sel == 3) y = d;
    else               y = 4'bx;
endmodule

All three are "simulation and synthesis friendly". Because the sel values are mutually exclusive, the if chain synthesizes to the same mux as the case version — no priority logic. The 4'bx default lets the tool treat the impossible branch as a don't care.三種寫法都屬於「模擬與合成都友善」。由於 sel 的各個值互斥，if 串接合成出來的多工器與 case 版完全相同，不會多出優先邏輯。4'bx 的 default 則讓工具把不可能發生的分支當成 don't care。三つとも「シミュレーションにも合成にも適した」書き方である。sel の各値は互いに排他なので、if チェーンも case 版と同じマルチプレクサに合成され、優先順位論理は生じない。4'bx の default は、起こりえない分岐をドントケアとして扱わせる。

5.2 The "simulation efficient" style5.2「模擬有效率」的寫法5.2「シミュレーション効率型」の記述

always @ (sel)            // only sel
  case (sel)
    0: assign y = a;      // procedural continuous assignment
    1: assign y = b;
    2: assign y = c;
    3: assign y = d;
    default: assign y = 4'bx;
  endcase

Using assign (PCA) inside the block lets y follow a–d continuously while the block wakes only on sel, so it simulates fast. The synthesis result is the same mux, but PCA support varies by tool, so the full-sensitivity version is preferred.在區塊內用 assign（PCA），y 會持續跟著 a–d 變動，而區塊本身只在 sel 改變時被喚醒，所以模擬很快。合成結果是同一個多工器，但各家工具對 PCA 的支援不一，因此還是建議用完整敏感列表的版本。ブロック内で assign（PCA）を使うと、ブロックは sel でしか起動しないのに y は a–d に追従し続けるため、シミュレーションが速い。合成結果は同じマルチプレクサだが、PCA のサポートはツールによって差があるので、感度リストを完全に書いた版のほうが望ましい。

6. Unwanted Latches6. 非預期的閂鎖6. 意図しないラッチ

6.1 Incompletely specified case / if6.1 未完整指定的 case / if6.1 不完全に指定された case / if

A case or if that does not cover all possible values is incompletely specified. On the uncovered paths the register must keep its old value, so synthesis inserts a latch. Avoid it.沒有涵蓋所有可能值的 case 或 if 就是未完整指定。在沒涵蓋到的路徑上，變數必須保持舊值，於是合成工具會插入一個閂鎖。請避免。取りうる値をすべて網羅していない case や if は不完全指定である。網羅されていない経路では変数が古い値を保持しなければならないので、合成はそこにラッチを挿入する。避けること。

module mux_latch (y_out, sel_a, sel_b, data_a, data_b);
  input  sel_a, sel_b, data_a, data_b;
  output y_out;
  reg    y_out;

  always @ (sel_a or sel_b or data_a or data_b)
    case ({sel_a, sel_b})
      2'b10: y_out = data_a;
      2'b01: y_out = data_b;     // incomplete case list!!
    endcase
endmodule

6.2 Bad and good ALU examples6.2 ALU 的壞例與好例6.2 ALU の悪い例と良い例

module alu_incomplete1a (alu_out, data_a,
                    data_b, enable, opcode);
  input  [2:0] opcode;
  input  [3:0] data_a, data_b;
  input        enable;
  output       alu_out;      // scalar
  reg    [3:0] alu_reg;

  assign alu_out = (enable == 1) ? alu_reg : 4'b0;

  always @ (opcode)
    case (opcode)
      3'b001: alu_reg = data_a | data_b;
      3'b010: alu_reg = data_a ^ data_b;
      3'b110: alu_reg = ~data_b;
    endcase
endmodule

module alu_incomplete2a (alu_out, data_a,
                    data_b, enable, opcode);
  ...
  assign alu_out = (enable == 1) ? alu_reg : 4'b0;

  always @ (opcode or data_a or data_b)
    case (opcode)
      3'b001: alu_reg = data_a | data_b;
      3'b010: alu_reg = data_a ^ data_b;
      3'b110: alu_reg = ~data_b;
    endcase
endmodule

Both synthesize a latch (latrnb) between the opcode-selected datapath and alu_out: for the five opcodes not listed, alu_reg must hold its value. Fixing the sensitivity list alone does not remove it.兩者都會在由 opcode 選出的資料路徑與 alu_out 之間合成出一個閂鎖（latrnb）：對於沒列出的那五個 opcode，alu_reg 必須保持原值。只修敏感列表並不能把它消掉。どちらも、opcode で選ばれたデータパスと alu_out の間にラッチ（latrnb）を合成してしまう。列挙されていない 5 つの opcode では alu_reg が値を保持しなければならないからである。感度リストだけを直してもラッチは消えない。

module alu_complete (alu_out, data_a, data_b, enable, opcode);
  ...
  always @ (opcode or data_a or data_b)
    case (opcode)
      3'b001:  alu_reg = data_a | data_b;
      3'b010:  alu_reg = data_a ^ data_b;
      3'b110:  alu_reg = ~data_b;
      default: alu_reg = 4'b0;      // makes the case list complete
    endcase
endmodule

With default the result is pure gates plus a mux — no latch.加上 default 之後，結果只剩純邏輯閘加一個多工器 — 沒有閂鎖。default を加えれば、結果は純粋なゲートとマルチプレクサだけになり、ラッチは生じない。

6.3 Bad example using if6.3 用 if 寫出的壞例6.3 if を使った悪い例

module incomplete_and (y, a1, a2);
  input  a1, a2;
  output y;
  reg    y;

  always @ (a1 or a2)
    begin
      if      ({a2, a1} == 2'b11) y = 1;
      else if ({a2, a1} == 2'b01) y = 0;
      else if ({a2, a1} == 2'b10) y = 0;   // the last statement should be "else"
    end
endmodule

The case {a2, a1} = 00 is missing, so the tool builds inverters, a NOR/NAND enable and a latch (latrnb). Ending with a plain else y = 0; gives one AND gate.少了 {a2, a1} = 00 這個情況，工具就造出反相器、一組 NOR/NAND 致能邏輯與一個閂鎖（latrnb）。只要最後改成單純的 else y = 0;，就只剩一個 AND 閘。{a2, a1} = 00 の場合が抜けているため、ツールはインバータ、NOR/NAND のイネーブル論理、そしてラッチ（latrnb）を作ってしまう。最後を単純な else y = 0; にすれば AND ゲート 1 個で済む。

// (a)
always @ (a or b or s) if (s) y = a; else y = b;
// (b)
always @ (en or d) if (en) q = d;
// (c)
always @ (s or a or b) begin y = b; if (s) y = a; end
// (d)
always @ (op or a or b)
  case (op) 2'b00: y = a; 2'b01: y = b; 2'b10: y = a & b; endcase
// (e)  op is 2 bits
always @ (op or a or b)
  case (op) 2'b00: y = a; 2'b01: y = b; 2'b10: y = a & b; 2'b11: y = a | b; endcase

7. Combinational Loops (Mux with Feedback)7. 組合邏輯迴路（含回授的多工器）7. 組合せループ（帰還つきマルチプレクサ）

7.1 Completed case / if with feedback7.1 用回授「補完」的 case / if7.1 帰還で「完全」にした case / if

A case or if that is "completed" by assigning the variable to itself in a level-sensitive behavior synthesizes to a mux whose output feeds back to its input. This combinational loop cannot be mapped to proper gates — avoid it.在位準敏感的行為區塊裡，用把變數指定給自己的方式來「補完」case 或 if，合成出來會是一個輸出回授到自己輸入的多工器。這種組合邏輯迴路無法對應成正常的邏輯閘 — 請避免。レベル検出の記述の中で、変数に自分自身を代入して case や if を「完全」にすると、出力が自分の入力へ戻るマルチプレクサに合成される。この組合せループはまともなゲートにマッピングできない — 避けること。

module latch_case1 (latch_out, latch_in,
                    set, clear, enable);
  input  latch_in, set, clear, enable;
  output latch_out;
  reg    latch_out;

  always @ (enable or set or clear or latch_in)
    case ({enable, set, clear})
      3'b000: latch_out = latch_in; // transparent
      3'b110: latch_out = 1'b1;     // set
      3'b010: latch_out = 1'b1;     // set
      3'b101: latch_out = 1'b0;     // clear
      3'b001: latch_out = 1'b0;     // clear
      default: latch_out = latch_out; // holds value
    endcase
endmodule

module latch_if1 (data_out, data_in,
                  latch_enable);
  input  [3:0] data_in;
  output [3:0] data_out;
  input        latch_enable;
  reg    [3:0] data_out;

  always @ (latch_enable or data_in)
    if (latch_enable) data_out = data_in;
    else data_out = data_out;
endmodule

// (a) intentional latch: no else, no self-assignment
always @ (latch_enable or data_in)
  if (latch_enable) data_out = data_in;

// (b) combinational: every path gets a new value
always @ (latch_enable or data_in)
  if (latch_enable) data_out = data_in;
  else              data_out = 4'b0;

8. Priority Structures, Encoders and Decoders8. 優先權結構、編碼器與解碼器8. 優先順位構造、エンコーダとデコーダ

8.1 Mux vs priority chain8.1 多工器 vs 優先鏈8.1 マルチプレクサ vs 優先順位チェーン

• If the case items are mutually exclusive, synthesis treats them as having equal priority and builds a mux.若 case 的各項互斥，合成會把它們視為同等優先，造出一個多工器。case の各項目が互いに排他なら、合成はそれらを同等の優先度とみなしマルチプレクサを作る。
• An if statement also synthesizes to a mux when its branch conditions are mutually exclusive.if 敘述只要分支條件互斥，同樣會合成成多工器。if 文も、分岐条件が互いに排他であれば同じくマルチプレクサに合成される。
• A priority structure appears only when the conditions are not mutually exclusive.只有在條件不互斥時，才會出現優先權結構。条件が互いに排他でないときにだけ優先順位構造が現れる。

module mux_4pri (y, a, b, c, d, sel_a, sel_b, sel_c);
  input  a, b, c, d, sel_a, sel_b, sel_c;
  output y;
  reg    y;

  always @ (sel_a or sel_b or sel_c or a or b or c or d)
    begin                       // not mutually exclusive
      if      (sel_a == 1) y = a;
      else if (sel_b == 0) y = b;
      else if (sel_c == 1) y = c;
      else                 y = d;
    end
endmodule

8.2 8:3 encoder (without priority)8.2 8:3 編碼器（無優先權）8.2 8:3 エンコーダ（優先順位なし）

module encoder (Data, Code);
  input  [7:0] Data;
  output [2:0] Code;
  reg    [2:0] Code;

  always @ (Data)
    begin
      if      (Data == 8'b00000001) Code = 0;
      else if (Data == 8'b00000010) Code = 1;
      else if (Data == 8'b00000100) Code = 2;
      else if (Data == 8'b00001000) Code = 3;
      else if (Data == 8'b00010000) Code = 4;
      else if (Data == 8'b00100000) Code = 5;
      else if (Data == 8'b01000000) Code = 6;
      else if (Data == 8'b10000000) Code = 7;
      else                          Code = 3'bx;
    end
endmodule

module encoder (Data, Code);
  input  [7:0] Data;
  output [2:0] Code;
  reg    [2:0] Code;

  always @ (Data)
    case (Data)
      8'b00000001 : Code = 0;
      8'b00000010 : Code = 1;
      8'b00000100 : Code = 2;
      8'b00001000 : Code = 3;
      8'b00010000 : Code = 4;
      8'b00100000 : Code = 5;
      8'b01000000 : Code = 6;
      8'b10000000 : Code = 7;
      default     : Code = 3'bx;
    endcase
endmodule

The one-hot patterns are mutually exclusive and the default is a don't care, so the tool reduces each output bit to a 4-input OR:one-hot 的樣式彼此互斥，default 又是 don't care，所以工具把每個輸出位元化簡成一個 4 輸入 OR：ワンホットのパターンは互いに排他で、default はドントケアなので、ツールは各出力ビットを 4 入力 OR に簡単化する。

8.3 8:3 priority encoder8.3 8:3 優先編碼器8.3 8:3 プライオリティエンコーダ

module priority (Data, Code, valid_data);
  input  [7:0] Data;
  output [2:0] Code;
  output       valid_data;
  reg    [2:0] Code;

  assign valid_data = |Data;   // reduction or

  always @ (Data)
    begin
      if      (Data[7]) Code = 7;
      else if (Data[6]) Code = 6;
      else if (Data[5]) Code = 5;
      else if (Data[4]) Code = 4;
      else if (Data[3]) Code = 3;
      else if (Data[2]) Code = 2;
      else if (Data[1]) Code = 1;
      else if (Data[0]) Code = 0;
      else              Code = 3'bx;
    end
endmodule

module priority (Data, Code, valid_data);
  ...
  assign valid_data = |Data;

  always @ (Data)
    casex (Data)
      8'b1xxxxxxx : Code = 7;
      8'b01xxxxxx : Code = 6;
      8'b001xxxxx : Code = 5;
      8'b0001xxxx : Code = 4;
      8'b00001xxx : Code = 3;
      8'b000001xx : Code = 2;
      8'b0000001x : Code = 1;
      8'b00000001 : Code = 0;
      default     : Code = 3'bx;
    endcase
endmodule

Now several bits may be 1 at once, so the conditions overlap and the highest index wins. The synthesized netlist adds inverters and AND/NOR terms that mask lower bits, e.g.現在可能同時有好幾個位元是 1，條件因此重疊，由索引最高的那個勝出。合成出的 netlist 會多出反相器與遮蔽低位元的 AND/NOR 項，例如：今度は複数のビットが同時に 1 になりうるため条件が重なり、添字の大きいほうが勝つ。合成されたネットリストには、下位ビットをマスクするインバータと AND/NOR 項が加わる。例えば次のとおり。

8.4 3:8 decoder8.4 3:8 解碼器8.4 3:8 デコーダ

module decoder (Code, Data);
  output [7:0] Data;
  input  [2:0] Code;
  reg    [7:0] Data;

  always @ (Code)
    begin
      if      (Code == 0) Data = 8'b00000001;
      else if (Code == 1) Data = 8'b00000010;
      else if (Code == 2) Data = 8'b00000100;
      else if (Code == 3) Data = 8'b00001000;
      else if (Code == 4) Data = 8'b00010000;
      else if (Code == 5) Data = 8'b00100000;
      else if (Code == 6) Data = 8'b01000000;
      else if (Code == 7) Data = 8'b10000000;
      else                Data = 8'bx;
    end
endmodule

  always @ (Code)
    case (Code)
      0 : Data = 8'b00000001;
      1 : Data = 8'b00000010;
      2 : Data = 8'b00000100;
      3 : Data = 8'b00001000;
      4 : Data = 8'b00010000;
      5 : Data = 8'b00100000;
      6 : Data = 8'b01000000;
      7 : Data = 8'b10000000;
      default: Data = 8'bx;
    endcase

9. Buses and Tri-State Buffers9. 匯流排與三態緩衝器9. バスとトライステート・バッファ

Buses transport multi-bit data; buffers store or drive data with or without control signals. Four implementation concerns: tri-state buffers, bidirectional buses, bus loading, and tri-state outputs with don't cares.匯流排負責搬運多位元資料；緩衝器則在有或沒有控制訊號的情況下儲存或驅動資料。實作上有四個重點：三態緩衝器、雙向匯流排、匯流排負載，以及帶 don't care 的三態輸出。バスは多ビットのデータを運び、バッファは制御信号の有無に応じてデータを保持または駆動する。実装上の論点は四つある。トライステート・バッファ、双方向バス、バスの負荷、そしてドントケアを伴うトライステート出力である。

9.1 Tri-state buffer9.1 三態緩衝器9.1 トライステート・バッファ

module stuff_to_bus1 (data_to_bus, bus_enabled, clk);
  input         bus_enabled, clk;
  output [31:0] data_to_bus;
  reg    [31:0] ckt_output_to_bus;

  assign data_to_bus = (bus_enabled) ? ckt_output_to_bus : 32'bz;
  // Description of core circuit goes here to drive ckt_output_to_bus
endmodule

A conditional operator whose other branch is z synthesizes to a 32-bit tri-state buffer controlled by bus_enabled.條件運算子的另一個分支給 z，就會合成成一個由 bus_enabled 控制的 32 位元三態緩衝器。条件演算子のもう一方の分岐を z にすると、bus_enabled で制御される 32 ビットのトライステート・バッファに合成される。

9.2 Bidirectional bus9.2 雙向匯流排9.2 双方向バス

module stuff_to_bus2 (data_to_from_bus, clk, send_data, rcv_data);
  input         clk, send_data, rcv_data;
  inout  [31:0] data_to_from_bus;
  reg    [31:0] reg_to_bus;
  wire   [31:0] data_to_from_bus, inbound_data;

  assign inbound_data     = (rcv_data)  ? data_to_from_bus : 32'bz;
  assign data_to_from_bus = (send_data) ? reg_to_bus       : 32'bz;
  // Behavior using inbound_data goes here
endmodule

9.3 Bus loading9.3 匯流排負載9.3 バスの負荷

module stuff_to_bus3 (data_to_from_bus, enab_a, enab_b, clk, rcv_data);
  input         enab_a, enab_b, rcv_data, clk;
  inout  [31:0] data_to_from_bus;
  reg    [31:0] reg_a_to_bus, reg_b_to_bus;

  assign data_to_from_bus = (enab_a) ? reg_a_to_bus :
                            (enab_b) ? reg_b_to_bus : 32'bz;
endmodule // not showing other logic

Rather than two tri-state drivers on the bus, one nested conditional gives a 2:1 mux (select enab_a) followed by a single tri-state driver enabled by enab_a | enab_b. Only one driver loads the bus, and contention is impossible.與其在匯流排上掛兩個三態驅動器，用一個巢狀條件式就能得到一個 2:1 多工器（以 enab_a 選擇），後面再接單一由 enab_a | enab_b 致能的三態驅動器。匯流排上只有一個驅動器，也就不可能發生競爭。バスにトライステート・ドライバを 2 個ぶら下げる代わりに、入れ子の条件式を使えば、2:1 マルチプレクサ（選択は enab_a）の後ろに enab_a | enab_b でイネーブルされる単一のトライステート・ドライバが置かれる。バスを駆動するのは 1 個だけなので、競合は起こりえない。

9.4 Tri-state outputs with don't cares9.4 帶 don't care 的三態輸出9.4 ドントケアを伴うトライステート出力

module alu_with_z1 (alu_out, data_a, data_b, enable, opcode);
  input  [2:0] opcode;
  input  [3:0] data_a, data_b;
  input        enable;
  output       alu_out;          // scalar for illustration
  reg    [3:0] alu_reg;

  assign alu_out = (enable == 1) ? alu_reg : 4'bz;

  always @ (opcode or data_a or data_b)
    case (opcode)
      3'b001:  alu_reg = data_a | data_b;
      3'b010:  alu_reg = data_a ^ data_b;
      3'b110:  alu_reg = ~data_b;
      default: alu_reg = 4'b0;   // alu_with_z2: alu_reg = 4'bx;  (don't cares)
    endcase
endmodule

assign data_to_from_bus = enab_a ? reg_a_to_bus : 32'bz;
assign data_to_from_bus = enab_b ? reg_b_to_bus : 32'bz;

10. Resource Sharing10. 資源共享10. リソース共有

Do the resource sharing before RTL coding — it is what gives hardware its low-cost property.資源共享要在寫 RTL 之前就想好 — 硬體之所以能低成本，靠的就是這件事。リソース共有はRTL を書く前に済ませておく — ハードウェアが低コストでいられるのはこれによる。

module res_share (y_out, sel, data_a, data_b, accum);
  input  [3:0] data_a, data_b, accum;
  input        sel;
  output [4:0] y_out;

  // two adders + mux
  // assign y_out = sel ? (data_a + accum) : (data_a + data_b);

  // one mux + one adder
  assign y_out = data_a + (sel ? accum : data_b);
endmodule

11. Summary and Exam Checklist11. 總結與考前檢查表11. まとめと試験前チェックリスト

always @*                 // complete sensitivity
  begin
    y = DEFAULT_VALUE;      // every path assigned
    case (sel)
      ...
      default: y = 'bx;     // complete list, don't care
    endcase
  end