Operadores bit a bit y de reducción en Verilog

Dos roles para el mismo símbolo

&, |, ^ y sus hermanos invertidos aparecen en dos formas distintas:

• Forma binaria (dos operandos): a & b - operación bit a bit entre vectores del mismo ancho.
• Forma unaria (un operando): &a - reducción de todos los bits de a a un solo bit.

El compilador los distingue contando los operandos. La convención de nombres que usa la gente es "los operadores bit a bit" para la forma binaria y "los operadores de reducción" para la forma unaria.

Bit a bit: un bit cada vez

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 (one operand)
        $display("a ~^ b = %b", a ~^ b); // bitwise XNOR
        $finish;
    end
endmodule

El conjunto completo:

Operador	Nombre	Bit de salida en la posición 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]

Ten en cuenta que ~&, ~|, ~^ se escriben con la tilde primero y el operador después. Son un único token; no hay espacio en medio.

Cuando los dos operandos tienen anchos distintos, el más estrecho se extiende con ceros a la izquierda para igualar. Si quieres extensión de signo, usa operandos con signo explícitamente con $signed().

Reducción: de muchos bits a uno

Las formas unarias de los mismos operadores colapsan un vector a un solo 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

Qué significa cada uno:

• &data devuelve 1 si todos los bits de data son 1, si no 0. Útil para chequeos del tipo "¿es todo unos?".
• |data devuelve 1 si cualquier bit de data es 1, si no 0. Útil para chequeos del tipo "¿es distinto de cero?".
• ^data devuelve la paridad - XOR de todos los bits. 1 si hay un número impar de unos, 0 si es par.
• ~&data, ~|data, ~^data son los inversos de los anteriores.

Los verás por todas partes en código real:

wire empty       = ~|fifo_count;       // empty solo si count es cero
wire all_ones    = &mask;              // todos los bits a 1
wire parity_bit  = ^data;              // paridad de un byte
wire any_request = |request_vector;    // ¿hay algo solicitado?

Las formas de reducción son concisas y sintetizan a árboles de puertas obvios: & se reduce a una puerta AND de varias entradas, | a un OR de varias entradas, ^ a un árbol XOR (que es también el generador de paridad en hardware).

Patrones comunes

Poner y limpiar bits

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

wire [7:0] set     = data | mask;     // fuerza el bit 3 a 1
wire [7:0] cleared = data & ~mask;    // fuerza el bit 3 a 0
wire [7:0] toggled = data ^ mask;     // invierte el bit 3
wire [7:0] tested  = data & mask;     // cero si el bit 3 era 0, distinto de cero si no

Estos son los mismos modismos de manipulación de bits que usarías en C. Sintetizan a operaciones de una sola puerta.

Comprobar si un valor es igual a todo unos

wire is_max = &counter;       // 1 si cada bit de counter es 1

Un AND de reducción con una puerta, frente a escribir counter == 8'hFF (que también funcionaría; los sintetizadores normalmente producen hardware idéntico).

Generar un bit de paridad

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // bit de paridad par
    wire       odd_parity = ~^data;     // bit de paridad impar

    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

Detectar cualquier señal activa

wire any_pending = |request_vector;

Si request_vector es ancho (digamos 64 solicitantes), el OR de reducción colapsa a una única señal que puedes meter en un codificador de prioridad o un árbitro.

Operadores de desplazamiento

Ya que estamos con operadores a nivel de bit, los desplazamientos:

• a << N desplaza a N posiciones a la izquierda, rellenando con ceros por la derecha.
• a >> N desplaza a N posiciones a la derecha, rellenando con ceros por la izquierda.
• a <<< N desplazamiento aritmético a la izquierda (igual que << para sin signo).
• a >>> N desplazamiento aritmético a la derecha - rellena con el bit de signo cuando a tiene signo.

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

        // Arithmetic right shift on signed value preserves sign:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Los desplazamientos por una constante son gratis en hardware (solo recableado). Los desplazamientos por una variable en runtime producen un barrel shifter, que es más grande pero sigue siendo barato.

Qué viene a continuación

Ya has visto cada operador que devuelve un único valor. El siguiente doc - Concatenation and Replication - cubre la sintaxis {} y {N{...}} que construye vectores más anchos a partir de piezas, que usarás constantemente cuando conectes módulos de diferentes anchos.