If-else в Verilog: условная логика в процедурных блоках

Знакомый синтаксис, другая ментальная модель

if/else выглядит ровно как в C:

if (condition) begin
    // ... операторы ...
end else begin
    // ... операторы ...
end

Но правила другие, потому что Verilog не софт. Две вещи держим в голове:

1. if/else живёт только внутри процедурного блока. Нельзя написать отдельностоящий if на уровне module.
2. Во что синтезируется if/else, зависит от типа блока. В комбинационном блоке - в mux или priority-encoder. В тактируемом - во flip-flop с условной логикой обновления.

Внутри комбинационного блока

module max_of_three(
    input  wire [7:0] a,
    input  wire [7:0] b,
    input  wire [7:0] c,
    output reg  [7:0] max
);
    always @(*) begin
        if (a >= b && a >= c)
            max = a;
        else if (b >= c)
            max = b;
        else
            max = c;
    end
endmodule

module test;
    reg [7:0] a, b, c;
    wire [7:0] max;
    max_of_three dut(.a(a), .b(b), .c(c), .max(max));

    initial begin
        a = 8'd10; b = 8'd20; c = 8'd15; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd50; b = 8'd30; c = 8'd40; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        a = 8'd5;  b = 8'd5;  c = 8'd50; #1 $display("max(%0d,%0d,%0d)=%0d", a, b, c, max);
        $finish;
    end
endmodule

Комбинационный always @(*) перезапускается, когда меняется a, b или c. Цепочка if/else выбирает одну ветку, присваивает max, и блок заканчивается. Поскольку max всегда присваивается (на каждом пути), синтезатор выдаёт чистую комбинационную логику - без latch.

Заметь, что max объявлен reg, хотя в железе нет flip-flop. То же правило, что всегда: всё, что присваивается внутри always, должно быть reg.

Latch-ловушка

Самый частый баг в комбинационном коде новичка:

// НЕПРАВИЛЬНО - выводит latch
always @(*) begin
    if (enable)
        out = data;
    // нет else! когда `enable` low, что делает `out`?
end

Синтезатор читает "когда enable low, out не присваивается" и решает, что out должен помнить старое значение. Помнить значение требует ячейку памяти, и тул вставляет latch. Latch в синхронных проектах вызывают timing-проблемы, их сложно сбрасывать и они почти никогда не то, что ты имел в виду.

Два способа фикса:

// Фикс 1: явная ветка else
module no_latch_1(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        if (enable) out = data;
        else        out = 8'd0;
    end
endmodule

// Фикс 2: дефолтное присваивание в начале
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // сначала дефолт
        if (enable) out = data; // переопределяем, если условие
    end
endmodule

module test;
    reg en;
    reg [7:0] d;
    wire [7:0] out1, out2;

    no_latch_1 u1(.enable(en), .data(d), .out(out1));
    no_latch_2 u2(.enable(en), .data(d), .out(out2));

    initial begin
        en = 0; d = 8'h55; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        en = 1; d = 8'hAA; #1 $display("en=%b d=%h out1=%h out2=%h", en, d, out1, out2);
        $finish;
    end
endmodule

Оба дают одно и то же комбинационное железо - 2-to-1 mux. Паттерн "дефолт в начале" лучше масштабируется, когда у одного сигнала много условных присваиваний.

Внутри тактируемого блока

module counter_with_reset(
    input  wire       clk,
    input  wire       reset,
    input  wire       enable,
    output reg  [7:0] count
);
    always @(posedge clk) begin
        if (reset)        count <= 8'd0;
        else if (enable)  count <= count + 8'd1;
        // else: неявный hold (count держит значение - так делает flip-flop)
    end
endmodule

module test;
    reg clk = 0;
    reg reset = 1;
    reg enable = 0;
    wire [7:0] count;

    counter_with_reset dut(.clk(clk), .reset(reset), .enable(enable), .count(count));

    always #5 clk = ~clk;

    initial begin
        #12 reset = 0;
        #5  enable = 1;
        #50 enable = 0;
        #20 enable = 1;
        #30 $finish;
    end

    always @(posedge clk)
        $display("t=%0t reset=%b enable=%b count=%0d", $time, reset, enable, count);
endmodule

Замечай, что отличается от комбинационного случая:

• Блок - always @(posedge clk) - территория flip-flop.
• Присваивание через <= (non-blocking).
• Нет else для случая "ни reset, ни enable". Это нормально. В тактируемом блоке, когда ни одна ветка не срабатывает, flip-flop просто держит старое значение - что физически делает flip-flop. Никакой latch не выводится, потому что сигнал уже регистр.

Это единственное место, где опустить else безопасно. Вне тактируемых блоков всегда обрабатывай каждый путь.

Цепочка else if: priority encoder

Цепочка else if-операторов имеет неявный приоритет - более ранние условия перекрывают более поздние:

module priority_encoder(
    input  wire [3:0] requests,
    output reg  [1:0] grant,
    output reg        any
);
    always @(*) begin
        any = |requests;
        if      (requests[0]) grant = 2'd0;
        else if (requests[1]) grant = 2'd1;
        else if (requests[2]) grant = 2'd2;
        else if (requests[3]) grant = 2'd3;
        else                  grant = 2'd0;
    end
endmodule

module test;
    reg [3:0] req;
    wire [1:0] grant;
    wire any;
    priority_encoder dut(.requests(req), .grant(grant), .any(any));

    initial begin
        req = 4'b0000; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b0010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1010; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        req = 4'b1111; #1 $display("req=%b any=%b grant=%0d", req, any, grant);
        $finish;
    end
endmodule

requests[0] - высший приоритет: если он установлен, grant равен 0 независимо от того, что делают старшие биты. Синтезатор превращает цепочку в каскад mux: сначала проверяем бит 0, потом 1, потом 2, потом 3. Каждый уровень добавляет небольшую задержку.

Если условия взаимоисключающие - скажем, декодируешь one-hot вход - case (следующий документ) даёт более плоское и быстрое железо, чем цепочка else if. Используй форму case, когда нет реальной потребности в приоритете.

if без else в тактируемом коде

Тактируемому блоку не нужен else, потому что "держать старое значение" - дефолтное поведение. Так строят enables:

always @(posedge clk) begin
    if (load) target <= incoming;
    // нет else: когда load low, target держит значение
end

Это load-enabled-регистр. Большинство pipeline-регистров, счётчиков и конфигурационных регистров используют этот паттерн.

begin/end и одиночные операторы

Как в C, для одного оператора begin/end можно опустить:

if (a) out = 1;
else   out = 0;

Для чего-то длиннее одного оператора - используй блок:

if (a) begin
    out = 1;
    flag = 1;
end else begin
    out = 0;
    flag = 0;
end

Два паттерна свободно смешиваются. Style guides обычно рекомендуют всегда использовать begin/end, чтобы добавлять второй оператор было безболезненно.

Что дальше

Следующий документ - Case Statement - разбирает case, правильный инструмент для multi-way декодирования (state machines, диспетчеризация opcode, ROM-таблицы). После - циклы for, чуть отличающиеся от софтовых родственников, потому что разворачиваются на elaboration.