Synthesis of Language Constructs語言結構的合成言語構造の合成

1. Data Types: Nets, Registers, x and z1. 資料型別：net、register、x 與 z1. データ型：ネット、レジスタ、x と z

1.1 Synthesis of net variables1.1 net 變數的合成1.1 ネット変数の合成

• Nets declared as input or output ports are retained.宣告為 input 或 output 埠的 net 會被保留。input または output ポートとして宣言されたネットは保持される。
• Internal nets may be eliminated by logic optimization.內部 net 可能在邏輯最佳化時被消去。内部ネットは論理最適化によって削除されることがある。
• The user can force a net to exist with special tool instructions (e.g. a "keep"/"dont_touch" attribute).使用者可以用工具的特殊指令強迫某條 net 留下來（例如 "keep" / "dont_touch" 屬性）。ツール固有の指示（たとえば "keep" / "dont_touch" 属性）を与えれば、ネットを強制的に残せる。
• wand and wor are implemented as AND / OR gates.wand 與 wor 會實作成 AND / OR 閘。wand と wor は AND / OR ゲートとして実装される。

1.2 Synthesis of register variables1.2 register 變數的合成1.2 レジスタ変数の合成

• integer: 32-bit register by default; the size may be reduced during optimization.integer：預設是 32 位元的 register；最佳化時位元寬可能被縮減。integer：既定では 32 ビットのレジスタ。最適化でビット幅が削られることがある。
• Constants should be declared with a fixed size to keep the hardware small (4'd9, not 9, which is a 32-bit number).常數應該宣告固定位元寬，硬體才不會變大（寫 4'd9，不要寫 9，後者是 32 位元的數）。定数はビット幅を固定して宣言し、ハードウェアを小さく保つ（9 は 32 ビット値なので 4'd9 と書く）。
• real, time and realtime are not supported.real、time 與 realtime 不支援合成。real、time、realtime はサポートされない。
• A reg becomes a flip-flop only if it must hold a value across clock edges; otherwise it is just a wire (Lecture 6).reg 只有在必須跨時脈邊緣保存數值時才會變成正反器；否則它只是一條線（第 6 講）。reg がフリップフロップになるのは、クロックエッジをまたいで値を保持する必要があるときだけで、そうでなければ単なる配線である（第 6 講）。

1.3 Four-value logic: x and z1.3 四值邏輯：x 與 z1.3 4 値論理：x と z

Comparing against x or z (if (a === 1'bx)) has no hardware meaning.拿 x 或 z 來比較（if (a === 1'bx)）在硬體上沒有意義。x や z との比較（if (a === 1'bx)）にハードウェア上の意味はない。

(a) assign y = en ? d : 8'bz;
(b) if (sel == 2'bx1) y = a;
(c) case (op) 2'b00: y = a; 2'b01: y = b; default: y = 4'bx; endcase
(d) reg [7:0] r = 8'bx;            // as reset value
(e) casez (req) 4'b1???: g = 0; ... endcase

2. Operators2. 運算子2. 演算子

2.1 Arithmetic operators2.1 算術運算子2.1 算術演算子

• Adders and subtractors: ripple carry or carry look-ahead, chosen by the tool against timing constraints.加法器與減法器：漣波進位或前瞻進位，由工具依時序限制決定。加算器と減算器：リプルキャリーかキャリールックアヘッドかを、ツールがタイミング制約に応じて選ぶ。
• * and / may not be implemented efficiently as combinational logic.* 與 / 做成組合邏輯不一定有效率。* と / は組合せ論理として効率よく実装されるとは限らない。
• Special cases:特例：特別な場合：
  • Multiply / divide by a power of 2 → left / right shift (just wiring).乘以 / 除以 2 的冪次 → 向左 / 向右移位（只是接線）。2 のべき乗での乗除算 → 左／右シフト（配線だけ）。
  • % by a power of 2 → part select of the low bits.對 2 的冪次取 % → 低位元的 part select。2 のべき乗での % → 下位ビットの部分選択。

2.2 Shift operators2.2 移位運算子2.2 シフト演算子

• The shift amount (or the number of bits storing it) must be a constant.移位量（或儲存移位量的位元數）必須是常數。シフト量（またはそれを保持するビット数）は定数でなければならない。
• Inside a behavior they become shift registers and multiplexers built from low-level gates — not necessarily a library shift-register cell.在行為描述中它們會變成由低階邏輯閘組成的移位暫存器與多工器 — 不一定會對應到元件庫裡的移位暫存器 cell。振る舞い記述の中では、低レベルのゲートで構成されたシフトレジスタとマルチプレクサになる。ライブラリのシフトレジスタセルになるとは限らない。

Example: shift right / left unit範例：右移 / 左移單元例：右シフト／左シフトユニット

module data_shift (data_out, data_in, clk, reset, data_load, SL, SR);
  input  [3:0] data_in;
  input        clk, reset, data_load, SL, SR;
  output [3:0] data_out;
  reg    [3:0] data_out;

  always @ (posedge clk or negedge reset)
    if (reset == 0)  data_out = 0;              else
    if (data_load)   data_out = data_in;        else
    if (SL)          data_out = data_out << 1;  else
    if (SR)          data_out = data_out >> 1;
endmodule

The synthesized netlist realizes this per bit as AND-OR-INVERT gates in front of four DFFs with asynchronous reset.合成出來的 netlist 在每一個位元上都用一組 AND-OR-INVERT 閘實現這個結構，接在四個具非同步重置的 DFF 前面。合成されたネットリストでは、各ビットが AND-OR-INVERT ゲート群として実現され、非同期リセット付きの DFF 4 個の前段に置かれる。

2.3 Relational and identity operators2.3 關係運算子與相等運算子2.3 関係演算子と等価演算子

• Relational < > >= <=: combinational logic, or an adder/subtractor — $A \ge B$ when the sign bit of $A - B$ is 0, $A < B$ otherwise.關係運算子 < > >= <=：組合邏輯，或是一個加法器／減法器 — 當 $A - B$ 的符號位元為 0 時 $A \ge B$，否則 $A < B$。関係演算子 < > >= <=：組合せ論理、あるいは加減算器になる。$A - B$ の符号ビットが 0 なら $A \ge B$、そうでなければ $A < B$ である。
• Identity == != === !==: simple combinational logic (XOR per bit + OR). ===/!== synthesize like ==/!= because hardware has no x.相等運算子 == != === !==：簡單的組合邏輯（每位元 XOR 之後再 OR）。因為硬體裡沒有 x，===/!== 的合成結果與 ==/!= 相同。等価演算子 == != === !==：単純な組合せ論理（ビットごとの XOR と OR）。ハードウェアに x は存在しないので、===/!== は ==/!= と同じように合成される。

module identity_4bit (A_eq_B, A_noteq_B, A, B);
  output       A_eq_B, A_noteq_B;
  input  [3:0] A, B;

  assign A_eq_B    = (A == B);
  assign A_noteq_B = (A != B);
endmodule

module identity_if_4bit (data_out, data_a,
          data_b, data_c, data_d, sel);
  input  [3:0] data_a, data_b, data_c, data_d;
  input  [1:0] sel;
  output [3:0] data_out;
  reg    [3:0] data_out;

  always @ (data_a or data_b or data_c
            or data_d or sel)
    begin
      if      (sel == 2'b00) data_out = data_a;
      else if (sel == 2'b01) data_out = data_b;
      else if (sel == 2'b10) data_out = data_c;
      else                   data_out = data_d;
    end
endmodule

The equality tests are mutually exclusive, so the result is a single 4:1 mux (mux4_a per bit). Another tool run produced plain AND-OR gates with sel[1], sel[0] and their inverses — same function, different mapping.這些相等判斷互斥，所以結果只是一個 4:1 多工器（每位元一顆 mux4_a）。另一次工具執行則產生以 sel[1]、sel[0] 及其反相訊號組成的 AND-OR 閘 — 功能相同，只是對應到的元件不同。等価判定は互いに排他的なので、結果は 4:1 マルチプレクサ 1 個（ビットごとに mux4_a）になる。別のツール実行では sel[1]、sel[0] とその反転信号による単純な AND-OR ゲートが得られた。機能は同じでマッピングが異なる。

2.4 Reduction, bitwise and logical operators2.4 縮減、位元與邏輯運算子2.4 リダクション・ビット単位・論理演算子

Translated to Boolean equations and mapped to gates.會被翻譯成布林方程式，再對應到邏輯閘。ブール式に変換され、ゲートへマッピングされる。

module reduction (data_word, y_red_and, y_red_or, y_red_nand,
                  y_red_nor, y_red_xor, y_red_xnor);
  input  [1:0] data_word;
  output       y_red_and, y_red_or, y_red_nand, y_red_nor, y_red_xor, y_red_xnor;
  reg          y_red_and, y_red_or, y_red_nand, y_red_nor, y_red_xor, y_red_xnor;

  always @ (data_word) begin
    y_red_and  <=  &data_word;
    y_red_or   <=  |data_word;
    y_red_nand <= ~&data_word;
    y_red_nor  <= ~|data_word;
    y_red_xor  <=  ^data_word;
    y_red_xnor <= ~^data_word;
  end
endmodule

Six 2-input gates (AND, OR, XOR and their inverted versions) on data_word[1:0]. Non-blocking in a combinational block works here but = is the usual style.對 data_word[1:0] 產生六個 2 輸入閘（AND、OR、XOR 以及它們的反相版本）。在組合邏輯區塊中使用非阻斷式指定在這裡可以運作，但慣用寫法仍是 =。data_word[1:0] に対して 2 入力ゲートが 6 個（AND、OR、XOR とそれぞれの反転版）生成される。組合せ論理ブロックで非ブロッキング代入を使っても動作はするが、通常は = を使う。

2.5 Conditional and concatenation operators2.5 條件運算子與串接運算子2.5 条件演算子と連結演算子

module mux_conditional (data_out, data_a, data_b, data_c, data_d, sel);
  input  [3:0] data_a, data_b, data_c, data_d;
  input  [1:0] sel;
  output [3:0] data_out;

  assign data_out = (sel == 2'b00) ? data_a :
                    (sel == 2'b01) ? data_b :
                    (sel == 2'b10) ? data_c : data_d;
endmodule

• ?: synthesizes into muxes or gates that implement muxes.?: 會合成成多工器，或是實作多工器功能的邏輯閘。?: はマルチプレクサ、またはマルチプレクサを実現するゲートに合成される。
• Concatenation { } is supported in general and is just a logical bus — wiring with no function of its own.串接 { } 一般都支援，它只是一條邏輯匯流排 — 純粹是接線，本身沒有任何功能。連結 { } は一般にサポートされ、論理的なバスにすぎない。すなわち配線だけで、それ自体に機能はない。

2.6 Grouping of operators2.6 運算子的分組2.6 演算子のグループ化

module operator_group (sum1, sum2, a, b, c, d);
  input  [3:0] a, b, c, d;
  output [4:0] sum1, sum2;

  assign sum1 = a + b + c + d;
  assign sum2 = (a + b) + (c + d);
endmodule

Verilog evaluates a + b + c + d left to right as ((a + b) + c) + d: a chain of three adders. Parentheses turn it into a balanced tree — still three adders, but only two adder delays on the critical path.Verilog 由左而右把 a + b + c + d 解讀成 ((a + b) + c) + d：三個加法器串成一條鏈。加上括號就變成平衡樹 — 一樣是三個加法器，但關鍵路徑上只剩兩個加法器延遲。Verilog は a + b + c + d を左から右へ ((a + b) + c) + d と評価する。すなわち加算器 3 個の直列である。括弧を付けると平衡木になり、加算器は 3 個のままだがクリティカルパス上の加算器遅延は 2 段だけになる。

3. Assignments, case / if and Blocking vs Non-Blocking3. 指定敘述、case / if 與阻斷式對非阻斷式3. 代入、case / if、ブロッキングと非ブロッキング

3.1 Continuous assignments3.1 連續指定3.1 連続代入

• Translated to Boolean equations, then optimized and synthesized into combinational gates.先翻譯成布林方程式，再最佳化並合成為組合邏輯閘。ブール式に変換されたうえで最適化され、組合せゲートに合成される。
• No structural feedback allowed — no combinational loops.不允許結構上的回授 — 也就是不可以有組合迴路。構造的なフィードバックは許されない。すなわち組合せループを作ってはならない。

3.2 case and if statements3.2 case 與 if 敘述3.2 case 文と if 文

module alu_reg_with_z1 (alu_out, en, a, b, s0, s1, s2, clk, reset);
  output [1:0] alu_out;
  input  [1:0] a, b;
  input        en, s0, s1, s2, clk, reset;
  reg    [1:0] out_int;

  assign alu_out = (en == 1) ? out_int : 2'bz;

  always @ (posedge clk)
    if (reset) out_int = 2'b0;
    else
      case ({s0, s1, s2})
        3'b111:  out_int = a & b;
        3'b011:  out_int = a | b;
        3'b001:  out_int = a ^ b;
        default: out_int = 2'bx;
      endcase
endmodule

All three listed cases have s2 = 1, and every other code is a don't care. The optimizer can therefore choose outputs that ignore s2 entirely — the logic is driven only by s0 and s1. The unused input s2 is still retained as a port (ports are never removed). Result: two DFFs with synchronous reset, a gate-level ALU in front and two tri-state output buffers.列出的三個 case 都滿足 s2 = 1，其餘編碼全是 don't care。因此最佳化器可以挑出完全不理會 s2 的輸出 — 邏輯只由 s0 與 s1 驅動。沒用到的輸入 s2 仍然保留為埠（埠永遠不會被刪掉）。結果是：兩個具同步重置的 DFF，前面接閘級 ALU，後面接兩個三態輸出緩衝器。挙げられた 3 つの case はいずれも s2 = 1 であり、それ以外のコードはすべてドントケアである。したがって最適化器は s2 を完全に無視する出力を選べる。論理は s0 と s1 だけで駆動される。使われない入力 s2 もポートとしては残る（ポートが削除されることはない）。結果は、同期リセット付き DFF 2 個、その前段のゲートレベル ALU、そして 2 個のトライステート出力バッファである。

3.3 Blocking vs non-blocking in clocked blocks3.3 時脈區塊中的阻斷式與非阻斷式指定3.3 クロック同期ブロックにおけるブロッキングと非ブロッキング

module pipe1 (data, rega, regb, regc, clk, reset);
  input  [1:0] data;
  input        clk, reset;
  output [1:0] rega, regb, regc;
  reg    [1:0] rega, regb, regc;

  always @ (posedge clk or posedge reset)
    if (reset)
      begin
        rega  = 2'b0;
        regb <= 2'b0;
        regc <= 2'b0;
      end
    else
      begin
        rega  = data;
        regb <= rega + 1;     // new rega!
        regc <= regb + 1;     // old regb
      end
endmodule

module pipe1_alt (data, rega, regb, regc, clk, reset);
  ...
  always @ (posedge clk or posedge reset)
    if (reset) rega = 2'b0; else rega = data;

  always @ (posedge clk or posedge reset)
    if (reset)
      begin
        regb <= 2'b0;
        regc <= 2'b0;
      end
    else
      begin
        regb <= rega + 1;     // rega of the previous cycle
        regc <= regb + 1;
      end
endmodule

module pipe2 (data, rega, regb, regc, clk, reset);
  ...
  always @ (posedge clk or posedge reset)
    if (reset)
      begin
        rega = 2'b0;
        regb = 2'b0;
        regc = 2'b0;
      end
    else
      begin
        rega = data;
        regb = rega + 1;
        regc = regb + 1;
      end
endmodule

rega = data;
regb = data + 1;
regc = data + 1 + 1;

// equivalent to
rega <= data;
regb <= data + 1;
regc <= data + 1 + 1;

4. Delay Controls, Event Controls and Resets4. 延遲控制、事件控制與重置4. 遅延制御、イベント制御、リセット

4.1 Delay controls4.1 延遲控制4.1 遅延制御

• Not advisable in a behavior that will be synthesized.在將要拿去合成的行為描述中不建議使用。合成対象となる振る舞い記述では使うべきでない。
• Delays shorter than a clock cycle are ignored.比一個時脈週期短的延遲會被忽略。1 クロック周期より短い遅延は無視される。
• Some tools place an assignment in a later clock cycle if its delay is longer than a clock cycle — avoid: the behavior then depends on the tool.若延遲比一個時脈週期長，有些工具會把該指定移到後面的時脈週期 — 請避免：這樣電路行為就取決於工具。遅延が 1 クロック周期より長い場合、代入を後のクロック周期に置くツールもある。避けること。動作がツール依存になる。

4.2 Event controls4.2 事件控制4.2 イベント制御

always @ (posedge x or posedge y or posedge z)
  begin
    if (x)
      a <= 0;          // asynchronous clear
    else if (y)
      a <= 1;          // asynchronous set
    // z is not mentioned here, and is assumed synchronous
    else a <= b & c;   // z acts as the clock
  end

4.3 Resets4.3 重置4.3 リセット

• An asynchronous reset is modeled within the event control expression that detects the synchronizing (clock) signal of the behavior.非同步重置要寫在偵測該行為同步訊號（時脈）的事件控制運算式裡。非同期リセットは、その振る舞いの同期信号（クロック）を検出するイベント制御式の中に記述する。
• If the library flip-flops have set/reset pins that the Verilog code does not use, those pins are tied to power or ground.如果元件庫的正反器有 set/reset 腳位而 Verilog 程式沒有用到，那些腳位會被接到電源或接地。ライブラリのフリップフロップにセット／リセット端子があり、Verilog 記述がそれを使わない場合、その端子は電源かグランドに固定される。

// (a)
always @ (posedge clk or negedge rst_n)
  if (!rst_n) q <= 0; else q <= d;
// (b)
always @ (posedge clk or negedge rst_n)
  if (en) q <= d; else if (!rst_n) q <= 0;
// (c)
always @ (posedge clk or negedge clk) q <= d;
// (d)
always @ (posedge clk or posedge set or posedge clr)
  if (clr) q <= 0; else if (set) q <= 1; else q <= d;

5. Loops5. 迴圈5. ループ

5.1 Four loop types5.1 四種迴圈型態5.1 四つのループ型

A loop is static (data-independent) if the compiler can determine the number of iterations.如果編譯器能決定迴圈的執行次數，這個迴圈就是靜態的（與資料無關）。コンパイラが反復回数を決定できるとき、そのループは静的（データ非依存）である。

5.2 Type I — static loop without internal timing controls5.2 型 I — 無內部時序控制的靜態迴圈5.2 タイプ I — 内部タイミング制御のない静的ループ

module for_and_loop_comb (out, a, b);
  input  [3:0] a, b;
  output [3:0] out;
  reg    [2:0] i;
  reg    [3:0] out;

  always @ (a or b)
    begin
      for (i = 0; i < 4; i = i + 1)
        out[i] = a[i] & b[i];
    end
endmodule

Unrolled into four AND gates. Replacing @(a or b) with @(posedge clk) gives for_and_loop_reg: the same ANDs feeding four flip-flops.展開成四個 AND 閘。把 @(a or b) 換成 @(posedge clk) 就成為 for_and_loop_reg：同樣的 AND 閘接到四個正反器。AND ゲート 4 個に展開される。@(a or b) を @(posedge clk) に替えると for_and_loop_reg になり、同じ AND ゲートが 4 個のフリップフロップを駆動する。

Counting ones (Type I)數 1 的個數（型 I）1 の個数を数える（タイプ I）

module count_ones_a (bit_count, data, clk, reset);
  parameter data_width  = 4;
  parameter count_width = 3;
  output [count_width-1:0] bit_count;
  input  [data_width-1:0]  data;
  input                    clk, reset;
  reg    [count_width-1:0] count, bit_count, index;
  reg    [data_width-1:0]  temp;

  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      bit_count = 0;
      temp = data;
      for (index = 0; index < data_width; index = index + 1) begin
        count = count + temp[0];
        temp  = temp >> 1;
      end
      bit_count = count;
    end
endmodule

The loop unrolls into a small adder tree that counts the ones of data in one clock; only bit_count (3 FFs) is registered — count, temp, index are written before they are read, so they are wires.迴圈展開成一棵小的加法器樹，在一個時脈內數完 data 裡的 1；只有 bit_count（3 個正反器）會被暫存 — count、temp、index 都是先寫後讀，所以只是線。ループは小さな加算器ツリーに展開され、data 中の 1 を 1 クロックで数える。レジスタになるのは bit_count（FF 3 個）だけで、count、temp、index は読まれる前に書かれるため単なる配線になる。

5.3 Type II — static loop with internal timing controls5.3 型 II — 含內部時序控制的靜態迴圈5.3 タイプ II — 内部タイミング制御のある静的ループ

If a static loop contains an edge-sensitive event control, its work is synchronized and distributed over one or more clock cycles.靜態迴圈若含有邊緣觸發的事件控制，它的工作會被同步化，並分散到一個或多個時脈週期。静的ループがエッジセンシティブなイベント制御を含む場合、その処理は同期化され、1 つ以上のクロック周期に分散される。

module count_ones_b (bit_count, data, clk, reset);
  ... // same declarations
  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      temp  = data;
      for (index = 0; index < data_width; index = index + 1)
        @ (posedge clk)
          begin
            if (temp[0]) count = count + 1;
            temp = temp >> 1;
          end
      @ (posedge clk)
        bit_count = count;
    end
endmodule

One bit is examined per clock; bit_count updates after data_width + 1 extra clocks. This is an implicit state machine — supported only by some tools. Not recommended.每個時脈檢查一個位元；bit_count 要再過 data_width + 1 個時脈才更新。這是一個隱含的狀態機 — 只有部分工具支援。不建議使用。1 クロックにつき 1 ビットを調べ、bit_count は追加の data_width + 1 クロック後に更新される。これは暗黙の状態機械であり、一部のツールしか対応しない。推奨しない。

5.4 Type III — non-static loop without internal timing controls 5.4 型 III — 無內部時序控制的非靜態迴圈 5.4 タイプ III — 内部タイミング制御のない非静的ループ Not synthesizable不可合成合成不可

• The number of iterations depends on a variable modified inside the loop.執行次數取決於迴圈內部被修改的變數。反復回数が、ループ内で変更される変数に依存する。
• Essentially an iterative combinational circuit of data-dependent size — it simulates, but cannot be built.本質上是一個大小由資料決定的迭代式組合電路 — 模擬得出來，硬體卻做不出來。本質的には、サイズがデータに依存する反復型の組合せ回路である。シミュレーションはできるが、回路としては作れない。

module count_ones_c (bit_count, data, clk, reset);
  ...
  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin
      count = 0;
      temp  = data;
      for (index = 0; | temp; index = index + 1) begin   // stops when temp == 0
        if (temp[0]) count = count + 1;
        temp = temp >> 1;
      end
      bit_count = count;
    end
endmodule

5.5 Type IV — non-static loop with internal timing controls5.5 型 IV — 含內部時序控制的非靜態迴圈5.5 タイプ IV — 内部タイミング制御のある非静的ループ

The timing control distributes the loop over multiple cycles; the number of cycles is set by a variable modified within the loop.時序控制把迴圈分散到多個週期；週期數由迴圈內部被修改的變數決定。タイミング制御がループを複数サイクルに分散させ、そのサイクル数はループ内で変更される変数によって決まる。

module count_ones_d (bit_count, data, clk, reset);
  ...
  always @ (posedge clk)
    if (reset) begin count = 0; bit_count = 0; end
    else begin: bit_counter
      count = 0;
      temp  = data;
      while (temp)
        @ (posedge clk)
          if (reset) begin
            count = 2'b0;
            disable bit_counter; end
          else begin
            count = count + temp[0];   // notice: no if needed
            temp  = temp >> 1;
          end
      @ (posedge clk);
        if (reset) begin
          count = 0;
          disable bit_counter; end
        else bit_count = count;
    end
endmodule

Reset must be re-checked at every internal @(posedge clk), and disable jumps back to the top. Not recommended.每一個內部的 @(posedge clk) 都必須重新檢查 reset，而 disable 會跳回最上面。不建議使用。内部の @(posedge clk) ごとにリセットを再確認する必要があり、disable は先頭へ戻る。推奨しない。

(a) for (k = 0; k < 8; k = k + 1) y[k] = x[7-k];
(b) while (q != 0) begin q = q - 1; n = n + 1; end
(c) repeat (4) @(posedge clk) acc = acc + in;
(d) while (busy) @(posedge clk) busy = check(status);

6. Tasks, Functions, specify and Compiler Directives6. task、function、specify 與編譯指令6. タスク、関数、specify、コンパイラ指令

6.1 Tasks6.1 task6.1 タスク

• Synthesis tools expand a task inline.合成工具會把 task 就地展開。合成ツールはタスクをインライン展開する。
• A task to be synthesized may not contain inout ports.要拿去合成的 task 不可以有 inout 埠。合成対象のタスクに inout ポートを含めてはならない。
• A task with no timing (event) controls synthesizes to combinational logic.沒有時序（事件）控制的 task 會合成成組合邏輯。タイミング（イベント）制御を持たないタスクは組合せ論理に合成される。

module adder_task (c_out, sum, clk, reset, c_in, data_a, data_b);
  input  [3:0] data_a, data_b;
  input        clk, reset, c_in;
  output [3:0] sum;
  output       c_out;
  reg    [3:0] sum;
  reg          c_out;

  always @ (posedge clk or posedge reset)
    if (reset) {c_out, sum} = 0; else
    add_values (sum, c_out, data_a, data_b, c_in);

  task add_values;
    output [3:0] sum;
    output       c_out;
    input  [3:0] data_a, data_b;
    input        c_in;
    begin
      {c_out, sum} = data_a + (data_b + c_in);
    end
  endtask
endmodule

Result: two 5-bit adders (data_b + c_in, then + data_a) feeding five DFFs with asynchronous reset.結果：兩個 5 位元加法器（先 data_b + c_in，再 + data_a）接到五個具非同步重置的 DFF。結果：5 ビット加算器 2 個（まず data_b + c_in、次に + data_a）が、非同期リセット付き DFF 5 個を駆動する。

6.2 Functions6.2 function6.2 関数

• Expanded at the site of their call; always synthesize to combinational logic.在呼叫的位置就地展開；一定會合成成組合邏輯。呼び出し箇所で展開され、常に組合せ論理に合成される。
• Incompletely specified case and if statements are not allowed inside a function.function 裡不允許出現不完整的 case 與 if 敘述。関数の中では、不完全に記述された case 文や if 文は許されない。

module arithmetic_unit (operand_1, operand_2, result_1, result_2);
  input  [3:0] operand_1, operand_2;
  output [4:0] result_1;
  output [3:0] result_2;

  assign result_1 = sum_of_operands (operand_1, operand_2);
  assign result_2 = largest_operand (operand_1, operand_2);

  function [4:0] sum_of_operands;
    input [3:0] operand_1, operand_2;
    sum_of_operands = operand_1 + operand_2;
  endfunction

  function [3:0] largest_operand;
    input [3:0] operand_1, operand_2;
    largest_operand = (operand_1 >= operand_2) ? operand_1 : operand_2;
  endfunction
endmodule

Result: one 4-bit adder for result_1, and a comparator (gates) driving four 2:1 muxes for result_2.結果：result_1 用一個 4 位元加法器；result_2 則是一個比較器（邏輯閘）驅動四個 2:1 多工器。結果：result_1 には 4 ビット加算器 1 個、result_2 には比較器（ゲート）が 2:1 マルチプレクサ 4 個を駆動する構成になる。

6.3 specify blocks and compiler directives6.3 specify 區塊與編譯指令6.3 specify ブロックとコンパイラ指令

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