If-Else em Verilog: Lógica condicional em blocos procedurais

Sintaxe familiar, modelo mental diferente

if/else parece exatamente com C:

if (condition) begin
    // ... declaracoes ...
end else begin
    // ... declaracoes ...
end

Mas as regras são diferentes porque Verilog não é software. Duas coisas para lembrar:

1. if/else só vive dentro de um bloco procedural. Você não consegue escrever um if solto no nível do module.
2. O que o if/else sintetiza depende do tipo do bloco. Em um bloco combinacional, vira um multiplexador ou priority encoder. Em um bloco clocked, vira um flip-flop com lógica de atualização condicional.

Dentro de um bloco combinacional

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

O bloco combinacional always @(*) re-roda sempre que a, b ou c muda. A cadeia if/else escolhe um ramo, atribui max e o bloco termina. Como max é sempre atribuído (cada caminho tem uma atribuição), o sintetizador produz lógica combinacional pura - sem latch.

Note que max é declarado reg mesmo sem haver um flip-flop no hardware. Mesma regra de sempre: qualquer coisa atribuída dentro de always precisa ser reg.

A armadilha do latch

Este é o bug mais comum em código combinacional de iniciante:

// ERRADO - infere um latch
always @(*) begin
    if (enable)
        out = data;
    // sem else! quando `enable` e baixo, o que `out` faz?
end

O sintetizador lê "quando enable é baixo, out não é atribuído" e decide que out precisa lembrar seu valor anterior. Lembrar um valor requer uma célula de armazenamento, então a ferramenta insere um latch. Latches em designs síncronos causam problemas de timing, são difíceis de resetar e quase nunca são o que você quis dizer.

Duas formas de corrigir:

// Fix 1: ramo else explicito
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

// Fix 2: atribuicao default no topo
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // default primeiro
        if (enable) out = data; // sobrescreve se a condicao for verdadeira
    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

Ambos produzem o mesmo hardware combinacional - um mux 2-para-1. O padrão "default no topo" escala melhor quando você tem muitas atribuições condicionais ao mesmo sinal.

Dentro de um bloco clocked

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 implicito (count mantem o valor - e o que um flip-flop faz)
    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

Note o que é diferente do caso combinacional:

• O bloco é always @(posedge clk) - território de flip-flop.
• A atribuição usa <= (non-blocking).
• Não há else para o caso "nem reset nem enable". Tudo bem. Em um bloco clocked, quando nenhum ramo dispara, o flip-flop simplesmente mantém seu valor anterior - o que é exatamente o que um flip-flop fisicamente faz. Nenhum latch é inferido porque o sinal já é um register.

Esse é o único lugar onde omitir um else é seguro. Fora de blocos clocked, sempre lide com cada caminho.

else if encadeado: Um priority encoder

Uma cadeia de declarações else if tem prioridade implícita - condições anteriores superam as posteriores:

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] é a prioridade mais alta - se está setado, o grant é 0 independente do que os bits de número maior fazem. O sintetizador transforma a cadeia em um mux em cascata: verifica o bit 0 primeiro, depois o bit 1, depois o bit 2, depois o bit 3. Cada nível adiciona um pouco de delay.

Se as condições são mutuamente exclusivas - digamos, decodificar uma entrada one-hot - uma declaração case (próximo doc) produz hardware mais achatado e rápido do que uma cadeia else if. Use a forma case quando não há um requisito genuíno de prioridade.

if sem else em código clocked

Um bloco clocked não precisa de else porque "manter valor anterior" é o padrão. É assim que você constrói enables:

always @(posedge clk) begin
    if (load) target <= incoming;
    // sem else: quando load e baixo, target mantem seu valor
end

Esse é um register com load enable. A maioria dos registers de pipeline, contadores e registers de configuração usam esse padrão.

begin/end e declarações únicas

Como em C, você pode omitir begin/end para uma única declaração:

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

Para qualquer coisa além de uma declaração, use o bloco:

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

Os dois padrões se misturam livremente. Guias de estilo geralmente recomendam sempre usar begin/end para tornar adicionar uma segunda declaração indolor.

O que vem a seguir

O próximo doc - Case Statement - cobre case, que é a ferramenta certa para decodificação multi-way (máquinas de estado, dispatch de opcode, tabelas ROM). Depois disso, loops for, que são sutilmente diferentes de seus primos de software porque são desenrolados em tempo de elaboração.