If-Else Verilog : logique conditionnelle dans les blocs procéduraux

Syntaxe familière, modèle mental différent

if/else ressemble exactement à C :

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

Mais les règles sont différentes parce que Verilog n'est pas du logiciel. Deux choses à garder en tête :

1. if/else ne vit qu'à l'intérieur d'un bloc procédural. Tu ne peux pas écrire un if autonome au niveau module.
2. Ce en quoi se synthétise le if/else dépend du type de bloc. Dans un bloc combinatoire, ça devient un multiplexeur ou encodeur de priorité. Dans un bloc cadencé, ça devient un flip-flop avec une logique de mise à jour conditionnelle.

À l'intérieur d'un bloc combinatoire

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

Le bloc combinatoire always @(*) se ré-exécute chaque fois que a, b ou c change. La chaîne if/else choisit une branche, assigne max, et le bloc se termine. Comme max est toujours assigné (chaque chemin a une assignation), le synthétiseur produit de la logique combinatoire pure - pas de latch.

Note que max est déclaré reg même s'il n'y a pas de flip-flop dans le matériel. Même règle qu'avant : tout ce qui est assigné à l'intérieur de always doit être reg.

Le piège du latch

C'est le bug le plus courant dans le code combinatoire débutant :

// FAUX - infère un latch
always @(*) begin
    if (enable)
        out = data;
    // pas de else ! quand `enable` est bas, que fait `out` ?
end

Le synthétiseur lit « quand enable est bas, out n'est pas assigné » et décide que out doit se souvenir de sa valeur précédente. Se souvenir d'une valeur nécessite une cellule de stockage, donc l'outil insère un latch. Les latches dans les designs synchrones causent des problèmes de timing, sont durs à reset, et ne sont presque jamais ce que tu voulais dire.

Deux façons de corriger :

// Fix 1 : branche else explicite
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 : assignation par défaut en haut
module no_latch_2(
    input  wire       enable,
    input  wire [7:0] data,
    output reg  [7:0] out
);
    always @(*) begin
        out = 8'd0;             // défaut d'abord
        if (enable) out = data; // surcharge si la condition tient
    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

Les deux produisent le même matériel combinatoire - un mux 2 vers 1. Le motif « défaut en haut » passe mieux à l'échelle quand tu as beaucoup d'assignations conditionnelles vers le même signal.

À l'intérieur d'un bloc cadencé

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 : maintien implicite (count garde sa valeur - c'est ce que fait un 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

Remarque ce qui est différent du cas combinatoire :

• Le bloc est always @(posedge clk) - territoire flip-flop.
• L'assignation utilise <= (non-blocking).
• Pas de else pour le cas « ni reset ni enable ». C'est OK. Dans un bloc cadencé, quand aucune branche ne tire, le flip-flop garde simplement sa valeur précédente - ce qui est exactement ce qu'un flip-flop fait physiquement. Aucun latch n'est inféré parce que le signal est déjà un registre.

C'est le seul endroit où omettre un else est sûr. En dehors des blocs cadencés, gère toujours chaque chemin.

else if chaînés : un encodeur de priorité

Une chaîne d'instructions else if a une priorité implicite - les conditions plus anciennes l'emportent sur les plus récentes :

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 la priorité la plus haute - s'il est mis, le grant est 0 quelle que soit l'action des bits plus haut. Le synthétiseur transforme la chaîne en mux en cascade : vérifie bit 0 d'abord, puis bit 1, puis bit 2, puis bit 3. Chaque niveau ajoute un petit délai.

Si les conditions sont mutuellement exclusives - disons décoder une entrée one-hot - une instruction case (prochain document) produit du matériel plus plat et plus rapide qu'une chaîne else if. Utilise la forme case quand il n'y a pas d'exigence de priorité véritable.

if sans else dans le code cadencé

Un bloc cadencé n'a pas besoin d'un else parce que « garder la valeur précédente » est la valeur par défaut. C'est ainsi qu'on construit des enables :

always @(posedge clk) begin
    if (load) target <= incoming;
    // pas de else : quand load est bas, target garde sa valeur
end

C'est un registre à load enable. La plupart des registres de pipeline, compteurs et registres de configuration utilisent ce motif.

begin/end et instructions uniques

Comme en C, tu peux omettre begin/end pour une seule instruction :

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

Pour tout ce qui dépasse une instruction, utilise le bloc :

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

Les deux motifs se mélangent librement. Les guides de style recommandent généralement d'utiliser toujours begin/end pour rendre l'ajout d'une seconde instruction indolore.

La suite

Le prochain document - Instruction case - couvre case, qui est le bon outil pour le décodage multi-voies (machines à états, dispatch d'opcodes, tables ROM). Ensuite, les boucles for, qui sont subtilement différentes de leurs cousines logicielles parce qu'elles sont déroulées à l'élaboration.