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.

// 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  = 0x0080  Exclude from compare()
// 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