Verilog bitwise- und Reduktions-Operatoren

Zwei Rollen für dasselbe Symbol

&, |, ^ und ihre invertierten Geschwister tauchen in zwei verschiedenen Formen auf:

• Binäre Form (zwei Operanden): a & b - bitweise Operation zwischen gleich breiten Vektoren.
• Unäre Form (ein Operand): &a - Reduktion über alle Bits von a zu einem einzelnen Bit.

Der Compiler unterscheidet sie durch Zählen der Operanden. Die Namenskonvention: "die bitwise-Operatoren" für die binäre Form und "die Reduktions-Operatoren" für die unäre Form.

Bitwise: Ein Bit nach dem anderen

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);   // bitweises AND
        $display("a | b = %b", a | b);   // bitweises OR
        $display("a ^ b = %b", a ^ b);   // bitweises XOR
        $display("~a    = %b", ~a);      // bitweises NOT (ein Operand)
        $display("a ~^ b = %b", a ~^ b); // bitweises XNOR
        $finish;
    end
endmodule

Der volle Satz:

Operator	Name	Ergebnisbit an 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]

Beachte: ~&, ~|, ~^ werden mit Tilde zuerst und Operator danach geschrieben. Sie sind ein einzelnes Token; dazwischen darf kein Leerzeichen sein.

Sind die beiden Operanden unterschiedlich breit, wird der schmalere links mit Nullen erweitert. Willst du Vorzeichen-Erweiterung, nutze explizit signed-Operanden mit $signed().

Reduktion: Von vielen Bits zu einem

Die unären Formen derselben Operatoren kollabieren einen Vektor auf ein einzelnes 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

Was die einzelnen bedeuten:

• &data liefert 1, wenn alle Bits von data 1 sind, sonst 0. Nützlich für "ist das nur Einsen?"-Checks.
• |data liefert 1, wenn irgendein Bit von data 1 ist, sonst 0. Nützlich für "ist das ungleich Null?"-Checks.
• ^data liefert die Parität - XOR aller Bits. 1, wenn ungerade Anzahl Einsen, 0, wenn gerade.
• ~&data, ~|data, ~^data sind die Inversen der obigen.

Du siehst sie überall in echtem Code:

wire empty       = ~|fifo_count;       // leer gdw count Null ist
wire all_ones    = &mask;              // alle Bits gesetzt
wire parity_bit  = ^data;              // Parität eines Bytes
wire any_request = |request_vector;    // gibt es irgendeine Anfrage?

Die Reduktionsformen sind knapp und synthetisieren zu offensichtlichen Gatter-Bäumen: & reduziert auf ein Multi-Input-AND-Gatter, | auf ein Multi-Input-OR, ^ auf einen XOR-Baum (was in Hardware auch der Paritätsgenerator ist).

Übliche Muster

Bits setzen und löschen

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

wire [7:0] set     = data | mask;     // erzwingt Bit 3 auf 1
wire [7:0] cleared = data & ~mask;    // erzwingt Bit 3 auf 0
wire [7:0] toggled = data ^ mask;     // dreht Bit 3 um
wire [7:0] tested  = data & mask;     // Null, wenn Bit 3 war 0, sonst ungleich Null

Das sind dieselben Bit-Manipulations-Idiome wie in C. Sie synthetisieren zu Operationen mit einem Gatter.

Prüfen, ob ein Wert nur aus Einsen besteht

wire is_max = &counter;       // 1, wenn jedes Bit von counter 1 ist

Ein Reduktions-AND mit einem Gatter, verglichen mit counter == 8'hFF (was ebenfalls funktioniert; Synthesizer erzeugen meist identische Hardware).

Ein Paritätsbit erzeugen

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // gerade Paritätsbit
    wire       odd_parity = ~^data;     // ungerade Paritätsbit

    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

Erkennen, ob irgendein aktives Signal vorliegt

wire any_pending = |request_vector;

Ist request_vector breit (etwa 64 Anfrager), kollabiert das Reduktions-OR es zu einem einzelnen Signal, das du in einen Priority Encoder oder Arbiter füttern kannst.

Shift-Operatoren

Während wir bei Bit-Operatoren sind, die Shifts:

• a << N schiebt a um N Bitpositionen nach links und füllt rechts mit Nullen.
• a >> N schiebt a um N Bitpositionen nach rechts und füllt links mit Nullen.
• a <<< N arithmetischer Linksshift (wie << für Unsigned).
• a >>> N arithmetischer Rechtsshift - füllt mit dem Vorzeichenbit, wenn a signed ist.

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

        // Arithmetischer Rechtsshift auf signed Wert erhält Vorzeichen:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Shifts um eine konstante Zweierpotenz sind in Hardware kostenlos (nur Umverdrahtung). Shifts um eine Laufzeit-Variable erzeugen einen Barrel-Shifter, der größer, aber immer noch günstig ist.

Wie es weitergeht

Du hast jetzt jeden Operator gesehen, der einen Einzelwert liefert. Das nächste Doc - Konkatenation und Replikation - behandelt die {}- und {N{...}}-Syntax, die breitere Vektoren aus Teilen baut und die du ständig brauchst, wenn du Module unterschiedlicher Breite verbindest.