Операторы Verilog: арифметика, сравнение, логические и conditional

Что значит "оператор" в Verilog

Операторы берут выражения, несущие сигналы, и производят новые выражения, несущие сигналы. a + b - это железо: синтезатор превращает его в adder. a == b - железо: строит компаратор. Ничто из этого не "код, который выполняется"; всё это "схемы, которые описывает оператор".

Полное меню операторов небольшое, его можно запомнить. Этот документ покрывает арифметику, сравнение, логические и conditional. Bitwise and Reduction разбирает bit-level операторы, у которых нет прямых софтовых аналогов.

Арифметика: + - * / %

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);   // целочисленное деление: 3
        $display("17 %% 5 = %0d", 17 % 5);   // modulo: 2
        $display("-3 *  4 = %0d", -3 * 4);   // работает со знаковыми
        $finish;
    end
endmodule

Три вещи, которые надо знать:

1. Деление целочисленное. 7/2 - это 3, не 3.5. У Verilog нет float-типа (ну, есть real, но он simulation-only).
2. Деление и modulo дороги в железе. /4 - нормально (синтезатор превращает в правый сдвиг), а /n для runtime-переменной n строит многотактовый divider, которого почти никогда не хочется.
3. Переполнение оборачивается. Сложение двух N-битных unsigned-значений, превышающих N бит, обрезается до N бит. Хочешь поймать carry - объяви результат на бит шире:

wire [7:0] a, b;
wire [8:0] sum = a + b;   // 9-битная sum ловит carry out

Сравнение: == != < > <= >=

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);

        // Внимание: сравнение с x даёт x, не 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

Все шесть операторов сравнения возвращают однобитный результат: 1, если истинно, 0, если ложно, x, если у любого операнда есть бит x или z. Чтобы обработать случай x/z, тянись к === и !== (case-equality операторы), разбираем в X and Z Values.

<= тут - оператор сравнения (меньше-или-равно). Те же символы также означают non-blocking присваивание в процедурном блоке (q <= d). Контекст разводит: внутри выражения - сравнение; на левой стороне присваивания - оператор присваивания. Совпадение сбивает с толку, но для парсера однозначно.

Логические: && || !

Логические операторы трактуют операнды как boolean (всё non-zero - true, zero - false) и дают однобитный результат:

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));

        // Логические на многобитных: всё non-zero = "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

Критическое различие, которое стоит усвоить: логическое && - это не побитовое &.

4'b1100 && 4'b0011   // 1 (оба non-zero, логическое AND true)
4'b1100 &  4'b0011   // 4'b0000 (никаких позиций бит, где оба 1)

То же самое с || vs |. Используй логические в условиях if и предикатах ?:; побитовые - когда хочешь, чтобы каждая позиция бита AND/OR-илась независимо.

&& и || short-circuit в смысле C: правая часть не вычисляется, если результат уже определён левой. Это важно для testbench, которые проверяют указатели или вызовы функций; для синтезируемого RTL почти не важно, так как всё всё равно происходит параллельно.

Conditional оператор: ?:

Ternary - твой лучший друг для построения mux и условных выражений:

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 через цепочку ?:
    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

Паттерн cond ? a : b - это 2-to-1 мультиплексор с 1-битным select в железе. Цепочки нормально работают для 3- и 4-сторонних select, но дальше case (разбираем в Case Statement) драматически читаемее.

?: - также стандартный способ дать регистру дефолтное значение, которое перезаписываешь только иногда:

next_value = update ? new_data : next_value;

Правила ширины: засада для новичков

Правила ширины для арифметических операторов Verilog классически удивляют. Кратко:

• Ширина результата - максимум из ширин входов.
• Если результат присваивается чему-то шире - он zero-extend'ится (или sign-extend'ится, если знаковый).
• Ширина промежуточных вычислений - тоже ширина результата, что значит: переполнение происходит в промежуточном.

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

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

        // a * b "должно" быть 40000 (помещается в 16 бит)
        // но умножение происходит на 8 битах, переполняется, потом присваивается
        product = a * b;
        $display("8-bit *: product = %0d (ожидалось 40000)", product);

        // Фикс: расширяем один операнд до умножения
        product = {8'b0, a} * b;
        $display("расширенный: product = %0d", product);

        $finish;
    end
endmodule

Первое умножение переполняется, потому что ширина обоих операндов - 8 бит, ширина результата соответственно 8 бит, а 40000 не помещается. Второе работает, потому что мы явно расширили a перед умножением.

Техники фикса:

• Используй оператор конкатенации {8'b0, a} для zero-extend.
• Используй $unsigned(a) или $signed(a), чтобы повлиять на интерпретацию.
• Кастуй промежуточные выражения в более широкие, если сомневаешься.

Приоритет операторов

Таблицу запоминать не будешь, но опираться на несколько правил - да:

• *, /, % связывают сильнее, чем +, -.
• Сравнение связывает сильнее, чем логические (&&, ||).
• Conditional ?: имеет очень низкий приоритет - обычно нужны скобки вокруг его веток в более крупных выражениях.
• В сомнении - ставь скобки. Симулятор не берёт деньги за символы.

out = (mode == 2'd0) ? a + b : a - b;   // понятнее со скобками

Что дальше

Ты прошёл по каждому оператору, который выглядит как софтовый родственник. Следующий документ - Bitwise and Reduction - разбирает операторы, у которых нет прямых софтовых аналогов: побитовые AND/OR/XOR на каждом бите плюс reduction-формы, схлопывающие весь вектор в один бит.