Operadores Bitwise e Reduction em Verilog

Dois papéis para o mesmo símbolo

&, |, ^ e seus parentes invertidos aparecem em duas formas distintas:

• Forma binária (dois operandos): a & b - operação bitwise entre vetores de mesma largura.
• Forma unária (um operando): &a - reduction através de todos os bits de a em um único bit.

O compilador as distingue contando operandos. A convenção de nomes que as pessoas usam é "os operadores bitwise" para a forma binária e "os operadores de reduction" para a forma unária.

Bitwise: Um bit por 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 (um operando)
        $display("a ~^ b = %b", a ~^ b); // bitwise XNOR
        $finish;
    end
endmodule

O conjunto completo:

Operador	Nome	Bit de saída na posição 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ão escritos com o til primeiro e o operador depois. São um único token; não há espaço entre eles.

Quando os dois operandos têm larguras diferentes, o mais estreito é zero-extended à esquerda para combinar. Se você quer sign-extension, use operandos signed explicitamente com $signed().

Reduction: De muitos bits para um

As formas unárias dos mesmos operadores colapsam um vetor em um único 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

O que cada um significa:

• &data retorna 1 se todos os bits de data são 1, caso contrário 0. Útil para checks "isso é só 1s?".
• |data retorna 1 se qualquer bit de data é 1, caso contrário 0. Útil para checks "isso é não-zero?".
• ^data retorna a paridade - XOR de todos os bits. 1 se contagem ímpar de 1s, 0 se par.
• ~&data, ~|data, ~^data são os inversos dos acima.

Você verá essas formas em todo lugar em código real:

wire empty       = ~|fifo_count;       // empty se e somente se count e zero
wire all_ones    = &mask;              // todos os bits setados
wire parity_bit  = ^data;              // paridade de um byte
wire any_request = |request_vector;    // alguma coisa requisitada?

As formas de reduction são concisas e sintetizam em árvores de gates óbvias: & reduz para um gate AND multi-entrada, | para um OR multi-entrada, ^ para uma árvore XOR (que também é o gerador de paridade em hardware).

Padrões comuns

Setando e limpando bits

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

wire [7:0] set     = data | mask;     // forca bit 3 para 1
wire [7:0] cleared = data & ~mask;    // forca bit 3 para 0
wire [7:0] toggled = data ^ mask;     // inverte bit 3
wire [7:0] tested  = data & mask;     // zero se bit 3 era 0, nao-zero caso contrario

São os mesmos idiomas de manipulação de bit que você usaria em C. Sintetizam para operações de um único gate.

Verificando se um valor é igual a todos 1s

wire is_max = &counter;       // 1 se cada bit de counter e 1

Um AND de reduction com um gate, vs escrever counter == 8'hFF (que também funcionaria; sintetizadores geralmente produzem hardware idêntico).

Gerando um bit de paridade

module parity_demo;
    reg  [7:0] data;
    wire       parity = ^data;          // bit de paridade par
    wire       odd_parity = ~^data;     // bit de paridade 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

Detectando qualquer sinal ativo

wire any_pending = |request_vector;

Se request_vector é largo (digamos 64 requisitantes), o OR de reduction colapsa em um único sinal que você pode alimentar em um encoder de prioridade ou árbitro.

Operadores de shift

Já que estamos em operadores em nível de bit, os shifts:

• a << N faz shift de a para a esquerda em N posições de bit, preenchendo com zeros à direita.
• a >> N faz shift de a para a direita em N posições de bit, preenchendo com zeros à esquerda.
• a <<< N shift aritmético à esquerda (mesmo que << para unsigned).
• a >>> N shift aritmético à direita - preenche com o sign bit quando a é signed.

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 aritmetico a direita em valor signed preserva sinal:
        $display("8'sb1100_0000 >>> 2 = %b", $signed(8'sb1100_0000) >>> 2);
        $finish;
    end
endmodule

Shifts por uma potência constante são grátis em hardware (só refiação). Shifts por uma variável de runtime produzem um barrel shifter, que é maior mas ainda barato.

O que vem a seguir

Você agora viu todo operador que retorna um único valor. O próximo doc - Concatenation and Replication - cobre a sintaxe {} e {N{...}} que constrói vetores mais largos a partir de pedaços, que você vai usar constantemente ao fazer interface entre modules de diferentes larguras.