do_copy, do_compare, do_print, do_pack

class my_txn extends uvm_sequence_item;
    `uvm_object_utils(my_txn)
 
    rand bit [31:0] addr;
    rand bit [31:0] data;
    rand bit         write;
    bit     [1:0]  resp;
 
    function new(string name = "my_txn"); super.new(name); endfunction
 
    // ── do_copy: deep copy from source object ─────────────────────────
    function void do_copy(uvm_object rhs);
        my_txn rhs_;
        super.do_copy(rhs);             // ALWAYS first
        if (!$cast(rhs_, rhs)) begin
            `uvm_fatal("DO_COPY", "Cast failed — rhs is not my_txn")
        end
        this.addr  = rhs_.addr;
        this.data  = rhs_.data;
        this.write = rhs_.write;
        this.resp  = rhs_.resp;
    endfunction
 
    // ── do_compare: field-by-field comparison ─────────────────────────
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        my_txn rhs_;
        bit    ok = 1;
        if (!$cast(rhs_, rhs)) return 0;
 
        // Accumulate with &= , NOT with && .
        // `&&` short-circuits by language rule (IEEE 1800), so the first
        // failing compare_field prevents every later one from RUNNING - and
        // compare_field is what records a miscompare with the comparer. The
        // result is a report naming one differing field when five differ,
        // which is the opposite of what uvm_comparer's show_max exists for.
        ok &= super.do_compare(rhs, comparer);
        ok &= comparer.compare_field("addr",  addr,  rhs_.addr,  32);
        ok &= comparer.compare_field("data",  data,  rhs_.data,  32);
        ok &= comparer.compare_field("write", write, rhs_.write,  1);
        // resp intentionally excluded — DUT response, not stimulus
        return ok;
    endfunction
 
    // ── do_print: formatted output ────────────────────────────────────
    function void do_print(uvm_printer printer);
        super.do_print(printer);
        printer.print_field_int("addr",  addr,  32, UVM_HEX);
        printer.print_field_int("data",  data,  32, UVM_HEX);
        printer.print_field_int("write", write,  1, UVM_BIN);
        printer.print_field_int("resp",  resp,   2, UVM_BIN);
    endfunction
 
    // ── do_pack: serialize to bitstream ───────────────────────────────
    function void do_pack(uvm_packer packer);
        super.do_pack(packer);
        packer.pack_field_int(addr,  32);
        packer.pack_field_int(data,  32);
        packer.pack_field_int(write,  1);
        // resp NOT packed — it's a response field, not a stimulus field
    endfunction
 
    // ── do_unpack: deserialize from bitstream ─────────────────────────
    function void do_unpack(uvm_packer packer);
        super.do_unpack(packer);
        addr  = packer.unpack_field_int(32);
        data  = packer.unpack_field_int(32);
        write = packer.unpack_field_int( 1);
    endfunction
 
endclass

class apb_txn extends uvm_sequence_item;
    `uvm_object_utils(apb_txn)
 
    rand bit [31:0] addr;
    rand bit [31:0] data;
    rand bit [3:0]  strobe;
    bit     [1:0]  pslverr;   // DUT response — not always meaningful
    bit              burst_mode;  // when set, pslverr is don't-care
    bit     [31:0]  addr_mask = 32'hFFFF_FFFF; // configurable address mask
 
    function new(string name="apb_txn"); super.new(name); endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        apb_txn rhs_;
        bit result = 1;
 
        if (!$cast(rhs_, rhs)) return 0;
 
        result &= super.do_compare(rhs, comparer);
 
        // Compare only masked address bits
        result &= comparer.compare_field("addr",
            addr  & addr_mask,
            rhs_.addr & rhs_.addr_mask, 32);
 
        // Data must always match
        result &= comparer.compare_field("data", data, rhs_.data, 32);
 
        // Strobe must match
        result &= comparer.compare_field("strobe", strobe, rhs_.strobe, 4);
 
        // pslverr: only compare when NOT in burst mode
        // In burst mode, DUT may return any error code — don't flag it
        if (!burst_mode && !rhs_.burst_mode) begin
            result &= comparer.compare_field("pslverr", pslverr, rhs_.pslverr, 2);
        end
 
        return result;
    endfunction
endclass

class axi_header extends uvm_object;
    `uvm_object_utils(axi_header)
    rand bit [7:0] id;
    rand bit [3:0] len;
    function new(string n="axi_header"); super.new(n); endfunction
 
    function void do_copy(uvm_object rhs);
        axi_header r; $cast(r, rhs);
        super.do_copy(rhs);
        id = r.id; len = r.len;
    endfunction
endclass
 
class axi_txn extends uvm_sequence_item;
    `uvm_object_utils(axi_txn)
 
    axi_header       hdr;         // nested sub-object
    rand bit[63:0]   addr;
    rand bit[7:0]    data[$];     // payload
    time             created_at;  // never copy — always fresh
 
    function new(string n="axi_txn");
        super.new(n);
        hdr = axi_header::type_id::create("hdr");
        created_at = $time;
    endfunction
 
    function void do_copy(uvm_object rhs);
        axi_txn rhs_;
        super.do_copy(rhs);
        if (!$cast(rhs_, rhs)) return;
 
        // DEEP copy of nested header — hdr gets its own clone
        // Without this: this.hdr and rhs_.hdr POINT TO THE SAME OBJECT
        $cast(hdr, rhs_.hdr.clone());
 
        addr = rhs_.addr;
 
        // Deep copy of the dynamic array
        data = rhs_.data;   // SV dynamic arrays copy by value ✓
 
        // created_at intentionally NOT copied
        // Each copy represents a new observation at a new time
        created_at = $time;
    endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer comparer);
        axi_txn rhs_;
        bit     ok = 1;
        if (!$cast(rhs_, rhs)) return 0;
 
        // Accumulate with &= so every field is compared and every miscompare
        // is recorded. `&&` would stop at the first failure - see §3.
        ok &= super.do_compare(rhs, comparer);
        ok &= comparer.compare_object("hdr", hdr, rhs_.hdr);   // nested object
        ok &= comparer.compare_field("addr", addr, rhs_.addr, 64);
 
        // The size check DOES belong in front of the element comparison -
        // comparing queues of different length is meaningless - so it is one
        // place a short-circuit is deliberate rather than accidental.
        if (data.size() != rhs_.data.size()) begin
            comparer.print_msg($sformatf("data size %0d != %0d",
                                         data.size(), rhs_.data.size()));
            ok = 0;
        end else begin
            ok &= (data === rhs_.data);   // === handles X/Z correctly
        end
        return ok;
    endfunction
endclass

class pcie_tlp extends uvm_sequence_item;
    `uvm_object_utils(pcie_tlp)
 
    rand bit [2:0]  fmt;       // TLP format: 3DW/4DW, with/without data
    rand bit [4:0]  tlp_type;
    rand bit [9:0]  length;    // in DWORDs
    rand bit [31:0] addr32;    // used when fmt[0]==0 (3DW)
    rand bit [63:0] addr64;    // used when fmt[0]==1 (4DW)
    rand bit [31:0] payload[$];
 
    function new(string n="pcie_tlp"); super.new(n); endfunction
 
    function void do_pack(uvm_packer packer);
        super.do_pack(packer);
        packer.pack_field_int(fmt,      3);
        packer.pack_field_int(tlp_type, 5);
        packer.pack_field_int(length,  10);
 
        // Protocol determines address width: 3DW vs 4DW header
        if (fmt[0] == 0)
            packer.pack_field_int(addr32, 32);   // 3DW header
        else
            packer.pack_field_int(addr64, 64);   // 4DW header
 
        // Payload only if format indicates data TLP
        if (fmt[1]) begin
            foreach (payload[i])
                packer.pack_field_int(payload[i], 32);
        end
    endfunction
 
    function void do_unpack(uvm_packer packer);
        super.do_unpack(packer);
        fmt      = packer.unpack_field_int( 3);
        tlp_type = packer.unpack_field_int( 5);
        length   = packer.unpack_field_int(10);
 
        if (fmt[0] == 0)
            addr32 = packer.unpack_field_int(32);
        else
            addr64 = packer.unpack_field_int(64);
 
        if (fmt[1]) begin
            payload = {};
            repeat(length)
                payload.push_back(packer.unpack_field_int(32));
        end
    endfunction
endclass

// What actually happens when you write: result = a.compare(b)
 
// Step 1: uvm_object::compare() is called (from uvm_object base class)
// It creates a default comparer if you didn't supply one:
//   comparer = uvm_default_comparer (singleton)
// Then it calls: do_compare(b, comparer)
 
// Step 2: Your do_compare() runs:
//   super.do_compare(b, comparer)   ← type check (returns 0 if wrong type)
//   comparer.compare_field("addr", addr, rhs_.addr, 32)
//     → if mismatch: prints "Miscompare for object..." to transcript
//     → returns 0 and increments comparer.result
 
// Step 3: The short-circuit behavior —
//   In UVM 1.2: ALL fields are compared, mismatches accumulated
//   In some implementations: stops at first mismatch
//   Behavior depends on comparer.show_max_mismatches setting
 
// ── Controlling comparer verbosity ────────────────────────────────────
uvm_comparer cmp = new();
cmp.verbosity = UVM_HIGH;          // print all field mismatches
cmp.show_max_mismatches = 5;        // stop reporting after 5 mismatches
cmp.sev = UVM_ERROR;               // mismatches trigger uvm_error (CI fail)
 
if (!a.compare(b, cmp)) begin
    `uvm_error("SCB", $sformatf(
        "Transaction mismatch! %0d field(s) differ",
        cmp.result))
end
 
// ── compare_field vs compare_field_int — know the difference ─────────
// compare_field(name, lhs, rhs, width_bits)  — works for any integral type
// compare_field_int(name, lhs, rhs, width)   — optimized for native int width
// compare_string(name, lhs_str, rhs_str)     — string comparison
// compare_object(name, lhs_obj, rhs_obj)     — recursive object comparison

class axi_scoreboard extends uvm_scoreboard;
    `uvm_component_utils(axi_scoreboard)
 
    axi_txn           expected_q[$];
    uvm_comparer      m_comparer;
 
    function void build_phase(uvm_phase phase);
        super.build_phase(phase);
        // Configure comparer once — reuse across all comparisons
        m_comparer = new();
        m_comparer.verbosity         = UVM_LOW;    // only print first mismatch
        m_comparer.show_max_mismatches = 1;
        m_comparer.sev               = UVM_ERROR;  // mismatches → CI failure
    endfunction
 
    function void write_from_monitor(axi_txn actual);
        axi_txn expected;
        if (expected_q.size() == 0) begin
            `uvm_error("SCB", "Received transaction but expected queue is empty")
            return;
        end
        expected = expected_q.pop_front();
 
        // compare() calls our do_compare() under the hood
        if (!expected.compare(actual, m_comparer))
            `uvm_error("SCB", $sformatf(
                "Mismatch!\nExpected: %s\nActual: %s",
                expected.sprint(), actual.sprint()))
        else
            `uvm_info("SCB", "Transaction matched ✓", UVM_HIGH)
    endfunction
endclass

// ── Bug 1: Missing super.do_copy() ───────────────────────────────────
// ❌ WRONG
function void do_copy(uvm_object rhs);
    my_txn r; $cast(r, rhs);
    addr = r.addr;   // parent fields from field macros: NEVER COPIED
endfunction
 
// ✓ CORRECT
function void do_copy(uvm_object rhs);
    my_txn r;
    super.do_copy(rhs);   // ← ALWAYS FIRST
    if (!$cast(r, rhs)) return;
    addr = r.addr;
endfunction
 
// ── Bug 2: Shallow copy of nested object ──────────────────────────────
// ❌ WRONG — both source and destination point to SAME header object
function void do_copy(uvm_object rhs);
    axi_txn r; super.do_copy(rhs); $cast(r, rhs);
    hdr  = r.hdr;    // SHALLOW: this.hdr IS r.hdr — same memory location
    addr = r.addr;
endfunction
// Later when r.hdr.id is changed, this.hdr.id changes too — silent corruption
 
// ✓ CORRECT — independent deep copy
function void do_copy(uvm_object rhs);
    axi_txn r; super.do_copy(rhs); $cast(r, rhs);
    $cast(hdr, r.hdr.clone());  // DEEP: independent copy via clone()
    addr = r.addr;
endfunction
 
// ── Bug 3: Using == instead of === for X-aware compare ────────────────
// ❌ WRONG — X propagates, 4-state 'X' data causes false mismatch
function bit do_compare(uvm_object rhs, uvm_comparer cmp);
    my_txn r; $cast(r, rhs);
    return super.do_compare(rhs, cmp) &&
           (data == r.data);   // if data contains X: X==X is X, not 1
endfunction
 
// ✓ CORRECT — use compare_field which handles X properly
function bit do_compare(uvm_object rhs, uvm_comparer cmp);
    my_txn r; $cast(r, rhs);
    return super.do_compare(rhs, cmp) &&
           cmp.compare_field("data", data, r.data, $bits(data));
endfunction
 
// ── Bug 4: Pack/unpack order mismatch ────────────────────────────────
// ❌ WRONG — pack order and unpack order must be IDENTICAL
function void do_pack(uvm_packer pk);
    super.do_pack(pk);
    pk.pack_field_int(addr, 32);  // packed first
    pk.pack_field_int(data, 32);
endfunction
 
function void do_unpack(uvm_packer pk);
    super.do_unpack(pk);
    data = pk.unpack_field_int(32);  // ❌ unpacked first — addr goes into data!
    addr = pk.unpack_field_int(32);
endfunction
// Result: addr and data are swapped — hard to catch without a known-pattern test

// do_methods_demo.sv — all five methods demonstrated
// Questa : vlog -sv do_methods_demo.sv && vsim -c do_methods_top -do "run -all; quit"
// VCS    : vcs -sverilog -ntb_opts uvm do_methods_demo.sv && ./simv
// Xcelium: xrun -sv -uvm do_methods_demo.sv -input "run; exit"
 
`include "uvm_macros.svh"
import uvm_pkg::*;
 
// ── Transaction with all five do_* methods ────────────────────────────
class demo_txn extends uvm_sequence_item;
    `uvm_object_utils(demo_txn)
 
    rand bit[31:0] addr;
    rand bit[31:0] data;
    rand bit       write;
    bit[1:0]      resp;      // excluded from compare and pack
    string          tag;      // debug only — excluded from compare
 
    function new(string n="demo_txn"); super.new(n); endfunction
 
    function void do_copy(uvm_object rhs);
        demo_txn r;
        super.do_copy(rhs);
        if(!$cast(r,rhs)) return;
        addr=r.addr; data=r.data; write=r.write; resp=r.resp; tag=r.tag;
    endfunction
 
    function bit do_compare(uvm_object rhs, uvm_comparer c);
        demo_txn r;
        if(!$cast(r,rhs)) return 0;
        return super.do_compare(rhs,c) &&
               c.compare_field("addr",  addr,  r.addr,  32) &&
               c.compare_field("data",  data,  r.data,  32) &&
               c.compare_field("write", write, r.write,  1);
        // resp and tag excluded — they are metadata not stimulus
    endfunction
 
    function void do_print(uvm_printer p);
        super.do_print(p);
        p.print_field_int("addr",  addr,  32, UVM_HEX);
        p.print_field_int("data",  data,  32, UVM_HEX);
        p.print_field_int("write", write,  1, UVM_BIN);
        p.print_field_int("resp",  resp,   2, UVM_BIN);
        p.print_string("tag", tag);
    endfunction
 
    function void do_pack(uvm_packer pk);
        super.do_pack(pk);
        pk.pack_field_int(addr,  32);
        pk.pack_field_int(data,  32);
        pk.pack_field_int(write,  1);
    endfunction
 
    function void do_unpack(uvm_packer pk);
        super.do_unpack(pk);
        addr  = pk.unpack_field_int(32);
        data  = pk.unpack_field_int(32);
        write = pk.unpack_field_int( 1);
    endfunction
endclass
 
// ── Test exercising all five methods ─────────────────────────────────
class do_methods_test extends uvm_test;
    `uvm_component_utils(do_methods_test)
    function new(string n, uvm_component p); super.new(n,p); endfunction
 
    task run_phase(uvm_phase phase);
        demo_txn orig, copy_a, copy_b;
        bit[7:0] packed[$];
        phase.raise_objection(this);
 
        // Create and randomize original
        orig = demo_txn::type_id::create("orig");
        void'(orig.randomize());
        orig.resp = 2'b01;
        orig.tag  = "WRITE_BURST_TEST";
 
        `uvm_info("TEST","=== do_print() output ===",UVM_NONE) orig.print();
 
        // Test do_copy via clone()
        $cast(copy_a, orig.clone());
        copy_a.set_name("copy_a");
        `uvm_info("TEST",$sformatf("do_compare after clone: %0d (expect 1)",
            orig.compare(copy_a)),UVM_NONE)
 
        // Modify copy — compare should fail on data, NOT on resp/tag
        copy_a.data = 32'hFFFF_0000;
        copy_a.resp = 2'b11;   // excluded from compare — should not affect result
        copy_a.tag  = "DIFFERENT_TAG";  // also excluded
        `uvm_info("TEST",$sformatf("do_compare after data change: %0d (expect 0)",
            orig.compare(copy_a)),UVM_NONE)
 
        // Test do_pack + do_unpack symmetry
        void'(orig.pack_bytes(packed));
        `uvm_info("TEST",$sformatf("Packed size: %0d bytes (expect 9)",
            packed.size()),UVM_NONE)
 
        copy_b = demo_txn::type_id::create("copy_b");
        void'(copy_b.unpack_bytes(packed));
        `uvm_info("TEST",$sformatf("Pack/unpack symmetry: %0d (expect 1)",
            orig.compare(copy_b)),UVM_NONE)
 
        `uvm_info("TEST","All do_* method tests complete",UVM_NONE)
        phase.drop_objection(this);
    endtask
endclass
 
module do_methods_top;
    initial run_test("do_methods_test");
endmodule
 
// Expected output:
// TEST: === do_print() output ===
//   Name    Type     Size  Value
//   addr    integral  32   'h????????
//   data    integral  32   'h????????
//   write   integral   1   'b?
//   resp    integral   2   'b01
//   tag     string    16   WRITE_BURST_TEST
// TEST: do_compare after clone: 1 (expect 1)
// TEST: do_compare after data change: 0 (expect 0)
// TEST: Packed size: 9 bytes (expect 9)
// TEST: Pack/unpack symmetry: 1 (expect 1)
// TEST: All do_* method tests complete