Field Macros — `uvm_field_*

typedef enum bit { WRITE=0, READ=1 } dir_e;
 
class apb_txn extends uvm_sequence_item;
 
    // ── Field declarations ────────────────────────────────────────────
    rand bit [31:0]   addr;
    rand bit [31:0]   data;
    rand    dir_e     direction;
    rand bit [3:0]    strobe;    // byte enables
    bit     [1:0]    resp;      // not randomised
    string             tag;       // debug label
    bit     [7:0]    data_q[$]; // payload queue
 
    // ── Factory registration with field automation ────────────────────
    `uvm_object_utils_begin(apb_txn)
        `uvm_field_int   (addr,      UVM_ALL_ON)
        `uvm_field_int   (data,      UVM_ALL_ON)
        `uvm_field_enum  (dir_e, direction, UVM_ALL_ON)
        `uvm_field_int   (strobe,    UVM_ALL_ON)
        `uvm_field_int   (resp,      UVM_NOCOMPARE | UVM_PRINT)
        `uvm_field_string(tag,       UVM_NOCOMPARE | UVM_PRINT)
        `uvm_field_queue_int(data_q, UVM_ALL_ON)
    `uvm_object_utils_end
 
    function new(string name = "apb_txn");
        super.new(name);
    endfunction
 
    constraint c_valid_addr { addr[1:0] == 2'b00; }  // word-aligned
 
endclass
 
// ── What you get for free — all without writing any of these manually:
apb_txn a = apb_txn::type_id::create("a");
apb_txn b = apb_txn::type_id::create("b");
void'(a.randomize());
a.print();                    // formatted table via do_print
b.copy(a);                    // deep copy via do_copy
`uvm_info("T", $sformatf("%0d", a.compare(b)), UVM_LOW)  // 1 = match
bit [7:0] packed[$];
void'(a.pack_bytes(packed));   // serialize to bytes
b.unpack_bytes(packed);        // deserialize back

`uvm_object_utils_begin(my_txn)
 
    // ── Payload fields: copy, compare, pack, print ────────────────────
    `uvm_field_int(addr,      UVM_ALL_ON | UVM_HEX)   // print as 0x...
    `uvm_field_int(data,      UVM_ALL_ON | UVM_HEX)
    `uvm_field_int(strobe,    UVM_ALL_ON | UVM_BIN)   // print as 0b...
 
    // ── Control field: all ops but show as decimal ────────────────────
    `uvm_field_int(burst_len, UVM_ALL_ON | UVM_DEC)
 
    // ── Response field: do not compare, do not pack — just print ─────
    `uvm_field_int(resp,      UVM_NOCOMPARE | UVM_NOPACK | UVM_PRINT | UVM_COPY)
 
    // ── Debug tag: print only — never affects compare or copy ─────────
    `uvm_field_string(debug_tag, UVM_READONLY)
 
    // ── Timestamp: print only, not compared, not packed ───────────────
    `uvm_field_int(timestamp, UVM_READONLY)
 
    // ── Sub-object: include in copy+compare, exclude from pack ────────
    `uvm_field_object(header_pkt, UVM_ALL_ON | UVM_NOPACK)
 
    // ── Queue: all operations ─────────────────────────────────────────
    `uvm_field_queue_int(payload_bytes, UVM_ALL_ON)
 
    // ── Enum: remember the type comes first ───────────────────────────
    `uvm_field_enum(opcode_t, opcode, UVM_ALL_ON)
 
`uvm_object_utils_end

// `uvm_field_int(addr, UVM_ALL_ON) expands to contributions inside each
// of the automation framework methods. Simplified equivalent:
 
// Contribution to do_copy:
function void do_copy(uvm_object rhs);
    apb_txn rhs_;
    $cast(rhs_, rhs);
    super.do_copy(rhs);
    this.addr = rhs_.addr;   // ← addr field contribution
    // ... data, direction, strobe ...
endfunction
 
// Contribution to do_compare:
function bit do_compare(uvm_object rhs, uvm_comparer comparer);
    apb_txn rhs_;
    $cast(rhs_, rhs);
    return super.do_compare(rhs, comparer) &&
           comparer.compare_field("addr", this.addr, rhs_.addr, $bits(addr));
endfunction
 
// Contribution to do_print:
function void do_print(uvm_printer printer);
    super.do_print(printer);
    printer.print_field("addr", this.addr, $bits(addr), UVM_HEX);
endfunction
 
// Contribution to do_pack/do_unpack:
function void do_pack(uvm_packer packer);
    super.do_pack(packer);
    packer.pack_field(this.addr, $bits(addr));
endfunction
 
function void do_unpack(uvm_packer packer);
    super.do_unpack(packer);
    this.addr = packer.unpack_field_int($bits(addr));
endfunction
 
// The actual macro expansion uses a dispatch table with virtual methods —
// it goes through uvm_field_automation() which adds runtime dispatch overhead.
// This is why field macros are slower than direct do_* implementations.

class apb_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(apb_txn)
        `uvm_field_int(addr, UVM_ALL_ON)
        `uvm_field_int(data, UVM_ALL_ON)
    `uvm_object_utils_end
 
    rand bit [31:0] addr, data;
    function new(string n="apb_txn"); super.new(n); endfunction
endclass
 
// What you give up:
//   1. Generic, introspective comparison on every compare/copy call
//   2. No sub-range comparison — cannot compare addr[15:0] only
//   3. No conditional logic — cannot skip a field based on ignore_mask
//   4. Display formatting is whatever the flag selects
//   5. Packed structs and unions need workarounds

class apb_txn extends uvm_sequence_item;
    `uvm_object_utils(apb_txn)
 
    rand bit [31:0] addr, data;
    bit [31:0]      addr_mask = 32'hFFFF_FFFF;
 
    function new(string n="apb_txn"); super.new(n); endfunction
 
    function void do_copy(uvm_object rhs);
        apb_txn r;
        if (!$cast(r, rhs)) `uvm_fatal("COPY", "type mismatch in do_copy")
        super.do_copy(rhs);
        addr = r.addr;
        data = r.data;
    endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        apb_txn r;
        bit ok = 1;
        if (!$cast(r, rhs)) `uvm_fatal("CMP", "type mismatch in do_compare")
        ok &= super.do_compare(rhs, comparer);
        // The point of going manual: compare only the masked address bits.
        ok &= comparer.compare_field("addr", addr & addr_mask,
                                     r.addr & r.addr_mask, 32);
        ok &= comparer.compare_field("data", data, r.data, 32);
        return ok;
    endfunction
endclass

// field_macros_demo.sv — complete ready-to-run UVM field macro demonstration
//
// Compile and run:
//   Questa : vlog -sv field_macros_demo.sv &&
//            vsim -c field_macros_top -do "run -all; quit"
//   VCS    : vcs -sverilog -ntb_opts uvm field_macros_demo.sv && ./simv
//   Xcelium: xrun -sv -uvm field_macros_demo.sv -input "run; exit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ═══════════════════════════════════════════════════════════════════════
//  ENUM TYPE (must be defined outside the class)
// ═══════════════════════════════════════════════════════════════════════
typedef enum bit { APB_WRITE=0, APB_READ=1 } apb_dir_e;
 
// ═══════════════════════════════════════════════════════════════════════
//  TRANSACTION WITH FIELD MACROS
// ═══════════════════════════════════════════════════════════════════════
class apb_txn extends uvm_sequence_item;
 
    rand bit [31:0] addr;
    rand bit [31:0] data;
    rand    apb_dir_e direction;
    rand bit [3:0]  strobe;
    bit     [1:0]  pslverr;     // response — excluded from compare
    string           debug_tag;   // label — excluded from compare
    bit     [7:0]  payload[$];  // byte queue
    time             issue_time;  // readonly — print only
 
    `uvm_object_utils_begin(apb_txn)
        `uvm_field_int      (addr,      UVM_ALL_ON | UVM_HEX)
        `uvm_field_int      (data,      UVM_ALL_ON | UVM_HEX)
        `uvm_field_enum     (apb_dir_e, direction, UVM_ALL_ON)
        `uvm_field_int      (strobe,    UVM_ALL_ON | UVM_BIN)
        `uvm_field_int      (pslverr,   UVM_NOCOMPARE | UVM_PRINT | UVM_COPY)
        `uvm_field_string   (debug_tag, UVM_NOCOMPARE | UVM_PRINT)
        `uvm_field_queue_int(payload,   UVM_ALL_ON)
        `uvm_field_int      (issue_time,UVM_READONLY)
    `uvm_object_utils_end
 
    function new(string name = "apb_txn");
        super.new(name);
    endfunction
 
    constraint c_align  { addr[1:0] == 2'b00; }
    constraint c_strobe { strobe != 4'h0; }
 
endclass
 
// ═══════════════════════════════════════════════════════════════════════
//  TEST — exercises all field macro capabilities
// ═══════════════════════════════════════════════════════════════════════
class field_macro_test extends uvm_test;
    `uvm_component_utils(field_macro_test)
 
    function new(string name, uvm_component parent);
        super.new(name, parent);
    endfunction
 
    task run_phase(uvm_phase phase);
        apb_txn a, b, c;
        bit [7:0] packed_bytes[$];
        phase.raise_objection(this);
 
        // ── Create and randomize ──────────────────────────────────────
        a = apb_txn::type_id::create("txn_a");
        void'(a.randomize() with { addr == 32'hA000_0000; direction == APB_WRITE; });
        a.data      = 32'h1234_5678;
        a.pslverr   = 2'b00;
        a.debug_tag = "test_write_1";
        a.issue_time = $time;
        a.payload   = { 8'h12, 8'h34, 8'h56, 8'h78 };
 
        // ── print(): shows formatted table ────────────────────────────
        `uvm_info("TEST", "=== print() output ===", UVM_NONE)
        a.print();
 
        // ── clone(): deep copy ────────────────────────────────────────
        $cast(b, a.clone());
        b.set_name("txn_b_clone");
        `uvm_info("TEST", "=== compare() after clone — must be 1 ===", UVM_NONE)
        `uvm_info("TEST", $sformatf("a.compare(b) = %0d", a.compare(b)), UVM_NONE)
 
        // ── Modify and compare — should show mismatch ─────────────────
        b.data = 32'hFFFF_0000;
        `uvm_info("TEST", "=== compare() after data change — must be 0 ===", UVM_NONE)
        `uvm_info("TEST", $sformatf("a.compare(b) = %0d", a.compare(b)), UVM_NONE)
 
        // ── pslverr is NOCOMPARE — change it, compare still passes ────
        $cast(c, a.clone());
        c.pslverr = 2'b11;  // error response
        `uvm_info("TEST", "=== compare() with different pslverr — must be 1 (NOCOMPARE) ===", UVM_NONE)
        `uvm_info("TEST", $sformatf("a.compare(c) = %0d", a.compare(c)), UVM_NONE)
 
        // ── pack_bytes(): serialize to byte array ─────────────────────
        void'(a.pack_bytes(packed_bytes));
        `uvm_info("TEST",
            $sformatf("pack_bytes() produced %0d bytes", packed_bytes.size()),
            UVM_NONE)
 
        // ── unpack_bytes(): deserialize back ──────────────────────────
        b.data = 0; b.addr = 0;
        void'(b.unpack_bytes(packed_bytes));
        `uvm_info("TEST",
            $sformatf("After unpack: addr=0x%0h data=0x%0h", b.addr, b.data),
            UVM_NONE)
 
        // ── sprint(): get the print as a string ───────────────────────
        `uvm_info("TEST", "=== sprint() into string ===", UVM_NONE)
        `uvm_info("TEST", a.sprint(), UVM_NONE)
 
        `uvm_info("TEST", "=== All field macro tests passed ===", UVM_NONE)
        phase.drop_objection(this);
    endtask
endclass
 
// ═══════════════════════════════════════════════════════════════════════
//  TOP MODULE
// ═══════════════════════════════════════════════════════════════════════
module field_macros_top;
    initial run_test("field_macro_test");
endmodule
 
// ═══════════════════════════════════════════════════════════════════════
//  EXPECTED OUTPUT (abridged):
//
//  TEST: === print() output ===
//  -----------------------------------------------
//  Name            Type        Size  Value
//  -----------------------------------------------
//  txn_a           apb_txn     -     @1
//    addr          integral    32    'ha0000000
//    data          integral    32    'h12345678
//    direction     apb_dir_e   1     APB_WRITE
//    strobe        integral    4     'b1111
//    pslverr       integral    2     'h0
//    debug_tag     string      12    test_write_1
//    payload       da(integral) 4    ...
//    issue_time    integral    64    'h0      (readonly)
//  -----------------------------------------------
//
//  TEST: compare() after clone — must be 1
//  TEST: a.compare(b) = 1
//
//  TEST: compare() after data change — must be 0
//  TEST: a.compare(b) = 0
//
//  TEST: compare() with different pslverr — must be 1 (NOCOMPARE)
//  TEST: a.compare(c) = 1
//
//  TEST: pack_bytes() produced N bytes
//  TEST: After unpack: addr=0xa0000000 data=0x12345678
//  TEST: === All field macro tests passed ===
// ═══════════════════════════════════════════════════════════════════════

## ── Questa ────────────────────────────────────────────────────────────
vlog -sv -timescale 1ns/1ps field_macros_demo.sv
vsim -c field_macros_top +UVM_VERBOSITY=UVM_NONE \
     -do "run -all; quit -f"
 
## ── VCS ───────────────────────────────────────────────────────────────
vcs -sverilog -ntb_opts uvm -timescale=1ns/1ps field_macros_demo.sv -o simv
./simv +UVM_TESTNAME=field_macro_test +UVM_VERBOSITY=UVM_NONE
 
## ── Xcelium ───────────────────────────────────────────────────────────
xrun -sv -uvm -timescale 1ns/1ps field_macros_demo.sv \
     -input "run; exit" \
     +UVM_TESTNAME=field_macro_test +UVM_VERBOSITY=UVM_NONE
 
## ── To see UVM report summary:
##    Remove +UVM_VERBOSITY=UVM_NONE from any command above

class apb_seq_item extends uvm_sequence_item;
    `uvm_object_utils_begin(apb_seq_item)
        `uvm_field_int(addr,  UVM_DEFAULT)
        `uvm_field_int(data,  UVM_DEFAULT)
        `uvm_field_int(write, UVM_DEFAULT)
    `uvm_object_utils_end
 
    rand logic [31:0] addr;
    rand logic [31:0] data;
    rand logic        write;
    function new(string name="apb_seq_item"); super.new(name); endfunction
endclass
 
// ── What each generated method produces ──────────────────────────────
//
// txn.print():
//   --------------------------------------------------------
//   Name        Type    Size  Value
//   --------------------------------------------------------
//   apb_seq_item  object   -
//     addr        integral  32    'h4000
//     data        integral  32    'hA5A5
//     write       integral  1     'h1
//
// txn.convert2string():
//   "addr='h4000 data='ha5a5 write='h1"
//
// txn1.compare(txn2):
//   Returns 1 if all three fields match, 0 otherwise.
//   Prints mismatch detail if +UVM_REPORT_VERBOSITY=UVM_HIGH
//
// txn_copy = txn.clone(): deep copy of all three fields (new object)
//
// txn.pack_ints(arr):
//   Packs addr[31:0] + data[31:0] + write[0] = 65 bits into integer array
 
// ── Scoreboard compare using auto-generated compare() ────────────────
function void write(apb_seq_item actual);
    apb_seq_item expected;
    // ... get expected ...
    if (!actual.compare(expected)) begin
        `uvm_error("SCB", $sformatf("Mismatch:\n  actual: %s\n  expected: %s",
            actual.convert2string(), expected.convert2string()))
    end
endfunction

// UVM_DEFAULT = UVM_ALL_ON = 0x01FF
// Deconstructed: COPY | COMPARE | PRINT | RECORD | PACK | UNPACK | NORADIX
//
// Selectively disable specific operations per field:
 
class packet extends uvm_sequence_item;
    `uvm_object_utils_begin(packet)
        // addr: full default — compare, print, copy, pack all enabled
        `uvm_field_int(addr, UVM_DEFAULT)
 
        // data: compared and printed, but EXCLUDED from pack/unpack
        `uvm_field_int(data, UVM_DEFAULT | UVM_NOPACK)
 
        // timestamp: printed (for debugging) but NOT compared
        // Timestamps differ between expected and actual — compare must skip it
        `uvm_field_int(timestamp, UVM_DEFAULT | UVM_NOCOMPARE)
 
        // debug_tag: internal debug only — never printed in clean regression logs
        `uvm_field_int(debug_tag, UVM_COPY | UVM_COMPARE)
        // UVM_COPY | UVM_COMPARE: copy and compare but don't print
 
        // status: excluded from comparison entirely (DUT-side, cannot predict)
        `uvm_field_int(status, UVM_DEFAULT | UVM_NOCOMPARE)
    `uvm_object_utils_end
 
    rand logic [31:0] addr;
    rand logic [31:0] data;
    logic       [63:0] timestamp;
    logic       [7:0]  debug_tag;
    logic       [3:0]  status;
    function new(string n="packet"); super.new(n); endfunction
endclass
 
// ── Common flag values ────────────────────────────────────────────────
//
// UVM_DEFAULT    = 0x01FF  All operations enabled (copy+compare+print+pack+...)
// UVM_NOCOMPARE  = 0x0008  Exclude from compare()  (bit 3)
// UVM_NOPRINT    = 0x0010  Exclude from print()
// UVM_NOPRINTX   = 0x0010  (same as NOPRINT in most implementations)
// UVM_NOPACK     = 0x0100  Exclude from pack/unpack
// UVM_NOCOPY     = 0x0001  Exclude from copy() — rarely used
// UVM_COPY       = 0x0001  Explicitly enable copy
// UVM_COMPARE    = 0x0004  Explicitly enable compare
// UVM_PRINT      = 0x0008  Explicitly enable print

class burst_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(burst_txn)
        `uvm_field_int(start_addr, UVM_DEFAULT)
        // Dynamic array of 32-bit data words
        `uvm_field_array_int(data_words, UVM_DEFAULT)
        // Queue of byte-sized error flags
        `uvm_field_queue_int(error_flags, UVM_DEFAULT)
        // Enum field
        `uvm_field_enum(burst_type_e, burst_type, UVM_DEFAULT)
    `uvm_object_utils_end
 
    rand logic [31:0]  start_addr;
    rand logic [31:0]  data_words[];  // dynamic array
    rand logic [7:0]   error_flags[$]; // queue
    rand burst_type_e  burst_type;
    function new(string n="burst_txn"); super.new(n); endfunction
endclass
 
// ── What compare() does with arrays ──────────────────────────────────
// 1. Compares array SIZE first — different sizes → immediate mismatch
// 2. Compares elements index by index
// 3. Prints element-level mismatch detail at UVM_HIGH verbosity
//
// ── What copy() does with dynamic arrays ─────────────────────────────
// Creates a new dynamic array of the same size and copies each element.
// This IS a deep copy for int/logic arrays — each element is a value type.
// For object arrays (uvm_field_array_object), copy() does SHALLOW copy
// — each element is still a shared handle. Use do_copy() for true deep copy.
//
// ── Tricky: compare() on different-length arrays ─────────────────────
burst_txn a = burst_txn::type_id::create("a");
burst_txn b = burst_txn::type_id::create("b");
a.data_words = new[4]('{1,2,3,4});
b.data_words = new[3]('{1,2,3});
// a.compare(b) → 0 (FAIL) — size mismatch detected first
// Error: "data_words: size mismatch: lhs=4 rhs=3"

class header extends uvm_object;
    `uvm_object_utils_begin(header)
        `uvm_field_int(hdr_type, UVM_DEFAULT)
    `uvm_object_utils_end
    rand int hdr_type;
    function new(string n="header"); super.new(n); endfunction
endclass
 
class complex_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(complex_txn)
        // ❌ Shallow copy — both original and copy share the SAME header object!
        `uvm_field_object(hdr, UVM_DEFAULT)
        `uvm_field_int(payload, UVM_DEFAULT)
    `uvm_object_utils_end
    header hdr;
    rand int payload;
    function new(string n="complex_txn"); super.new(n); endfunction
endclass
 
// ── Demonstration of the shallow copy problem ────────────────────────
complex_txn orig = complex_txn::type_id::create("orig");
complex_txn copy;
orig.hdr = header::type_id::create("hdr");
orig.hdr.hdr_type = 1;
$cast(copy, orig.clone());  // clone calls copy(), which calls do_copy()
 
copy.hdr.hdr_type = 99;     // modifying copy's header...
// $display(orig.hdr.hdr_type) → prints 99, not 1!
// BECAUSE: `uvm_field_object does shallow copy — hdr pointer is shared!
 
// ✓ FIX: override do_copy() for deep copy of object fields ─────────────
function void do_copy(uvm_object rhs);
    complex_txn rhs_cast;
    super.do_copy(rhs);                     // copies scalar fields via field macros
    $cast(rhs_cast, rhs);
    // Manually deep-copy the object handle
    hdr = header::type_id::create("hdr");
    hdr.copy(rhs_cast.hdr);               // new object with same field values
endfunction

// ❌ WRONG — UVM_NOCOMPARE applied to critical data field ─────────────
class apb_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(apb_txn)
        `uvm_field_int(addr, UVM_DEFAULT)
        `uvm_field_int(data, UVM_NOCOMPARE)  // ← data NOT compared!
        `uvm_field_int(write, UVM_DEFAULT)
    `uvm_object_utils_end
    rand logic [31:0] addr;
    rand logic [31:0] data;
    rand logic        write;
endclass
 
// In scoreboard:
// txn_actual.compare(txn_expected) → returns 1 even if data differs!
// → `uvm_error never fires → CI reports PASS → DUT corruption undetected
 
// ✓ CORRECT — use UVM_DEFAULT for fields that must be compared ────────
`uvm_field_int(data, UVM_DEFAULT)  // ← compare enabled
 
// If you genuinely need to exclude from comparison, document it clearly:
// `uvm_field_int(timestamp, UVM_DEFAULT | UVM_NOCOMPARE)  // timestamp: DUT-generated, not predicted
// And add an assertion in check_phase to verify the field separately if needed.

// ❌ WRONG — field macro outside the begin/end block ─────────────────
class bad_txn extends uvm_sequence_item;
    `uvm_object_utils(bad_txn)         // ← compact form, no begin/end
    `uvm_field_int(addr, UVM_DEFAULT)  // ← OUTSIDE the wrapper — ignored!
 
    rand logic [31:0] addr;
endclass
 
// bad_txn t;
// t.print() → shows "bad_txn" with NO fields listed
// t.compare(other) → always returns 1 (no fields registered for compare)
// t.clone() → creates empty object (no fields copied)
 
// ✓ CORRECT — field macros inside begin/end ───────────────────────────
class good_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(good_txn)     // ← _begin form required for field macros
        `uvm_field_int(addr, UVM_DEFAULT)   // ← INSIDE: generates code for all 6 methods
    `uvm_object_utils_end                   // ← closes the block
 
    rand logic [31:0] addr;
    function new(string n="good_txn"); super.new(n); endfunction
endclass
 
// good_txn t;
// t.addr = 32'h4000;
// t.print() → shows addr = 'h4000  ← field visible
// t.compare(other) → actually compares addr field

// ── Auto-generated (field macro): ~6 function calls per field ────────
class slow_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(slow_txn)
        `uvm_field_int(addr, UVM_DEFAULT)
        `uvm_field_int(data, UVM_DEFAULT)
    `uvm_object_utils_end
    rand logic [31:0] addr, data;
    // convert2string() → uses generic recorder → slow for high-frequency use
endclass
 
// ── Hand-written: one $sformatf call ─────────────────────────────────
class fast_txn extends uvm_sequence_item;
    `uvm_object_utils(fast_txn)   // compact — no field macros
    rand logic [31:0] addr, data;
 
    function string convert2string();
        return $sformatf("addr=0x%0h data=0x%0h", addr, data);
    endfunction
 
    function void do_copy(uvm_object rhs);
        fast_txn rhs_t; super.do_copy(rhs);
        $cast(rhs_t, rhs);
        addr = rhs_t.addr;
        data = rhs_t.data;
    endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        fast_txn rhs_t;
        if (!$cast(rhs_t, rhs)) return 0;
        return super.do_compare(rhs, comparer) &&
               (addr === rhs_t.addr) &&
               (data === rhs_t.data);
    endfunction
endclass
 
// Rule of thumb:
// ≤ 8 scalar fields + low transaction rate → use field macros (convenience wins)
// > 8 fields OR high transaction rate (> 10K/ms) → hand-write do_copy/do_compare/convert2string

// field_macro_demo.sv
// Compile: vlog -sv field_macro_demo.sv
// Run:     vsim -c work.tb_fm_top +UVM_TESTNAME=fm_test -do "run -all; quit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── VERSION A: field macros ────────────────────────────────────────────
class apb_macro_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(apb_macro_txn)
        `uvm_field_int(addr,  UVM_DEFAULT)
        `uvm_field_int(data,  UVM_DEFAULT)
        `uvm_field_int(write, UVM_DEFAULT)
    `uvm_object_utils_end
 
    rand logic [31:0] addr;
    rand logic [31:0] data;
    rand logic        write;
    function new(string n="apb_macro_txn"); super.new(n); endfunction
endclass
 
// ── VERSION B: manual implementation ──────────────────────────────────
class apb_manual_txn extends uvm_sequence_item;
    `uvm_object_utils(apb_manual_txn)
 
    rand logic [31:0] addr;
    rand logic [31:0] data;
    rand logic        write;
 
    function new(string n="apb_manual_txn"); super.new(n); endfunction
 
    function string convert2string();
        return $sformatf("[APB] addr=0x%08h data=0x%08h write=%0b",
            addr, data, write);
    endfunction
 
    function void do_copy(uvm_object rhs);
        apb_manual_txn r;
        super.do_copy(rhs);
        $cast(r, rhs);
        addr  = r.addr;
        data  = r.data;
        write = r.write;
    endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        apb_manual_txn r;
        if (!$cast(r, rhs)) return 0;
        if (addr  !== r.addr)  comparer.compare_field("addr",  addr,  r.addr,  32);
        if (data  !== r.data)  comparer.compare_field("data",  data,  r.data,  32);
        if (write !== r.write) comparer.compare_field("write", write, r.write, 1);
        return (addr === r.addr) && (data === r.data) && (write === r.write);
    endfunction
endclass
 
// ── Test: exercises both versions ─────────────────────────────────────
class fm_test extends uvm_test;
    `uvm_component_utils(fm_test)
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    task run_phase(uvm_phase phase);
        apb_macro_txn  a1, a2;
        apb_manual_txn m1, m2;
        phase.raise_objection(this);
 
        // ── Macro version ─────────────────────────────────────────────
        a1 = apb_macro_txn::type_id::create("a1");
        a1.addr = 32'h4000; a1.data = 32'hA5A5; a1.write = 1;
        `uvm_info("TEST", "=== Field Macro Version ===", UVM_LOW)
        `uvm_info("TEST", $sformatf("convert2string: %s", a1.convert2string()), UVM_LOW)
        a1.print();
 
        $cast(a2, a1.clone());
        a2.data = 32'hBEEF;  // a1.data unchanged (clone = deep copy of scalars)
        `uvm_info("TEST", $sformatf("compare (should differ): %0d",
            a1.compare(a2)), UVM_LOW)  // expect 0
 
        // ── Manual version ────────────────────────────────────────────
        m1 = apb_manual_txn::type_id::create("m1");
        m1.addr = 32'h4000; m1.data = 32'hA5A5; m1.write = 1;
        `uvm_info("TEST", "=== Manual Version ===", UVM_LOW)
        `uvm_info("TEST", $sformatf("convert2string: %s", m1.convert2string()), UVM_LOW)
 
        $cast(m2, m1.clone());
        m2.data = 32'hBEEF;
        `uvm_info("TEST", $sformatf("compare (should differ): %0d",
            m1.compare(m2)), UVM_LOW)  // expect 0
 
        phase.drop_objection(this);
    endtask
endclass
 
module tb_fm_top;
    initial run_test();
endmodule
 
// Expected output:
// TEST: === Field Macro Version ===
// TEST: convert2string: addr=4000 data=a5a5 write=1   (macro format)
// Name         Type    Size  Value
// apb_macro_txn  object  -
//   addr         integral 32   'h4000
//   data         integral 32   'ha5a5
//   write        integral 1    'h1
// TEST: compare (should differ): 0  ← data=0xa5a5 vs data=0xbeef
//
// TEST: === Manual Version ===
// TEST: convert2string: [APB] addr=0x00004000 data=0xa5a5a5a5 write=1
// TEST: compare (should differ): 0  ← same result, more control

// ================================================================
// nocompare_trap.sv — a mismatch that compare() reports as a match.
//   Questa : vlog -sv -L uvm_1_2 nocompare_trap.sv
//            vsim -c -L uvm_1_2 nocompare_trap_top -do "run -all; quit"
//   VCS    : vcs -sverilog -ntb_opts uvm-1.2 nocompare_trap.sv && ./simv
//   Xcelium: xrun -sv -uvm nocompare_trap.sv
// ================================================================
`include "uvm_macros.svh"
import uvm_pkg::*;
 
class apb_txn extends uvm_sequence_item;
    `uvm_object_utils_begin(apb_txn)
        `uvm_field_int(addr,   UVM_DEFAULT)
        `uvm_field_int(data,   UVM_DEFAULT)
        // Added during bring-up so a noisy debug field stopped failing runs.
        // It also silently removed the DUT's response code from every check.
        `uvm_field_int(resp,   UVM_DEFAULT | UVM_NOCOMPARE)
        // Never registered at all — the most invisible exclusion there is.
    `uvm_object_utils_end
 
    rand bit [31:0] addr, data;
    bit [1:0]       resp;
    bit             parity_err;      // ← not in any macro: not copied, not compared
 
    function new(string n="apb_txn"); super.new(n); endfunction
endclass
 
class nocompare_trap_test extends uvm_test;
    `uvm_component_utils(nocompare_trap_test)
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    task run_phase(uvm_phase phase);
        apb_txn expected, actual;
        phase.raise_objection(this);
 
        expected = apb_txn::type_id::create("expected");
        actual   = apb_txn::type_id::create("actual");
 
        expected.addr = 32'h1000; expected.data = 32'hDEAD_BEEF;
        expected.resp = 2'b00;    expected.parity_err = 1'b0;   // OKAY, clean
 
        actual.addr   = 32'h1000; actual.data   = 32'hDEAD_BEEF;
        actual.resp   = 2'b11;    actual.parity_err = 1'b1;     // ERROR + parity!
 
        // Two genuinely different transactions.
        if (expected.compare(actual))
            `uvm_info("TRAP", "compare() returned MATCH — resp and parity_err ignored",
                      UVM_LOW)
        else
            `uvm_error("TRAP", "compare() returned MISMATCH")
 
        // copy() has the same blind spot, from the same registration.
        begin
            apb_txn c = apb_txn::type_id::create("c");
            c.copy(actual);
            `uvm_info("TRAP", $sformatf(
                "after copy: resp=%0d (copied) parity_err=%0d (LOST — was %0d)",
                c.resp, c.parity_err, actual.parity_err), UVM_LOW)
        end
 
        phase.drop_objection(this);
    endtask
endclass
 
module nocompare_trap_top;
    initial run_test("nocompare_trap_test");
endmodule
 
// Expected:
//   UVM_INFO [TRAP] compare() returned MATCH — resp and parity_err ignored
//   UVM_INFO [TRAP] after copy: resp=3 (copied) parity_err=0 (LOST — was 1)