Opérateurs bitwise et de réduction en Verilog

Deux rôles pour le même symbole

&, |, ^, et leurs frères inversés apparaissent sous deux formes distinctes :

• Forme binaire (deux opérandes) : a & b - opération bitwise entre vecteurs de même largeur.
• Forme unaire (un opérande) : &a - réduction à travers tous les bits de a vers un seul bit.

Le compilateur les distingue en comptant les opérandes. La convention de nommage utilisée par les gens est « les opérateurs bitwise » pour la forme binaire et « les opérateurs de réduction » pour la forme unaire.

Bitwise : un bit à la fois

module bitwise;
    wire [7:0] a = 8'b1100_1010;
    wire [7:0] b = 8'b0101_1100;

    initial begin
        $display("a    = %b", a);
        $display("b    = %b", b);
        $display("a & b = %b", a & b);   // bitwise AND
        $display("a | b = %b", a | b);   // bitwise OR
        $display("a ^ b = %b", a ^ b);   // bitwise XOR
        $display("~a    = %b", ~a);      // bitwise NOT (un seul opérande)
        $display("a ~^ b = %b", a ~^ b); // bitwise XNOR
        $finish;
    end
endmodule

L'ensemble complet :

Opérateur	Nom	Bit de sortie en position N
a & b	AND	a[N] AND b[N]
a | b	OR	a[N] OR b[N]
a ^ b	XOR	a[N] XOR b[N]
a ~& b	NAND	NOT (a[N] AND b[N])
a ~| b	NOR	NOT (a[N] OR b[N])
a ~^ b	XNOR	NOT (a[N] XOR b[N])
~a	NOT	NOT a[N]

Note que ~&, ~|, ~^ s'écrivent avec le tilde en premier et l'opérateur en second. Ce sont des tokens uniques ; pas d'espace entre.

Quand les deux opérandes ont des largeurs différentes, la plus étroite est zero-étendue à gauche pour correspondre. Si tu veux une extension de signe, utilise des opérandes signés explicitement avec $signed().

Réduction : de plusieurs bits à un seul

Les formes unaires des mêmes opérateurs collapsent un vecteur à un seul bit :

module reduction;
    wire [7:0] data1 = 8'b1111_1111;
    wire [7:0] data2 = 8'b0000_0001;
    wire [7:0] data3 = 8'b0101_0101;
    wire [7:0] data4 = 8'b0000_0000;

    initial begin
        $display("data = %b   &data  |data  ^data  $isunknown", data1);
        $display("       %b      %b     %b     %b", data1, &data1, |data1, ^data1);
        $display("       %b      %b     %b     %b", data2, &data2, |data2, ^data2);
        $display("       %b      %b     %b     %b", data3, &data3, |data3, ^data3);
        $display("       %b      %b     %b     %b", data4, &data4, |data4, ^data4);
        $finish;
    end
endmodule

Ce que chacun veut dire :

• &data retourne 1 si tous les bits de data sont 1, sinon 0. Utile pour les checks « est-ce que c'est all-ones ? ».
• |data retourne 1 si un bit quelconque de data est 1, sinon 0. Utile pour les checks « est-ce que c'est non-zéro ? ».
• ^data retourne la parité - XOR de tous les bits. 1 si nombre impair de 1, 0 si pair.
• ~&data, ~|data, ~^data sont les inverses des précédents.

Tu les verras partout dans le vrai code :

wire empty       = ~|fifo_count;       // vide si et seulement si count est zéro
wire all_ones    = &mask;              // tous bits mis
wire parity_bit  = ^data;              // parité d'un octet
wire any_request = |request_vector;    // y a-t-il une requête ?

Les formes réduction sont concises et se synthétisent en arbres de portes évidents : & se réduit à un AND multi-entrées, | à un OR multi-entrées, ^ à un arbre XOR (qui est aussi le générateur de parité en matériel).

Motifs courants

Mettre et effacer des bits

wire [7:0] data;
wire [7:0] mask = 8'b0000_1000;

wire [7:0] set     = data | mask;     // force le bit 3 à 1
wire [7:0] cleared = data & ~mask;    // force le bit 3 à 0
wire [7:0] toggled = data ^ mask;     // bascule le bit 3
wire [7:0] tested  = data & mask;     // zéro si bit 3 était 0, non-zéro sinon

Ce sont les mêmes idiomes de manipulation de bits que tu utiliserais en C. Ils se synthétisent en opérations de porte unique.

Vérifier si une valeur égale all-ones

wire is_max = &counter;       // 1 si chaque bit de counter est 1

Une réduction AND avec une porte, vs écrire counter == 8'hFF (qui marcherait aussi ; les synthétiseurs produisent généralement le même matériel).

Générer un bit de parité

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // bit de parité paire
    wire       odd_parity = ~^data;     // bit de parité impaire

    initial begin
        for (integer i = 0; i < 8; i = i + 1) begin
            data = 8'd1 << i;
            #1 $display("data=%b parity=%b odd=%b", data, parity, odd_parity);
        end
        $finish;
    end
endmodule

Détecter un signal actif

wire any_pending = |request_vector;

Si request_vector est large (disons 64 requérants), la réduction OR collapse à un seul signal que tu peux alimenter dans un encodeur de priorité ou un arbitre.

Opérateurs de shift

Pendant qu'on est sur les opérateurs au niveau bit, les shifts :

• a << N décale a à gauche de N positions de bits, remplit avec des zéros à droite.
• a >> N décale a à droite de N positions de bits, remplit avec des zéros à gauche.
• a <<< N shift arithmétique gauche (identique à << pour le non signé).
• a >>> N shift arithmétique droit - remplit avec le bit de signe quand a est signé.

module shifts;
    initial begin
        $display("8'b0011_1100 << 2 = %b", 8'b0011_1100 << 2);
        $display("8'b0011_1100 >> 2 = %b", 8'b0011_1100 >> 2);

        // Shift arithmétique droit sur valeur signée préserve le signe :
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Les shifts par une puissance constante sont gratuits en matériel (juste du recâblage). Les shifts par une variable runtime produisent un barrel shifter, plus gros mais encore peu coûteux.

La suite

Tu as maintenant vu chaque opérateur qui retourne une valeur unique. Le prochain document - Concaténation et réplication - couvre la syntaxe {} et {N{...}} qui construit des vecteurs plus larges à partir de morceaux, que tu utiliseras constamment en interfaçant des modules de largeurs différentes.