Operator Precedence

module tb_prec_bitwise;
 
logic [7:0] data = 8'hA5;   // 1010_0101
 
initial begin
 
// BUGGY: engineer wants to check if upper nibble == 0xA
// Written: data & 8'hF0 == 8'hA0
// Parsed:  data & (8'hF0 == 8'hA0) = data & 0 = 8'h00
$display("BUGGY:   data & 8'hF0 == 8'hA0  = %0h",
data & 8'hF0 == 8'hA0);   // 0 — wrong!
 
// CORRECT: parentheses around the mask operation
$display("CORRECT: (data & 8'hF0) == 8'hA0 = %0b",
(data & 8'hF0) == 8'hA0); // 1 — upper nibble is A
 
// Verify the difference visually
$display("8'hF0 == 8'hA0       = %0b", 8'hF0 == 8'hA0);  // 0
$display("data & 0            = %0h",  data & 1'b0);     // 0
$display("data & 8'hF0         = %0h",  data & 8'hF0);   // A0
 
$finish;
end
 
endmodule

BUGGY:   data & 8'hF0 == 8'hA0  = 0
CORRECT: (data & 8'hF0) == 8'hA0 = 1
8'hF0 == 8'hA0       = 0
data & 0            = 0
data & 8'hF0         = A0

module tb_prec_conditional;
 
logic       sel = 1'b1;
logic [7:0] a   = 8'd5;
logic [7:0] b   = 8'd3;
logic [7:0] c   = 8'd10;
logic [7:0] result;
 
initial begin
 
// BUGGY intent: add c to whichever of a or b is selected
// Written:  sel ? a : b + c
// Parsed:   sel ? a : (b + c)  — + has higher precedence than ?:
result = sel ? a : b + c;
$display("BUGGY  sel?a:b+c   = %0d  (parsed as sel?a:(b+c))", result);  // 5
 
// CORRECT: parentheses enforce ternary-first
result = (sel ? a : b) + c;
$display("CORRECT (sel?a:b)+c = %0d", result);   // 15 (5 + 10)
 
// Same trap with sel=0
sel = 1'b0;
result = sel ? a : b + c;     // = 3 + 10 = 13 (b+c)
$display("sel=0: sel?a:b+c   = %0d", result);   // 13
result = (sel ? a : b) + c;   // = 3 + 10 = 13 (same — different path, same result)
$display("sel=0: (sel?a:b)+c  = %0d", result);   // 13
// Bug is only visible when sel=1 — classic intermittent bug!
 
$finish;
end
 
endmodule

BUGGY  sel?a:b+c   = 5  (parsed as sel?a:(b+c))
CORRECT (sel?a:b)+c = 15
sel=0: sel?a:b+c   = 13
sel=0: (sel?a:b)+c  = 13

module tb_prec_unary;
 
logic [3:0] data = 4'hA;   // 1010
 
initial begin
 
// Trap: ~&data vs ~(&data)
$display("&data        = %0b",  &data);       // 0  — AND reduction: 1010
$display("~(&data)     = %0b",  ~(&data));     // 1  — negate the AND result
$display("~&data       = %0b",  ~&data);       // 1  — NAND reduction: same as ~(&data)
// ~& is a single NAND reduction operator, not ~ followed by & reduction
 
// The dangerous one: !&data
$display("!&data       = %0b",  !&data);       // 1  — logical not of AND reduction
$display("!data        = %0b",  !data);        // 0  — logical not of 4-bit data (non-zero → 0)
// !&data parsed as !(&data) = !(0) = 1
// Very different from !(data) = !(8'hA) = 0
 
// Right-associativity of unary operators
$display("~~data       = %04b", ~~data);       // 1010 — double invert = original
$display("!!data       = %0b",  !!data);       // 1  — !(!(non-zero)) = !(0) = 1
 
$finish;
end
 
endmodule

module tb_precedence_all;
 
logic [7:0] a = 8'hAA;   // 1010_1010
logic [7:0] b = 8'h55;   // 0101_0101
logic       s = 1'b1;
logic [7:0] r;
 
initial begin
 
// ── Arithmetic before shift ───────────────────────────────────
r = 8'd2 + 8'd3 << 1;     // (2+3)<<1 = 5<<1 = 10
$display("2+3<<1       = %0d  (expect 10)", r);
 
// ── Equality above bitwise AND ─────────────────────────────────
r = a & b == 8'h00;        // a & (b==0) = AA & 0 = 0
$display("a&b==0        = %0h  (expect 0, NOT 1)", r);
r = (a & b) == 8'h00;      // (AA&55)=00, 00==00 → 1
$display("(a&b)==0      = %0b  (expect 1)", r);
 
// ── Bitwise OR below logical AND ──────────────────────────────
r = a | b && 1'b0;          // a | (b && 0) = AA | 0 = AA
$display("a|b&&0        = %0h  (expect AA)", r);
r = (a | b) && 1'b0;        // (FF) && 0 = 0
$display("(a|b)&&0      = %0b  (expect 0)", r);
 
// ── Conditional: ? : is right-associative ────────────────────
// a ? b ? c : d : e  =  a ? (b ? c : d) : e
logic [7:0] x = 8'h01, y = 8'h02, z = 8'h03;
r = s ? s ? x : y : z;     // s=1: s?(s?x:y):z = 1?(1?x:y):z = x = 0x01
$display("s?s?x:y:z     = %0h  (expect 01)", r);
 
// ── Exponentiation is right-associative ───────────────────────
r = 2 ** 3;                 // 2**3 = 8
$display("2**3          = %0d  (expect 8)", r);
 
$finish;
end
 
endmodule

logic [7:0] data  = 8'hA5;
logic [7:0] mask  = 8'hF0;
logic [7:0] exp   = 8'hA0;
logic        flag  = 1'b1;
logic        valid = 1'b1;
logic [7:0] sel_a = 8'h10;
logic [7:0] sel_b = 8'h20;
logic [7:0] offset = 8'h05;
logic [7:0] result;
 
// ── BUG 1: Bitwise mask check ──────────────────────────────────────
if (data & mask == exp)                // BUGGY: data & (mask==exp) = data & 0 = 0
$display("upper nibble is A");         // never fires
if ((data & mask) == exp)              // CORRECT
$display("upper nibble is A");         // fires
 
// ── BUG 2: Flag guard combined with bitwise ────────────────────────
if (valid & data == 8'hA5)             // BUGGY: valid & (data==A5) = 1 & 1 = 1'b1 ← width 1!
$display("guarded check");             // fires by accident — valid & 1-bit result
if (valid && (data == 8'hA5))          // CORRECT: use logical &&
$display("guarded check");             // fires correctly
 
// ── BUG 3: Ternary with offset ────────────────────────────────────
result = valid ? sel_a : sel_b + offset;   // BUGGY: valid ? sel_a : (sel_b+offset)
// valid=1: result = sel_a = 0x10 — offset never added!
result = (valid ? sel_a : sel_b) + offset; // CORRECT: 0x10 + 0x05 = 0x15
 
// ── BUG 4: NOT of comparison result ───────────────────────────────
if (!data == 8'h00)                    // BUGGY: (!data) == 8'h00 = 0 == 0 = 1 always!
$display("data is zero");              // fires even when data=0xA5
if (!(data == 8'h00))                  // CORRECT: negate the equality result
$display("data is non-zero");          // fires when data != 0
// !data = logical not = 1'b0 when data is non-zero; then 0 == 8'h00 → always 1
 
// ── BUG 5: Shift in constraint arithmetic ─────────────────────────
logic [7:0] base = 8'd4;
result = base + 2 << 3;               // BUGGY intent: base + (2<<3) = 4+16 = 20
// Parsed: (base + 2) << 3 = 6 << 3 = 48
result = base + (2 << 3);             // CORRECT: 4 + 16 = 20