Operadores de Verilog: aritméticos, de comparación, lógicos y condicionales

Qué significa "operador" en Verilog

Los operadores toman expresiones que portan señales y producen nuevas expresiones que portan señales. a + b es hardware - el sintetizador lo convierte en un sumador. a == b es hardware - construye un comparador. Nada de esto es "código que se ejecuta"; todo es "circuitos que el operador describe".

El menú completo de operadores es lo bastante pequeño como para memorizarlo. Este doc cubre los operadores aritméticos, de comparación, lógicos y condicional. Bitwise and Reduction cubre los operadores a nivel de bit que no tienen análogos directos en software.

Aritméticos: + - * / %

module arithmetic;
    initial begin
        $display("17 +  5 = %0d", 17 + 5);
        $display("17 -  5 = %0d", 17 - 5);
        $display("17 *  5 = %0d", 17 * 5);
        $display("17 /  5 = %0d", 17 / 5);   // integer division: 3
        $display("17 %% 5 = %0d", 17 % 5);   // modulo: 2
        $display("-3 *  4 = %0d", -3 * 4);   // works with signed
        $finish;
    end
endmodule

Tres cosas que saber:

1. La división es entera. 7/2 es 3, no 3.5. Verilog no tiene tipo float (bueno, real, pero eso es solo simulación).
2. División y módulo son caros en hardware. Un /4 está bien (el sintetizador lo convierte en un desplazamiento a la derecha), pero un /n para n variable en runtime construye un divisor multi-ciclo que casi nunca quieres.
3. El desbordamiento envuelve. Sumar dos valores sin signo de N bits que exceden N bits trunca a N bits. Si quieres capturar el acarreo, declara el resultado un bit más ancho:

wire [7:0] a, b;
wire [8:0] sum = a + b;   // 9-bit sum captures carry out

Comparación: == != < > <= >=

module comparison;
    initial begin
        $display("5 ==  5 = %b", 5 == 5);
        $display("5 !=  3 = %b", 5 != 3);
        $display("5 <   3 = %b", 5 < 3);
        $display("5 >=  5 = %b", 5 >= 5);

        // Watch out: comparing with x produces x, not 0
        $display("1'bx == 1'b0 = %b", 1'bx == 1'b0);   // x
        $display("1'bx === 1'b0 = %b", 1'bx === 1'b0); // 0

        $finish;
    end
endmodule

Los seis operadores de comparación devuelven un resultado de un solo bit: 1 si verdadero, 0 si falso, x si cualquier operando tiene un bit x o z. Para manejar el caso x/z, recurre a === y !== (los operadores de igualdad case-equality) cubiertos en X and Z Values.

<= aquí es el operador de comparación (menor o igual que). Los mismos caracteres también significan asignación no bloqueante en un bloque procedural (q <= d). El contexto los distingue: dentro de una expresión es una comparación; a la izquierda de un valor que se está asignando, es la asignación. El solapamiento es confuso pero inequívoco para el parser.

Lógicos: && || !

Los operadores lógicos tratan sus operandos como booleanos (cualquier cosa distinta de cero es verdadero, cero es falso) y producen un resultado de un solo bit:

module logical;
    initial begin
        $display("(5 > 3) && (2 < 4) = %b", (5 > 3) && (2 < 4));
        $display("(5 > 3) || (2 > 4) = %b", (5 > 3) || (2 > 4));
        $display("!(5 > 3)           = %b", !(5 > 3));

        // Logical on multi-bit values: anything nonzero is "true"
        $display("4'b1100 && 4'b0011 = %b", 4'b1100 && 4'b0011);   // 1
        $display("4'b1100 || 4'b0000 = %b", 4'b1100 || 4'b0000);   // 1
        $finish;
    end
endmodule

La distinción crucial que interiorizar: && lógico no es & bit a bit.

4'b1100 && 4'b0011   // 1 (both are non-zero, logical AND is true)
4'b1100 &  4'b0011   // 4'b0000 (no bit positions are 1 in both)

Lo mismo para || vs |. Usa lógicos en condiciones if y predicados ?:; usa bit a bit cuando quieras que cada posición de bit haga AND/OR de forma independiente.

&& y || son short-circuit en el sentido de C: el lado derecho no se evalúa si el resultado ya está determinado por el izquierdo. Esto importa para testbenches que comprueban punteros o llamadas a funciones; rara vez importa para RTL sintetizable donde todo sucede en paralelo de todas formas.

El operador condicional: ?:

El ternario es tu mejor amigo para construir muxes y expresiones condicionales:

module muxes;
    wire [3:0] a = 4'hA;
    wire [3:0] b = 4'hB;
    wire sel;

    // 2-to-1 mux:
    wire [3:0] out = sel ? a : b;

    // 4-to-1 mux as a chain of ?:
    reg [1:0] sel4;
    wire [3:0] in0, in1, in2, in3;
    wire [3:0] out4 = (sel4 == 2'd0) ? in0
                    : (sel4 == 2'd1) ? in1
                    : (sel4 == 2'd2) ? in2
                    : in3;

    initial begin
        $display("a=%h b=%h out=%h",  a, b, out);
        $finish;
    end
endmodule

El patrón cond ? a : b es un multiplexor 2 a 1 con selección de 1 bit en hardware. Encadenarlos está bien para selectores de 3 y 4 vías, pero pasado de eso una sentencia case (cubierta en Case Statement) es drásticamente más legible.

El operador ?: también es la forma estándar de dar a un registro un valor por defecto que solo sobrescribes a veces:

next_value = update ? new_data : next_value;

Reglas de ancho: la trampa del principiante

Las reglas de ancho de Verilog para operadores aritméticos son notoriamente sorprendentes. La versión corta:

• El ancho del resultado es el máximo de los anchos de las entradas.
• Si el resultado se asigna a algo más ancho, se hace zero-extend (o sign-extend si tiene signo).
• El ancho de los cálculos intermedios también es el ancho del resultado, lo que significa que el desbordamiento ocurre en el intermedio.

module width_trap;
    reg [7:0]  a, b;
    reg [15:0] product;

    initial begin
        a = 8'd200;
        b = 8'd200;

        // a * b "should" be 40000 (fits in 16 bits)
        // but the multiply happens at 8 bits, overflows, then assigns
        product = a * b;
        $display("8-bit *: product = %0d (expected 40000)", product);

        // Fix: cast one operand to wider before multiplying
        product = {8'b0, a} * b;
        $display("widened: product = %0d", product);

        $finish;
    end
endmodule

La primera multiplicación desborda porque los anchos de los operandos son ambos de 8 bits, el ancho del resultado por tanto es de 8 bits, y 40000 no encaja. La segunda funciona porque ensanchamos a explícitamente antes de multiplicar.

Las técnicas para arreglarlo:

• Usa el operador de concatenación {8'b0, a} para hacer zero-extend.
• Usa $unsigned(a) o $signed(a) para influir en la interpretación.
• Haz cast de las expresiones intermedias a anchos mayores cuando dudes.

Precedencia de operadores

No vas a memorizar la tabla, pero te apoyarás en unas pocas reglas:

• *, /, % enlazan más fuerte que +, -.
• La comparación enlaza más fuerte que los lógicos (&&, ||).
• El operador condicional ?: tiene precedencia muy baja - normalmente necesitas paréntesis alrededor de sus ramas en expresiones más grandes.
• Cuando dudes, pon paréntesis. El simulador no cobra por carácter.

out = (mode == 2'd0) ? a + b : a - b;   // clearer with parens

Qué viene a continuación

Has cubierto cada operador que se parece a su primo del software. El siguiente doc - Bitwise and Reduction - maneja los operadores que no tienen análogos directos en software: AND/OR/XOR bit a bit por bit, además de las formas de reducción que colapsan un vector entero a un solo bit.