Optimize trace code for faster compiles on repeated types (#6707) (#6832)

src/V3AstAttr.h

@@ -1139,6 +1139,16 @@ public:
     bool isWritable() const VL_MT_SAFE { return m_e == OUTPUT || m_e == INOUT || m_e == REF; }
     bool isRef() const VL_MT_SAFE { return m_e == REF; }
     bool isConstRef() const VL_MT_SAFE { return m_e == CONSTREF; }
+    string traceSigDirection() const {
+        if (isInout()) {
+            return "VerilatedTraceSigDirection::INOUT";
+        } else if (isWritable()) {
+            return "VerilatedTraceSigDirection::OUTPUT";
+        } else if (isNonOutput()) {
+            return "VerilatedTraceSigDirection::INPUT";
+        }
+        return "VerilatedTraceSigDirection::NONE";
+    }
 };
 constexpr bool operator==(const VDirection& lhs, const VDirection& rhs) VL_MT_SAFE {
     return lhs.m_e == rhs.m_e;
@@ -1798,6 +1808,10 @@ public:
         static const char* const names[] = {"CONSTANT", "FULL", "CHANGE"};
         return names[m_e];
     }
+    const char* func_prefix() const {
+        static const char* const names[] = {"trace_const", "trace_full", "trace_chg"};
+        return names[m_e];
+    }
 };
 constexpr bool operator==(const VTraceType& lhs, const VTraceType& rhs) {
     return lhs.m_e == rhs.m_e;

src/V3AstNodeExpr.h

@@ -4679,6 +4679,7 @@ public:
     string selfPointerProtect(bool useSelfForThis) const {
         return selfPointer().protect(useSelfForThis, protect());
     }
+    bool maybePointedTo() const override VL_MT_SAFE { return true; }
 };
 class AstCMethodCall final : public AstNodeCCall {
     // C++ method call

src/V3AstNodeOther.h

@@ -2089,6 +2089,12 @@ public:
     }
     VDirection direction() const VL_MT_SAFE { return m_direction; }
     bool isIO() const VL_MT_SAFE { return m_direction != VDirection::NONE; }
+    bool isVLIO() const {
+        const AstBasicDType* const bdtypep = basicp();
+        return isPrimaryIO() && bdtypep && !bdtypep->isOpaque()
+               && !dtypep()->skipRefp()->isCompound()
+               && !VN_IS(dtypep()->skipRefp(), UnpackArrayDType);
+    }
     void declDirection(const VDirection& flag) { m_declDirection = flag; }
     VDirection declDirection() const { return m_declDirection; }
     void varType(VVarType type) { m_varType = type; }
@@ -2107,7 +2113,7 @@ public:
     string dpiTmpVarType(const string& varName) const;
     // Return Verilator internal type for argument: CData, SData, IData, WData
     string vlArgType(bool named, bool forReturn, bool forFunc, const string& namespc = "",
-                     bool asRef = false) const;
+                     bool asRef = false, bool constRef = false) const;
     string vlEnumType() const;  // Return VerilatorVarType: VLVT_UINT32, etc
     string vlEnumDir() const;  // Return VerilatorVarDir: VLVD_INOUT, etc
     string vlPropDecl(const string& propName) const;  // Return VerilatorVarProps declaration

src/V3AstNodeStmt.h

@@ -1267,6 +1267,9 @@ class AstTraceDecl final : public AstNodeStmt {
     // Parents:  {statement list}
     // Expression being traced - Moved to AstTraceInc by V3Trace
     // @astgen op1 := valuep : Optional[AstNodeExpr]
+    //
+    // @astgen ptr := m_dtypeCallp: Optional[AstCCall] // Type init function call
+    // @astgen ptr := m_dtypeDeclp: Optional[AstTraceDecl] // CCall TraceDecl which replaces this
     uint32_t m_code{std::numeric_limits<uint32_t>::max()};  // Trace identifier code
     uint32_t m_fidx{0};  // Trace function index
     const string m_showname;  // Name of variable
@@ -1274,18 +1277,23 @@ class AstTraceDecl final : public AstNodeStmt {
     const VNumRange m_arrayRange;  // Property of var the trace details
     const VVarType m_varType;  // Type of variable (for localparam vs. param)
     const VDirection m_declDirection;  // Declared direction input/output etc
+    const bool m_inDtypeFunc;  // Trace decl inside type init function
+    int m_codeInc{0};  // Code increment for type
 public:
     AstTraceDecl(FileLine* fl, const string& showname,
                  AstVar* varp,  // For input/output state etc
-                 AstNodeExpr* valuep, const VNumRange& bitRange, const VNumRange& arrayRange)
+                 AstNodeExpr* valuep, const VNumRange& bitRange, const VNumRange& arrayRange,
+                 AstCCall* const dtypeCallp, const bool inDtypeFunc)
         : ASTGEN_SUPER_TraceDecl(fl)
         , m_showname{showname}
         , m_bitRange{bitRange}
         , m_arrayRange{arrayRange}
         , m_varType{varp->varType()}
-        , m_declDirection{varp->declDirection()} {
+        , m_declDirection{varp->declDirection()}
+        , m_inDtypeFunc{inDtypeFunc} {
         dtypeFrom(valuep);
         this->valuep(valuep);
+        this->dtypeCallp(dtypeCallp);
     }
     void dump(std::ostream& str) const override;
     void dumpJson(std::ostream& str) const override;
@@ -1294,7 +1302,7 @@ public:
     string name() const override VL_MT_STABLE { return m_showname; }
     bool maybePointedTo() const override VL_MT_SAFE { return true; }
     bool hasDType() const override VL_MT_SAFE { return true; }
-    bool sameNode(const AstNode* samep) const override { return false; }
+    bool sameNode(const AstNode* samep) const override { return true; }
     string showname() const { return m_showname; }  // * = Var name
     // Details on what we're tracing
     uint32_t code() const { return m_code; }
@@ -1302,7 +1310,9 @@ public:
     bool codeAssigned() const { return m_code != std::numeric_limits<uint32_t>::max(); }
     uint32_t fidx() const { return m_fidx; }
     void fidx(uint32_t fidx) { m_fidx = fidx; }
+    void codeInc(uint32_t codeInc) { m_codeInc = codeInc; }
     uint32_t codeInc() const {
+        if (m_codeInc) { return m_codeInc; }
         return (m_arrayRange.ranged() ? m_arrayRange.elements() : 1)
                * valuep()->dtypep()->widthWords()
                * (VL_EDATASIZE / 32);  // A code is always 32-bits
@@ -1311,6 +1321,11 @@ public:
     const VNumRange& arrayRange() const { return m_arrayRange; }
     VVarType varType() const { return m_varType; }
     VDirection declDirection() const { return m_declDirection; }
+    AstCCall* dtypeCallp() const { return m_dtypeCallp; }
+    void dtypeCallp(AstCCall* const callp) { m_dtypeCallp = callp; }
+    AstTraceDecl* dtypeDeclp() const { return m_dtypeDeclp; }
+    void dtypeDeclp(AstTraceDecl* const declp) { m_dtypeDeclp = declp; }
+    bool inDtypeFunc() const { return m_inDtypeFunc; }
 };
 class AstTraceInc final : public AstNodeStmt {
     // Trace point dump
@@ -1359,20 +1374,23 @@ class AstTracePushPrefix final : public AstNodeStmt {
     const VTracePrefixType m_prefixType;  // Type of prefix being pushed
     const int m_left;  // Array left index, or struct/union member count
     const int m_right;  // Array right index
+    const bool m_quotedPrefix;  // Quote prefix name
 public:
     AstTracePushPrefix(FileLine* fl, const string& prefix, VTracePrefixType prefixType,
-                       int left = 0, int right = 0)
+                       int left = 0, int right = 0, bool quotedPrefix = true)
         : ASTGEN_SUPER_TracePushPrefix(fl)
         , m_prefix{prefix}
         , m_prefixType{prefixType}
         , m_left{left}
-        , m_right{right} {}
+        , m_right{right}
+        , m_quotedPrefix{quotedPrefix} {}
     ASTGEN_MEMBERS_AstTracePushPrefix;
     bool sameNode(const AstNode* samep) const override { return false; }
     string prefix() const { return m_prefix; }
     VTracePrefixType prefixType() const { return m_prefixType; }
     int left() const { return m_left; }
     int right() const { return m_right; }
+    bool quotedPrefix() const { return m_quotedPrefix; }
 };
 class AstWait final : public AstNodeStmt {
     // @astgen op1 := condp : AstNodeExpr

src/V3AstNodes.cpp

@@ -622,7 +622,7 @@ string AstVar::verilogKwd() const {
 }
 
 string AstVar::vlArgType(bool named, bool forReturn, bool forFunc, const string& namespc,
-                         bool asRef) const {
+                         bool asRef, bool constRef) const {
     UASSERT_OBJ(!forReturn, this,
                 "Internal data is never passed as return, but as first argument");
     string ostatic;
@@ -630,7 +630,7 @@ string AstVar::vlArgType(bool named, bool forReturn, bool forFunc, const string&
 
     asRef = asRef || isDpiOpenArray() || (forFunc && (isWritable() || isRef() || isConstRef()));
 
-    if (forFunc && isReadOnly() && asRef) ostatic = ostatic + "const ";
+    if (forFunc && (isReadOnly() || constRef) && asRef) ostatic = ostatic + "const ";
 
     string oname;
     if (named) {
@@ -3317,7 +3317,8 @@ void AstStop::dumpJson(std::ostream& str) const {
 }
 void AstTraceDecl::dump(std::ostream& str) const {
     this->AstNodeStmt::dump(str);
-    if (code()) str << " [code=" << code() << "]";
+    if (codeAssigned()) str << " [code=" << code() << "]";
+    if (dtypeCallp()) str << " [dtypeCallp=" << dtypeCallp() << "]";
 }
 void AstTraceDecl::dumpJson(std::ostream& str) const {
     dumpJsonNumFunc(str, code);

src/V3EmitCBase.cpp

@@ -207,9 +207,7 @@ void EmitCBaseVisitorConst::emitVarDecl(const AstVar* nodep, bool asRef) {
         if (asRef && refNeedParens) puts(")");
         emitDeclArrayBrackets(nodep);
         puts(";\n");
-    } else if (nodep->isPrimaryIO() && basicp && !basicp->isOpaque()
-               && !nodep->dtypep()->skipRefp()->isCompound()
-               && !VN_IS(nodep->dtypep()->skipRefp(), UnpackArrayDType)) {
+    } else if (nodep->isVLIO()) {
         if (nodep->isInout()) {
             putns(nodep, "VL_INOUT");
         } else if (nodep->isWritable()) {

src/V3EmitCImp.cpp

@@ -627,6 +627,16 @@ class EmitCTrace final : public EmitCFunc {
     }
 
     void emitTraceInitOne(const AstTraceDecl* nodep, int enumNum) {
+        std::string direction;
+        direction = nodep->declDirection().traceSigDirection();
+
+        AstCCall* const callp = nodep->dtypeCallp();
+        if (callp) {
+            callp->argTypes(callp->argTypes() + ", " + cvtToStr(nodep->fidx()) + ", c+"
+                            + cvtToStr(nodep->code()) + ", " + direction);
+            return;
+        }
+
         if (nodep->dtypep()->basicp()->isDouble()) {
             puts("VL_TRACE_DECL_DOUBLE");
         } else if (nodep->isWide()) {
@@ -653,7 +663,11 @@ class EmitCTrace final : public EmitCFunc {
 
         // Function index
         puts(",");
-        puts(cvtToStr(nodep->fidx()));
+        if (nodep->inDtypeFunc()) {
+            puts("fidx");
+        } else {
+            puts(cvtToStr(nodep->fidx()));
+        }
 
         // Name
         puts(",");
@@ -663,14 +677,10 @@ class EmitCTrace final : public EmitCFunc {
         puts("," + cvtToStr(enumNum));
 
         // Direction
-        if (nodep->declDirection().isInout()) {
-            puts(", VerilatedTraceSigDirection::INOUT");
-        } else if (nodep->declDirection().isWritable()) {
-            puts(", VerilatedTraceSigDirection::OUTPUT");
-        } else if (nodep->declDirection().isNonOutput()) {
-            puts(", VerilatedTraceSigDirection::INPUT");
+        if (nodep->inDtypeFunc()) {
+            puts(", direction");
         } else {
-            puts(", VerilatedTraceSigDirection::NONE");
+            puts(", " + direction);
         }
 
         // Kind
@@ -767,16 +777,7 @@ class EmitCTrace final : public EmitCFunc {
                 puts("VL_SC_BV_DATAP(");
             }
             iterateConst(varrefp);  // Put var name out
-            // Tracing only supports 1D arrays
-            if (nodep->declp()->arrayRange().ranged()) {
-                if (arrayindex == -2) {
-                    puts("[i]");
-                } else if (arrayindex == -1) {
-                    puts("[0]");
-                } else {
-                    puts("[" + cvtToStr(arrayindex) + "]");
-                }
-            }
+            emitTraceIndex(nodep, arrayindex);
             if (varp->isSc()) puts(".read()");
             if (emitTraceIsScUint(nodep)) {
                 puts(nodep->isQuad() ? ".to_uint64()" : ".to_uint()");
@@ -789,10 +790,24 @@ class EmitCTrace final : public EmitCFunc {
         } else {
             puts("(");
             iterateConst(nodep->valuep());
+            emitTraceIndex(nodep, arrayindex);
             puts(")");
         }
     }
 
+    void emitTraceIndex(const AstTraceInc* const nodep, int arrayindex) {
+        // Tracing only supports 1D arrays
+        if (nodep->declp()->arrayRange().ranged()) {
+            if (arrayindex == -2) {
+                puts("[i]");
+            } else if (arrayindex == -1) {
+                puts("[0]");
+            } else {
+                puts("[" + cvtToStr(arrayindex) + "]");
+            }
+        }
+    }
+
     // VISITORS
     using EmitCFunc::visit;  // Suppress hidden overloaded virtual function warning
     void visit(AstCFunc* nodep) override {
@@ -812,7 +827,11 @@ class EmitCTrace final : public EmitCFunc {
     }
     void visit(AstTracePushPrefix* nodep) override {
         putns(nodep, "VL_TRACE_PUSH_PREFIX(tracep, ");
-        putsQuoted(VIdProtect::protectWordsIf(nodep->prefix(), nodep->protect()));
+        if (nodep->quotedPrefix()) {
+            putsQuoted(VIdProtect::protectWordsIf(nodep->prefix(), nodep->protect()));
+        } else {
+            puts(nodep->prefix());
+        }
         puts(", VerilatedTracePrefixType::");
         puts(nodep->prefixType().ascii());
         puts(", " + std::to_string(nodep->left()));

src/V3Gate.cpp

@@ -429,11 +429,11 @@ class GateOkVisitor final : public VNVisitorConst {
 
         // We only allow a LHS ref for the var being set, and a RHS ref for
         // something else being read.
+        AstVarScope* const vscp = nodep->varScopep();
         if (nodep->access().isWriteOnly()) {
             if (m_lhsVarRef) clearSimple(">1 write refs");
             m_lhsVarRef = nodep;
         } else {
-            AstVarScope* const vscp = nodep->varScopep();
             // TODO: possible bug, should it be >= 1 as add is below?
             if (m_readVscps.size() > 1) {
                 if (m_buffersOnly) clearSimple(">1 rhs varRefs");

src/V3Trace.cpp

@@ -39,13 +39,16 @@
 
 #include "V3Trace.h"
 
+#include "V3Ast.h"
 #include "V3DupFinder.h"
 #include "V3EmitCBase.h"
 #include "V3Graph.h"
 #include "V3Stats.h"
+#include "V3UniqueNames.h"
 
 #include <limits>
 #include <set>
+#include <unordered_map>
 
 VL_DEFINE_DEBUG_FUNCTIONS;
 
@@ -118,6 +121,8 @@ class TraceTraceVertex final : public V3GraphVertex {
     AstTraceDecl* const m_nodep;  // TRACEINC this represents
     // nullptr, or other vertex with the real code() that duplicates this one
     TraceTraceVertex* m_duplicatep = nullptr;
+    // When aliasing to a dtype parent, offset of the member within the dtype
+    uint32_t m_dtypeAliasOffset = 0;
 
 public:
     TraceTraceVertex(V3Graph* graphp, AstTraceDecl* nodep)
@@ -134,6 +139,9 @@ public:
         UASSERT_OBJ(!duplicatep(), nodep(), "Assigning duplicatep() to already duplicated node");
         m_duplicatep = dupp;
     }
+    void redirectDuplicatep(TraceTraceVertex* dupp) { m_duplicatep = dupp; }
+    uint32_t dtypeAliasOffset() const { return m_dtypeAliasOffset; }
+    void dtypeAliasOffset(uint32_t offset) { m_dtypeAliasOffset = offset; }
 };
 
 class TraceVarVertex final : public V3GraphVertex {
@@ -161,9 +169,12 @@ class TraceVisitor final : public VNVisitor {
     //  Ast*::user4()                   // V3Hasher calculation
     // Cleared entire netlist
     //  AstCFunc::user1()               // V3GraphVertex* for this node
+    //  AstCFunc::user2()               // bool; func contains trace decls (needs splitting)
     //  AstTraceDecl::user1()           // V3GraphVertex* for this node
+    //  AstTraceDecl::user2()           // dtype decl cannot be used for _chg
     //  AstVarScope::user1()            // V3GraphVertex* for this node
     //  AstStmtExpr::user2()            // bool; walked next list for other ccalls
+    //  AstVarRef::user2()              // dtype V3TraceDecl* for this node
     //  Ast*::user3()                   // TraceActivityVertex* for this node
     const VNUser1InUse m_inuser1;
     const VNUser2InUse m_inuser2;
@@ -183,6 +194,15 @@ class TraceVisitor final : public VNVisitor {
     V3Graph m_graph;  // Var/CFunc tracking
     TraceActivityVertex* const m_alwaysVtxp;  // "Always trace" vertex
     bool m_finding = false;  // Pass one of algorithm?
+    struct DtypeFuncs final {
+    public:
+        AstCFunc* fullFuncp = nullptr;
+        AstCFunc* chgFuncp = nullptr;
+    };
+    std::unordered_map<const AstNodeDType*, DtypeFuncs>
+        m_dtypeNonConstFuncs;  // Full / Chg funcs per type
+    std::unordered_map<const AstNodeDType*, AstCFunc*> m_dtypeConstFuncs;  // Const func per type
+    V3UniqueNames m_dtypeNames{""};  // Unique type func names
 
     // Trace parallelism. Only VCD tracing can be parallelized at this time.
     const uint32_t m_parallelism
@@ -203,31 +223,165 @@ class TraceVisitor final : public VNVisitor {
         UINFO(9, "Finding duplicates");
         // Note uses user4
         V3DupFinder dupFinder;  // Duplicate code detection
+
+        // Compute member offsets within dtype instances incrementally.
+        // For each dtype member TraceDecl, stores its code offset within the
+        // dtype parent's code range.
+        std::unordered_map<const AstTraceDecl*, uint32_t> memberOffsets;
+        std::unordered_map<const AstTraceDecl*, uint32_t> runningOffset;
+
+        // For fixup pass: track dups redirected to dtype parents, so we can
+        // fix them if the parent's user2 is later set during the loop.
+        // Maps dup vertex -> original canonical member vertex.
+        std::vector<std::pair<TraceTraceVertex*, TraceTraceVertex*>> dtypeParentRedirects;
+
         // Hash all of the traced values and find if there are any duplicates
         for (V3GraphVertex& vtx : m_graph.vertices()) {
             if (TraceTraceVertex* const vvertexp = vtx.cast<TraceTraceVertex>()) {
-                const AstTraceDecl* const nodep = vvertexp->nodep();
+                AstTraceDecl* const nodep = vvertexp->nodep();
+                if (nodep->dtypeCallp()) continue;
+
+                if (nodep->dtypeDeclp()) {
+                    uint32_t& offset = runningOffset[nodep->dtypeDeclp()];
+                    memberOffsets[nodep] = offset;
+                    offset += nodep->codeInc();
+                }
+
                 UASSERT_OBJ(!vvertexp->duplicatep(), nodep, "Should not be a duplicate");
-                const auto dupit = dupFinder.findDuplicate(nodep->valuep());
+                const auto dupit = dupFinder.findDuplicate(nodep);
                 if (dupit == dupFinder.end()) {
-                    dupFinder.insert(nodep->valuep());
+                    dupFinder.insert(nodep);
                 } else {
-                    const AstTraceDecl* const dupDeclp = VN_AS(dupit->second->backp(), TraceDecl);
+                    AstTraceDecl* const dupDeclp = VN_AS(dupit->second, TraceDecl);
                     UASSERT_OBJ(dupDeclp, nodep, "Trace duplicate of wrong type");
                     TraceTraceVertex* const dupvertexp
                         = dupDeclp->user1u().toGraphVertex()->cast<TraceTraceVertex>();
-                    UINFO(8, "  Orig " << nodep);
-                    UINFO(8, "   dup " << dupDeclp);
-                    // Mark the hashed node as the original and our
-                    // iterating node as duplicated
-                    vvertexp->duplicatep(dupvertexp);
+                    UINFO(8, "  Orig " << dupDeclp << endl);
+                    UINFO(8, "   dup " << nodep << endl);
+
+                    if (dupDeclp->dtypeDeclp() && !dupDeclp->dtypeDeclp()->user2()) {
+                        AstTraceDecl* const dtypeParentp = dupDeclp->dtypeDeclp();
+                        TraceTraceVertex* const dtypeVtxp
+                            = dtypeParentp->user1u().toGraphVertex()->cast<TraceTraceVertex>();
+                        const auto it2 = memberOffsets.find(dupDeclp);
+                        UASSERT_OBJ(it2 != memberOffsets.end(), dupDeclp,
+                                    "Member offset not precomputed");
+                        vvertexp->duplicatep(dtypeVtxp);
+                        vvertexp->dtypeAliasOffset(it2->second);
+                        dtypeParentRedirects.emplace_back(vvertexp, dupvertexp);
+                    } else {
+                        vvertexp->duplicatep(dupvertexp);
+                    }
+                    if (nodep->dtypeDeclp()) nodep->dtypeDeclp()->user2(true);
                 }
             }
         }
+
+        for (const auto& pair : dtypeParentRedirects) {
+            TraceTraceVertex* const dupVtxp = pair.first;
+            TraceTraceVertex* const memberVtxp = pair.second;
+            const AstTraceDecl* const parentDeclp = dupVtxp->duplicatep()->nodep();
+            if (parentDeclp->user2()) {
+                dupVtxp->redirectDuplicatep(memberVtxp);
+                dupVtxp->dtypeAliasOffset(0);
+            }
+        }
+
         if (dumpLevel() || debug() >= 9)
             dupFinder.dumpFile(v3Global.debugFilename("trace") + ".hash", false);
     }
 
+    void graphDtypePrune() {
+        for (V3GraphVertex* const vtxp : m_graph.vertices().unlinkable()) {
+            if (TraceTraceVertex* const vvertexp = vtxp->cast<TraceTraceVertex>()) {
+                AstTraceDecl* const declp = vvertexp->nodep();
+                // This skips the dtype sub-func optimization if a var is affected by multiple
+                // activities.  We really only need to do this for _chg funcs (and not decls,
+                // _const and _full) but it's simpiler to do it all one way or the other.
+                if (declp) {
+                    if (declp->user2() || (declp->dtypeDeclp() && !declp->dtypeDeclp()->user2())) {
+                        AstCCall* const callp = declp->dtypeCallp();
+                        if (callp) {
+                            AstNode* stmtexprp = callp->backp();
+                            VL_DO_DANGLING(pushDeletep(stmtexprp->unlinkFrBack()), stmtexprp);
+                        } else {
+                            bool emptyScope;
+                            do {
+                                emptyScope = false;
+                                AstNode* const declBackp = declp->backp();
+                                AstNode* const declNextp = declp->nextp();
+                                if (VN_IS(declBackp, TracePushPrefix)
+                                    && VN_IS(declNextp, TracePopPrefix)) {
+                                    VL_DO_DANGLING(pushDeletep(declBackp->unlinkFrBack()),
+                                                   declBackp);
+                                    VL_DO_DANGLING(pushDeletep(declNextp->unlinkFrBack()),
+                                                   declNextp);
+                                    emptyScope = true;
+                                }
+                            } while (emptyScope);
+                        }
+                        // Can't purge until we finish this pass
+                        pushDeletep(declp->unlinkFrBack());
+                        vvertexp->rerouteEdges(&m_graph);
+                        vvertexp->unlinkDelete(&m_graph);
+                    }
+                    declp->dtypeDeclp(nullptr);
+                }
+            }
+        }
+    }
+
+    void splitTraceDeclFuncs() {
+        const int splitLimit = v3Global.opt.outputSplitCTrace() ? v3Global.opt.outputSplitCTrace()
+                                                                : std::numeric_limits<int>::max();
+        if (splitLimit == std::numeric_limits<int>::max()) return;
+
+        for (AstNode* nodep = m_topScopep->blocksp(); nodep; nodep = nodep->nextp()) {
+            AstCFunc* const funcp = VN_CAST(nodep, CFunc);
+            if (!funcp || !funcp->user2()) continue;
+
+            const string baseName = funcp->name();
+            uint32_t subNum = 1;
+            int curSize = 0;
+            AstCFunc* curFuncp = funcp;
+            std::vector<AstNodeStmt*> callStmts;
+
+            auto startNewSubFunc = [&]() {
+                FileLine* const flp = funcp->fileline();
+                const string newName = baseName + "_" + cvtToStr(subNum++);
+                AstCFunc* const newFuncp = new AstCFunc{flp, newName, m_topScopep};
+                newFuncp->argTypes(v3Global.opt.traceClassBase() + "* tracep");
+                newFuncp->isTrace(true);
+                newFuncp->isStatic(false);
+                newFuncp->isLoose(true);
+                newFuncp->slow(true);
+                newFuncp->dontCombine(true);
+                m_topScopep->addBlocksp(newFuncp);
+                newFuncp->addStmtsp(new AstCStmt{flp, "const int c = vlSymsp->__Vm_baseCode;"});
+                AstCCall* const callp = new AstCCall{flp, newFuncp};
+                callp->dtypeSetVoid();
+                callp->argTypes("tracep");
+                callStmts.push_back(callp->makeStmt());
+                curFuncp = newFuncp;
+                curSize = 0;
+            };
+
+            for (AstNode *stmtp = funcp->stmtsp(), *nextp; stmtp; stmtp = nextp) {
+                nextp = stmtp->nextp();
+                curSize += stmtp->nodeCount();
+
+                if (curFuncp != funcp) {
+                    stmtp->unlinkFrBack();
+                    curFuncp->addStmtsp(stmtp);
+                }
+
+                if (curSize > splitLimit && nextp) startNewSubFunc();
+            }
+
+            for (AstNodeStmt* const callStmtp : callStmts) { funcp->addStmtsp(callStmtp); }
+        }
+    }
+
     void graphSimplify(bool initial) {
         if (initial) {
             // Remove all variable nodes
@@ -481,24 +635,26 @@ class TraceVisitor final : public VNVisitor {
     }
 
     AstCFunc* newCFunc(VTraceType traceType, AstCFunc* topFuncp, uint32_t funcNum,
-                       uint32_t baseCode = 0) {
+                       uint32_t baseCode = 0, const AstTraceDecl* const declp = nullptr,
+                       bool declSub = false) {
         // Create new function
-        const bool isTopFunc = topFuncp == nullptr;
+        const bool isTopFunc = !declp && topFuncp == nullptr;
         std::string funcName;
-        if (isTopFunc) {
-            if (traceType == VTraceType::CONSTANT) {
-                funcName = "trace_const";
-            } else if (traceType == VTraceType::FULL) {
-                funcName = "trace_full";
-            } else {
-                funcName = "trace_chg";
-            }
+        if (isTopFunc || declp) {
+            funcName = traceType.func_prefix();
         } else {
             funcName = topFuncp->name();
             funcName += "_sub";
         }
-        funcName += "_";
-        funcName += cvtToStr(funcNum);
+        if (declp) {
+            funcName += "_dtype";
+            if (declSub) funcName += "_sub";
+            funcName += "__";
+            funcName = m_dtypeNames.get(funcName);
+        } else {
+            funcName += "_";
+            funcName += cvtToStr(funcNum);
+        }
 
         FileLine* const flp = m_topScopep->fileline();
         AstCFunc* const funcp = new AstCFunc{flp, funcName, m_topScopep};
@@ -511,7 +667,10 @@ class TraceVisitor final : public VNVisitor {
         m_topScopep->addBlocksp(funcp);
         const std::string bufArg
             = v3Global.opt.traceClassBase()
-              + "::" + (v3Global.opt.useTraceOffload() ? "OffloadBuffer" : "Buffer") + "* bufp";
+              + "::" + (v3Global.opt.useTraceOffload() ? "OffloadBuffer" : "Buffer") + "* bufp"
+              + (declp ? (", uint32_t offset, const " + declp->dtypep()->cType("", true, true)
+                          + " __VdtypeVar")
+                       : "");
         if (isTopFunc) {
             // Top functions
             funcp->argTypes("void* voidSelf, " + bufArg);
@@ -546,35 +705,82 @@ class TraceVisitor final : public VNVisitor {
             if (traceType != VTraceType::CHANGE) {
                 // Full dump sub function
                 funcp->addStmtsp(new AstCStmt{flp,  //
-                                              "uint32_t* const oldp VL_ATTR_UNUSED = "
-                                              "bufp->oldp(vlSymsp->__Vm_baseCode);\n"});
+                                              string("uint32_t* const oldp VL_ATTR_UNUSED = "
+                                                     "bufp->oldp(vlSymsp->__Vm_baseCode")
+                                                  + (declp ? " + offset" : "") + ");\n"});
             } else {
                 // Change dump sub function
                 if (v3Global.opt.useTraceOffload()) {
                     funcp->addStmtsp(new AstCStmt{flp,  //
                                                   "const uint32_t base VL_ATTR_UNUSED = "
                                                   "vlSymsp->__Vm_baseCode + "
-                                                      + cvtToStr(baseCode) + ";\n"});
+                                                      + (declp ? " offset" : cvtToStr(baseCode))
+                                                      + ";\n"});
                     funcp->addStmtsp(
                         new AstCStmt{flp, "(void)bufp;  // Prevent unused variable warning\n"});
                 } else {
                     funcp->addStmtsp(new AstCStmt{flp,  //
                                                   "uint32_t* const oldp VL_ATTR_UNUSED = "
                                                   "bufp->oldp(vlSymsp->__Vm_baseCode + "
-                                                      + cvtToStr(baseCode) + ");\n"});
+                                                      + (declp ? " offset" : cvtToStr(baseCode))
+                                                      + ");\n"});
                 }
             }
-            // Add call to top function
-            AstCCall* const callp = new AstCCall{funcp->fileline(), funcp};
-            callp->dtypeSetVoid();
-            callp->argTypes("bufp");
-            topFuncp->addStmtsp(callp->makeStmt());
+            if (!declp) {
+                // Add call to top function
+                AstCCall* const callp = new AstCCall{funcp->fileline(), funcp};
+                callp->dtypeSetVoid();
+                callp->argTypes("bufp");
+                topFuncp->addStmtsp(callp->makeStmt());
+            }
         }
         // Done
         UINFO(5, "  newCFunc " << funcp);
         return funcp;
     }
 
+    AstCFunc* newCDtypeSubFunc(VTraceType traceType, const AstTraceDecl* const declp,
+                               AstCFunc* parentp) {
+        AstCFunc* const funcp = newCFunc(traceType, nullptr, 0, 0, declp, true);
+        FileLine* const flp = m_topScopep->fileline();
+        AstCCall* const callp = new AstCCall{flp, funcp};
+        callp->dtypeSetVoid();
+        callp->argTypes("bufp, offset, __VdtypeVar");
+        parentp->addStmtsp(callp->makeStmt());
+        return funcp;
+    }
+
+    AstCFunc* createConstDtypeTraceFunctions(const AstTraceDecl* declp) {
+        const AstNodeDType* const dtypep = declp->dtypep()->skipRefp();
+        auto pair = m_dtypeConstFuncs.emplace(dtypep, nullptr);
+        if (pair.second) {
+            FileLine* const flp = declp->fileline();
+            AstCFunc* const funcp = newCFunc(VTraceType::CONSTANT, nullptr, 0, 0, declp);
+
+            bool first = true;
+            for (AstNode* callStmtp = declp->dtypeCallp()->funcp()->stmtsp(); callStmtp;
+                 callStmtp = callStmtp->nextp()) {
+                const AstCCall* const callp
+                    = VN_CAST(VN_CAST(callStmtp, StmtExpr)->exprp(), CCall);
+                bool onlyOne = first && !callStmtp->nextp();
+                AstCFunc* const subFuncp
+                    = onlyOne ? funcp : newCDtypeSubFunc(VTraceType::CONSTANT, declp, funcp);
+                for (AstNode* stmtp = callp->funcp()->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
+                    if (AstTraceDecl* const fieldDeclp = VN_CAST(stmtp, TraceDecl)) {
+                        AstTraceInc* const incp
+                            = new AstTraceInc{flp, fieldDeclp, VTraceType::CONSTANT};
+                        subFuncp->addStmtsp(incp);
+                    }
+                }
+                first = false;
+            }
+
+            pair.first->second = funcp;
+        }
+
+        return pair.first->second;
+    }
+
     void createConstTraceFunctions(const TraceVec& traces) {
         const int splitLimit = v3Global.opt.outputSplitCTrace() ? v3Global.opt.outputSplitCTrace()
                                                                 : std::numeric_limits<int>::max();
@@ -583,18 +789,12 @@ class TraceVisitor final : public VNVisitor {
         uint32_t subFuncNum = 0;
         AstCFunc* subFuncp = nullptr;
         int subStmts = 0;
+        std::vector<const TraceTraceVertex*> duplicates;
         for (auto it = traces.cbegin(); it != traces.end(); ++it) {
             const TraceTraceVertex* const vtxp = it->second;
             AstTraceDecl* const declp = vtxp->nodep();
-            if (const TraceTraceVertex* const canonVtxp = vtxp->duplicatep()) {
-                // This is a duplicate trace node. We will assign the signal
-                // number to the canonical node, and emit this as an alias, so
-                // no need to create a TraceInc node.
-                const AstTraceDecl* const canonDeclp = canonVtxp->nodep();
-                UASSERT_OBJ(!canonVtxp->duplicatep(), canonDeclp, "Canonical node is a duplicate");
-                UASSERT_OBJ(canonDeclp->codeAssigned(), canonDeclp,
-                            "Canonical node should have code assigned already");
-                declp->code(canonDeclp->code());
+            if (vtxp->duplicatep()) {
+                duplicates.push_back(vtxp);
                 continue;
             }
 
@@ -616,11 +816,71 @@ class TraceVisitor final : public VNVisitor {
                     ++subFuncNum;
                 }
                 FileLine* const flp = declp->fileline();
-                AstTraceInc* const incp = new AstTraceInc{flp, declp, VTraceType::CONSTANT};
-                subFuncp->addStmtsp(incp);
-                subStmts += incp->nodeCount();
+                if (declp->dtypeCallp()) {
+                    AstCFunc* const funcp = createConstDtypeTraceFunctions(declp);
+                    AstNodeExpr* argsp = nullptr;
+                    argsp = AstNode::addNext(argsp, declp->valuep()->cloneTree(false));
+                    AstCCall* const callp = new AstCCall{flp, funcp, argsp};
+                    callp->dtypeSetVoid();
+                    callp->argTypes(callp->argTypes() + "bufp, " + std::to_string(declp->code()));
+                    subFuncp->addStmtsp(callp->makeStmt());
+
+                    subStmts += 1;
+                } else {
+                    AstTraceInc* const incp = new AstTraceInc{flp, declp, VTraceType::CONSTANT};
+                    subFuncp->addStmtsp(incp);
+                    subStmts += incp->nodeCount();
+                }
             }
         }
+
+        // Assign codes to duplicate nodes from their canonicals
+        for (const TraceTraceVertex* const vtxp : duplicates) {
+            AstTraceDecl* const declp = vtxp->nodep();
+            const TraceTraceVertex* const canonVtxp = vtxp->duplicatep();
+            const AstTraceDecl* const canonDeclp = canonVtxp->nodep();
+            UASSERT_OBJ(!canonVtxp->duplicatep(), canonDeclp, "Canonical node is a duplicate");
+            UASSERT_OBJ(canonDeclp->codeAssigned(), canonDeclp,
+                        "Canonical node should have code assigned already");
+            declp->code(canonDeclp->code() + vtxp->dtypeAliasOffset());
+        }
+    }
+
+    DtypeFuncs createNonConstDtypeTraceFunctions(const AstTraceDecl* declp) {
+        AstNodeDType* dtypep = declp->dtypep()->skipRefp();
+        auto pair = m_dtypeNonConstFuncs.emplace(dtypep, DtypeFuncs{});
+        if (pair.second) {
+            FileLine* const flp = declp->fileline();
+            AstCFunc* const fullFuncp = newCFunc(VTraceType::FULL, nullptr, 0, 0, declp);
+            AstCFunc* const chgFuncp = newCFunc(VTraceType::CHANGE, nullptr, 0, 0, declp);
+
+            bool first = true;
+            for (AstNode* callStmtp = declp->dtypeCallp()->funcp()->stmtsp(); callStmtp;
+                 callStmtp = callStmtp->nextp()) {
+                const AstCCall* const callp
+                    = VN_CAST(VN_CAST(callStmtp, StmtExpr)->exprp(), CCall);
+                bool onlyOne = first && !callStmtp->nextp();
+                AstCFunc* const fullSubFuncp
+                    = onlyOne ? fullFuncp : newCDtypeSubFunc(VTraceType::FULL, declp, fullFuncp);
+                AstCFunc* const chgSubFuncp
+                    = onlyOne ? chgFuncp : newCDtypeSubFunc(VTraceType::CHANGE, declp, chgFuncp);
+                for (AstNode* stmtp = callp->funcp()->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
+                    if (AstTraceDecl* const fieldDeclp = VN_CAST(stmtp, TraceDecl)) {
+                        AstTraceInc* const incFullp
+                            = new AstTraceInc{flp, fieldDeclp, VTraceType::FULL};
+                        fullSubFuncp->addStmtsp(incFullp);
+                        AstTraceInc* const incChgp
+                            = new AstTraceInc{flp, fieldDeclp, VTraceType::CHANGE};
+                        chgSubFuncp->addStmtsp(incChgp);
+                    }
+                }
+                first = false;
+            }
+
+            pair.first->second = {.fullFuncp = fullFuncp, .chgFuncp = chgFuncp};
+        }
+
+        return pair.first->second;
     }
 
     void createNonConstTraceFunctions(const TraceVec& traces, uint32_t nAllCodes,
@@ -698,24 +958,44 @@ class TraceVisitor final : public VNVisitor {
 
                 // Add TraceInc nodes
                 FileLine* const flp = declp->fileline();
-                AstTraceInc* const incFulp = new AstTraceInc{flp, declp, VTraceType::FULL};
-                subFulFuncp->addStmtsp(incFulp);
-                AstTraceInc* const incChgp
-                    = new AstTraceInc{flp, declp, VTraceType::CHANGE, baseCode};
-                ifp->addThensp(incChgp);
+                if (declp->dtypeCallp()) {
+                    DtypeFuncs funcs = createNonConstDtypeTraceFunctions(declp);
+                    AstNodeExpr* argsp = nullptr;
+                    argsp = AstNode::addNext(argsp, declp->valuep()->cloneTree(false));
+                    AstCCall* const callFullp = new AstCCall{flp, funcs.fullFuncp, argsp};
+                    callFullp->dtypeSetVoid();
+                    callFullp->argTypes(callFullp->argTypes() + "bufp, "
+                                        + std::to_string(declp->code()));
+                    subFulFuncp->addStmtsp(callFullp->makeStmt());
+                    argsp = nullptr;
+                    argsp = AstNode::addNext(argsp, declp->valuep()->cloneTree(false));
+                    AstCCall* const callChgp = new AstCCall{flp, funcs.chgFuncp, argsp};
+                    callChgp->dtypeSetVoid();
+                    callChgp->argTypes(callChgp->argTypes() + "bufp, "
+                                       + std::to_string(declp->code()));
+                    ifp->addThensp(callChgp->makeStmt());
 
-                // Set the function index of the decl
-                declp->fidx(topFuncNum);
-
-                // Track splitting due to size
-                UASSERT_OBJ(incFulp->nodeCount() == incChgp->nodeCount(), declp,
-                            "Should have equal cost");
-                const VNumRange range = declp->arrayRange();
-                if (range.ranged()) {
-                    // 2x because each element is a TraceInc and a VarRef
-                    subStmts += range.elements() * 2;
+                    subStmts += 2;
                 } else {
-                    subStmts += incChgp->nodeCount();
+                    AstTraceInc* const incFulp = new AstTraceInc{flp, declp, VTraceType::FULL};
+                    subFulFuncp->addStmtsp(incFulp);
+                    AstTraceInc* const incChgp
+                        = new AstTraceInc{flp, declp, VTraceType::CHANGE, baseCode};
+                    ifp->addThensp(incChgp);
+
+                    // Set the function index of the decl
+                    declp->fidx(topFuncNum);
+
+                    // Track splitting due to size
+                    UASSERT_OBJ(incFulp->nodeCount() == incChgp->nodeCount(), declp,
+                                "Should have equal cost");
+                    const VNumRange range = declp->arrayRange();
+                    if (range.ranged()) {
+                        // 2x because each element is a TraceInc and a VarRef
+                        subStmts += range.elements() * 2;
+                    } else {
+                        subStmts += incChgp->nodeCount();
+                    }
                 }
 
                 // Track partitioning
@@ -761,6 +1041,9 @@ class TraceVisitor final : public VNVisitor {
     void createTraceFunctions() {
         // Detect and remove duplicate values
         detectDuplicates();
+
+        graphDtypePrune();
+        splitTraceDeclFuncs();
         m_graph.removeRedundantEdgesMax(&V3GraphEdge::followAlwaysTrue);
 
         // Simplify & optimize the graph
@@ -885,7 +1168,7 @@ class TraceVisitor final : public VNVisitor {
                 || nodep->isCoroutine()) {
                 // Cannot treat a coroutine as slow, it may be resumed later
                 const bool slow = nodep->slow() && !nodep->isCoroutine();
-                V3GraphVertex* const activityVtxp = getActivityVertexp(nodep, slow);
+                TraceActivityVertex* const activityVtxp = getActivityVertexp(nodep, slow);
                 new V3GraphEdge{&m_graph, activityVtxp, funcVtxp, 1};
             }
         }
@@ -895,21 +1178,23 @@ class TraceVisitor final : public VNVisitor {
     }
     void visit(AstTraceDecl* nodep) override {
         UINFO(8, "   TRACE " << nodep);
-        if (!m_finding) {
+        if (!m_finding && !nodep->inDtypeFunc()) {
             V3GraphVertex* const vertexp = new TraceTraceVertex{&m_graph, nodep};
             nodep->user1p(vertexp);
 
             UASSERT_OBJ(m_cfuncp, nodep, "Trace not under func");
+            m_cfuncp->user2(true);
             VL_RESTORER(m_tracep);
             m_tracep = nodep;
             iterateChildren(nodep);
         }
     }
     void visit(AstVarRef* nodep) override {
+        UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
+        AstVarScope* const varscopep = nodep->varScopep();
+        V3GraphVertex* varVtxp = varscopep->user1u().toGraphVertex();
         if (m_tracep) {
-            UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
             UASSERT_OBJ(nodep->access().isReadOnly(), nodep, "Lvalue in trace?  Should be const.");
-            V3GraphVertex* varVtxp = nodep->varScopep()->user1u().toGraphVertex();
             if (!varVtxp) {
                 varVtxp = new TraceVarVertex{&m_graph, nodep->varScopep()};
                 nodep->varScopep()->user1p(varVtxp);
@@ -920,12 +1205,23 @@ class TraceVisitor final : public VNVisitor {
                 || nodep->varp()->isSigPublic()) {  // Or ones user can change
                 new V3GraphEdge{&m_graph, m_alwaysVtxp, traceVtxp, 1};
             }
+            if (m_tracep->dtypeCallp()) varscopep->user2p(m_tracep);
         } else if (m_cfuncp && m_finding && nodep->access().isWriteOrRW()) {
-            UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
             V3GraphVertex* const funcVtxp = getCFuncVertexp(m_cfuncp);
-            V3GraphVertex* const varVtxp = nodep->varScopep()->user1u().toGraphVertex();
             if (varVtxp) {  // else we're not tracing this signal
                 new V3GraphEdge{&m_graph, funcVtxp, varVtxp, 1};
+                AstTraceDecl* const declp = VN_AS(varscopep->user2p(), TraceDecl);
+                if (declp) {
+                    V3GraphVertex* const cFuncVtxp = getCFuncVertexp(m_cfuncp);
+                    for (const V3GraphEdge& edge : cFuncVtxp->inEdges()) {
+                        V3GraphVertex* const activityp = edge.fromp();
+                        if (!declp->user3p()) {
+                            declp->user3p(activityp);
+                        } else if (declp->user3u().toGraphVertex() != activityp) {
+                            declp->user2(true);
+                        }
+                    }
+                }
             }
         }
     }
@@ -936,7 +1232,15 @@ public:
     // CONSTRUCTORS
     explicit TraceVisitor(AstNetlist* nodep)
         : m_alwaysVtxp{new TraceActivityVertex{&m_graph, TraceActivityVertex::ACTIVITY_ALWAYS}} {
+        nodep->user2ClearTree();  // TraceDecl multiple activities flag
+        nodep->user3ClearTree();  // TraceDecl TraceActivityVertex (assumes we start at nullptr)
         iterate(nodep);
+        nodep->foreach([](AstTraceDecl* const declp) {
+            if (declp->inDtypeFunc()) {
+                declp->valuep()->unlinkFrBack()->deleteTree();
+                declp->valuep(nullptr);
+            }
+        });
     }
     ~TraceVisitor() override {
         V3Stats::addStat("Tracing, Activity setters", m_statSetters);

src/V3TraceDecl.cpp

@@ -24,13 +24,21 @@
 
 #include "V3TraceDecl.h"
 
+#include "V3Ast.h"
 #include "V3Control.h"
 #include "V3EmitCBase.h"
+#include "V3Error.h"
+#include "V3File.h"
+#include "V3Global.h"
+#include "V3Number.h"
 #include "V3Stats.h"
+#include "V3UniqueNames.h"
 
+#include <cstdint>
 #include <functional>
 #include <limits>
 #include <tuple>
+#include <unordered_map>
 #include <vector>
 
 VL_DEFINE_DEBUG_FUNCTIONS;
@@ -94,6 +102,10 @@ public:
 // TraceDecl state, as a visitor of each AstNode
 
 class TraceDeclVisitor final : public VNVisitor {
+    // NODE STATE
+    // AstCFunc::user1()                // code offset for current type
+    // AstCFunc::user2()                // VarScope for dtype functions
+
     // STATE
     AstTopScope* const m_topScopep;  // The singleton AstTopScope
     const AstScope* m_currScopep = nullptr;  // Current scope being visited
@@ -101,6 +113,30 @@ class TraceDeclVisitor final : public VNVisitor {
     std::vector<AstCFunc*> m_topFuncps;  // Top level trace initialization functions
     std::vector<AstCFunc*> m_subFuncps;  // Trace sub functions for this scope
     std::set<const AstTraceDecl*> m_declUncalledps;  // Declarations not called
+    // Functions per type and variable kind (wire vs logic etc.)
+    struct DtypeFuncKey final {
+        const AstNodeDType* dtypep;
+        VVarType varType;
+        bool operator==(const DtypeFuncKey& other) const {
+            return dtypep == other.dtypep && varType == other.varType;
+        }
+    };
+    struct DtypeFuncKeyHash final {
+        size_t operator()(const DtypeFuncKey& key) const {
+            return std::hash<const AstNodeDType*>{}(key.dtypep)
+                   ^ (std::hash<uint8_t>{}(key.varType) << 1);
+        }
+    };
+    std::unordered_map<DtypeFuncKey, AstCFunc*, DtypeFuncKeyHash>
+        m_dtypeFuncs;  // Functions per type+kind
+    AstCFunc* m_dtypeFuncp = nullptr;  // Current type func
+    AstCFunc* m_dtypeSubFuncp = nullptr;  // Current type sub func
+    const string m_dtypeArgs{", const char* name, uint32_t fidx, uint32_t c, "
+                             "VerilatedTraceSigDirection direction"};  // Type func args
+    AstTraceDecl* m_dtypeDeclp = nullptr;  // Current type func decl
+    V3UniqueNames m_dtypeNames{""};  // Unique names for dtype funcs
+    bool m_skipDtypeFunc = false;  // Don't create a type func
+    uint32_t m_offset = std::numeric_limits<uint32_t>::max();  // Offset for types
     int m_topFuncSize = 0;  // Size of the top function currently being built
     int m_subFuncSize = 0;  // Size of the sub function currently being built
     const int m_funcSizeLimit  // Maximum size of a function
@@ -255,9 +291,15 @@ class TraceDeclVisitor final : public VNVisitor {
     }
 
     void addToSubFunc(AstNodeStmt* stmtp) {
-        if (m_subFuncSize > m_funcSizeLimit || m_subFuncps.empty()) {
-            m_subFuncSize = 0;
-            //
+        // TODO (maybe) -- sub funcs for dtype components
+        if (m_dtypeSubFuncp) {
+            if (m_subFuncSize > m_funcSizeLimit) newDeclSubFunc();
+            m_dtypeSubFuncp->addStmtsp(stmtp);
+            m_subFuncSize += stmtp->nodeCount();
+            return;
+        }
+        // Defer trace splitting until V3Trace
+        if (m_subFuncps.empty()) {
             FileLine* const flp = m_currScopep->fileline();
             const string n = cvtToStr(m_subFuncps.size());
             const string name{"trace_init_sub__" + m_currScopep->nameDotless() + "__" + n};
@@ -269,20 +311,38 @@ class TraceDeclVisitor final : public VNVisitor {
         m_subFuncSize += stmtp->nodeCount();
     }
 
-    void addTraceDecl(const VNumRange& arrayRange,
-                      int widthOverride) {  // If !=0, is packed struct/array where basicp size
-                                            // misreflects one element
+    AstTraceDecl* addTraceDecl(const VNumRange& arrayRange,
+                               int widthOverride,  // If !=0, is packed struct/array where basicp
+                                                   // size misreflects one element
+                               AstCCall* const dtypeCallp = nullptr) {
         VNumRange bitRange;
         if (widthOverride) {
             bitRange = VNumRange{widthOverride - 1, 0};
         } else if (const AstBasicDType* const bdtypep = m_traValuep->dtypep()->basicp()) {
             bitRange = bdtypep->nrange();
         }
+        FileLine* const flp = m_traVscp->fileline();
+        AstNodeExpr* valuep = m_traValuep->cloneTree(false);
+        const bool validOffset = m_offset != std::numeric_limits<uint32_t>::max();
         AstTraceDecl* const newp
-            = new AstTraceDecl{m_traVscp->fileline(),         m_traName, m_traVscp->varp(),
-                               m_traValuep->cloneTree(false), bitRange,  arrayRange};
+            = new AstTraceDecl{flp,      m_traName,  m_traVscp->varp(), valuep,
+                               bitRange, arrayRange, dtypeCallp,        validOffset};
+        if (validOffset) {
+            newp->code(m_offset);
+            if (!dtypeCallp) { m_offset += newp->codeInc(); }
+            valuep->foreach([&](AstVarRef* const refp) {
+                UASSERT_OBJ(refp->varScopep() == m_traVscp, refp,
+                            "Trace decl expression references unexpected var");
+                refp->replaceWith(new AstCExpr{flp, "__VdtypeVar", m_traVscp->width()});
+                VL_DO_DANGLING(refp->deleteTree(), refp);
+            });
+        } else {
+            newp->dtypeDeclp(m_dtypeDeclp);
+        }
         m_declUncalledps.emplace(newp);
         addToSubFunc(newp);
+
+        return newp;
     }
 
     void addIgnore(const string& why) {
@@ -398,6 +458,166 @@ class TraceDeclVisitor final : public VNVisitor {
         });
     }
 
+    bool isBasicIO() { return m_traVscp->varp()->isVLIO(); }
+    void newDeclSubFunc() {
+        FileLine* const flp = m_dtypeFuncp->fileline();
+        AstCFunc* const subFuncp = newCFunc(flp, m_dtypeNames.get("trace_init_dtype_sub__"));
+        subFuncp->argTypes(subFuncp->argTypes() + m_dtypeArgs);
+        AstCCall* const subCallp = new AstCCall{flp, subFuncp};
+        subCallp->dtypeSetVoid();
+        subCallp->argTypes("tracep, name, fidx, c, direction");
+        m_dtypeFuncp->addStmtsp(subCallp->makeStmt());
+        m_dtypeSubFuncp = subFuncp;
+        m_subFuncSize = 0;
+    }
+    void newDeclFunc(AstNodeDType* nodep) {
+        AstNodeDType* const skipTypep = nodep->skipRefp();
+        // offset and direction args added in EmitCImp
+        std::string callArgs{"tracep, \"" + VIdProtect::protect(m_traName) + "\""};
+        VL_RESTORER(m_traName);
+        FileLine* const flp = skipTypep->fileline();
+
+        const DtypeFuncKey dtypeKey{skipTypep, m_traVscp->varp()->varType()};
+        auto pair = m_dtypeFuncs.emplace(dtypeKey, nullptr);
+        AstCFunc** funcpp = &pair.first->second;
+        if (pair.second) {
+            *funcpp = newCFunc(flp, m_dtypeNames.get("trace_init_dtype__"));
+            (*funcpp)->argTypes((*funcpp)->argTypes() + m_dtypeArgs);
+            (*funcpp)->user2p(m_traVscp);
+        }
+
+        AstCCall* const callp = new AstCCall{flp, *funcpp};
+        callp->dtypeSetVoid();
+        callp->argTypes(callArgs);
+        m_dtypeDeclp = addTraceDecl(VNumRange{}, skipTypep->width(), callp);
+        addToSubFunc(callp->makeStmt());
+
+        if (pair.second) {
+            VL_RESTORER(m_offset);
+            m_offset = 0;
+
+            VL_RESTORER(m_dtypeFuncp);
+            VL_RESTORER(m_dtypeSubFuncp);
+            VL_RESTORER(m_subFuncSize);
+            m_dtypeFuncp = *funcpp;
+            newDeclSubFunc();
+            if (AstStructDType* const dtypep = VN_CAST(skipTypep, StructDType)) {
+                declStruct(dtypep, true);
+            } else if (AstUnpackArrayDType* const dtypep = VN_CAST(skipTypep, UnpackArrayDType)) {
+                declUnpackedArray(dtypep, true);
+            } else if (AstPackArrayDType* const dtypep = VN_CAST(skipTypep, PackArrayDType)) {
+                declPackedArray(dtypep, true);
+            } else {
+                UASSERT_OBJ(false, skipTypep, "Creating a trace function for an unexpected type");
+            }
+            m_dtypeFuncp->user1(m_offset);
+        }
+
+        m_dtypeDeclp->codeInc((*funcpp)->user1());
+        m_offset += m_dtypeDeclp->codeInc();
+    }
+    void declUnpackedArray(AstUnpackArrayDType* const nodep, bool newFunc) {
+        string prefixName(newFunc ? "name" : m_traName);
+
+        VL_RESTORER(m_traName);
+        FileLine* const flp = nodep->fileline();
+
+        addToSubFunc(new AstTracePushPrefix{flp, prefixName, VTracePrefixType::ARRAY_UNPACKED,
+                                            nodep->left(), nodep->right(), !newFunc});
+
+        if (VN_IS(nodep->subDTypep()->skipRefToEnump(),
+                  BasicDType)  // Nothing lower than this array
+            && m_traVscp->dtypep()->skipRefToEnump() == nodep) {  // Nothing above this array
+            // Simple 1-D array, use existing V3EmitC runtime loop rather than unrolling
+            // This will put "(index)" at end of signal name for us
+            if (m_traVscp->dtypep()->skipRefToEnump()->isString()) {
+                addIgnore("Unsupported: strings");
+            } else {
+                m_traName = "";
+                addTraceDecl(nodep->declRange(), 0);
+            }
+        } else {
+            AstNodeDType* const subtypep = nodep->subDTypep()->skipRefToEnump();
+            // Always iterate left index to right index
+            const int inc = nodep->rangep()->ascending() ? 1 : -1;
+            for (int i = nodep->left(); i != nodep->right() + inc; i += inc) {
+                VL_RESTORER(m_traValuep);
+                m_traName = '[' + std::to_string(i) + ']';
+                m_traValuep = m_traValuep->cloneTree(false);
+                m_traValuep = new AstArraySel{flp, m_traValuep, i - nodep->lo()};
+                m_traValuep->dtypep(subtypep);
+                iterate(subtypep);
+                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
+            }
+        }
+
+        addToSubFunc(new AstTracePopPrefix{flp});
+    }
+    void declPackedArray(AstPackArrayDType* const nodep, bool newFunc) {
+        string prefixName(newFunc ? "name" : m_traName);
+        AstNodeDType* const subtypep = nodep->subDTypep()->skipRefToEnump();
+
+        VL_RESTORER(m_traName);
+        FileLine* const flp = nodep->fileline();
+
+        addToSubFunc(new AstTracePushPrefix{flp, prefixName, VTracePrefixType::ARRAY_PACKED,
+                                            nodep->left(), nodep->right(), !newFunc});
+
+        // Always iterate left index to right index
+        const int inc = nodep->rangep()->ascending() ? 1 : -1;
+        for (int i = nodep->left(); i != nodep->right() + inc; i += inc) {
+            VL_RESTORER(m_traValuep);
+            m_traName = '[' + std::to_string(i) + ']';
+            const int lsb = (i - nodep->lo()) * subtypep->width();
+            m_traValuep = m_traValuep->cloneTree(false);
+            m_traValuep = new AstSel{flp, m_traValuep, lsb, subtypep->width()};
+            m_traValuep->dtypep(subtypep);
+            iterate(subtypep);
+            VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = nullptr);
+        }
+
+        addToSubFunc(new AstTracePopPrefix{flp});
+    }
+    void declStruct(AstStructDType* const nodep, bool newFunc) {
+        FileLine* const flp = nodep->fileline();
+        string prefixName(newFunc ? "name" : m_traName);
+        int nMembers = 0;
+        for (AstNode* mp = nodep->membersp(); mp; mp = mp->nextp()) ++nMembers;
+        if (!nodep->packed()) {
+            addToSubFunc(new AstTracePushPrefix{flp, prefixName,  //
+                                                VTracePrefixType::STRUCT_UNPACKED, nMembers, 0,
+                                                !newFunc});
+            for (const AstMemberDType *itemp = nodep->membersp(), *nextp; itemp; itemp = nextp) {
+                nextp = VN_AS(itemp->nextp(), MemberDType);
+                AstNodeDType* const subtypep = itemp->subDTypep()->skipRefToEnump();
+                m_traName = itemp->prettyName();
+                VL_RESTORER(m_traValuep);
+                m_traValuep = m_traValuep->cloneTree(false);
+                m_traValuep = new AstStructSel{flp, m_traValuep, itemp->name()};
+                m_traValuep->dtypep(subtypep);
+                iterate(subtypep);
+                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
+            }
+            addToSubFunc(new AstTracePopPrefix{flp});
+        } else {
+            addToSubFunc(new AstTracePushPrefix{flp, prefixName,  //
+                                                VTracePrefixType::STRUCT_PACKED, nMembers, 0,
+                                                !newFunc});
+            for (const AstMemberDType *itemp = nodep->membersp(), *nextp; itemp; itemp = nextp) {
+                nextp = VN_AS(itemp->nextp(), MemberDType);
+                AstNodeDType* const subtypep = itemp->subDTypep()->skipRefToEnump();
+                m_traName = itemp->prettyName();
+                VL_RESTORER(m_traValuep);
+                m_traValuep = m_traValuep->cloneTree(false);
+                m_traValuep = new AstSel{flp, m_traValuep, itemp->lsb(), subtypep->width()};
+                m_traValuep->dtypep(subtypep);
+                iterate(subtypep);
+                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
+            }
+            addToSubFunc(new AstTracePopPrefix{flp});
+        }
+    }
+
     // VISITORS
     void visit(AstScope* nodep) override {
         UINFO(9, "visit " << nodep);
@@ -545,10 +765,14 @@ class TraceDeclVisitor final : public VNVisitor {
     // VISITORS - Data types when tracing
     void visit(AstConstDType* nodep) override {
         if (!m_traVscp) return;
+        VL_RESTORER(m_offset);
+        VL_RESTORER(m_skipDtypeFunc);
+        m_skipDtypeFunc = true;
         iterate(nodep->subDTypep()->skipRefToEnump());
     }
     void visit(AstRefDType* nodep) override {
         if (!m_traVscp) return;
+        VL_RESTORER(m_offset);
         iterate(nodep->subDTypep()->skipRefToEnump());
     }
     void visit(AstIfaceRefDType* /*nodep*/) override {
@@ -570,39 +794,22 @@ class TraceDeclVisitor final : public VNVisitor {
             return;
         }
 
-        VL_RESTORER(m_traName);
-        FileLine* const flp = nodep->fileline();
-
-        addToSubFunc(new AstTracePushPrefix{flp, m_traName, VTracePrefixType::ARRAY_UNPACKED,
-                                            nodep->left(), nodep->right()});
-
-        if (VN_IS(nodep->subDTypep()->skipRefToEnump(),
-                  BasicDType)  // Nothing lower than this array
-            && m_traVscp->dtypep()->skipRefToEnump() == nodep) {  // Nothing above this array
-            // Simple 1-D array, use existing V3EmitC runtime loop rather than unrolling
-            // This will put "(index)" at end of signal name for us
-            if (m_traVscp->dtypep()->skipRefToEnump()->isString()) {
-                addIgnore("Unsupported: strings");
-            } else {
-                m_traName = "";
-                addTraceDecl(nodep->declRange(), 0);
-            }
-        } else {
-            AstNodeDType* const subtypep = nodep->subDTypep()->skipRefToEnump();
-            // Always iterate left index to right index
-            const int inc = nodep->rangep()->ascending() ? 1 : -1;
-            for (int i = nodep->left(); i != nodep->right() + inc; i += inc) {
-                VL_RESTORER(m_traValuep);
-                m_traName = '[' + std::to_string(i) + ']';
-                m_traValuep = m_traValuep->cloneTree(false);
-                m_traValuep = new AstArraySel{flp, m_traValuep, i - nodep->lo()};
-                m_traValuep->dtypep(subtypep);
-                iterate(subtypep);
-                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
-            }
+        // Skip unpacked arrays of non-traceable leaf types (e.g. strings)
+        if (VN_IS(nodep->subDTypep()->skipRefToEnump(), BasicDType)
+            && nodep->subDTypep()->skipRefToEnump()->isString()) {
+            addIgnore("Unsupported: strings");
+            return;
         }
 
-        addToSubFunc(new AstTracePopPrefix{flp});
+        VL_RESTORER(m_skipDtypeFunc);
+        VL_RESTORER(m_dtypeDeclp);
+        if (isBasicIO()) m_skipDtypeFunc = true;
+
+        if (!(m_skipDtypeFunc || m_dtypeDeclp)) {
+            VL_RESTORER(m_offset);
+            newDeclFunc(nodep);
+        }
+        declUnpackedArray(nodep, false);
     }
     void visit(AstPackArrayDType* nodep) override {
         if (!m_traVscp) return;
@@ -625,26 +832,15 @@ class TraceDeclVisitor final : public VNVisitor {
             }
         }
 
-        VL_RESTORER(m_traName);
-        FileLine* const flp = nodep->fileline();
+        VL_RESTORER(m_skipDtypeFunc);
+        VL_RESTORER(m_dtypeDeclp);
+        if (isBasicIO()) m_skipDtypeFunc = true;
 
-        addToSubFunc(new AstTracePushPrefix{flp, m_traName, VTracePrefixType::ARRAY_PACKED,
-                                            nodep->left(), nodep->right()});
-
-        // Always iterate left index to right index
-        const int inc = nodep->rangep()->ascending() ? 1 : -1;
-        for (int i = nodep->left(); i != nodep->right() + inc; i += inc) {
-            VL_RESTORER(m_traValuep);
-            m_traName = '[' + std::to_string(i) + ']';
-            const int lsb = (i - nodep->lo()) * subtypep->width();
-            m_traValuep = m_traValuep->cloneTree(false);
-            m_traValuep = new AstSel{flp, m_traValuep, lsb, subtypep->width()};
-            m_traValuep->dtypep(subtypep);
-            iterate(subtypep);
-            VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = nullptr);
+        if (!(m_skipDtypeFunc || m_dtypeDeclp)) {
+            VL_RESTORER(m_offset);
+            newDeclFunc(nodep);
         }
-
-        addToSubFunc(new AstTracePopPrefix{flp});
+        declPackedArray(nodep, false);
     }
     void visit(AstStructDType* nodep) override {
         if (!m_traVscp) return;
@@ -657,47 +853,26 @@ class TraceDeclVisitor final : public VNVisitor {
             return;
         }
 
-        VL_RESTORER(m_traName);
-        FileLine* const flp = nodep->fileline();
+        VL_RESTORER(m_skipDtypeFunc);
+        VL_RESTORER(m_dtypeDeclp);
+        if (isBasicIO()) m_skipDtypeFunc = true;
 
-        int nMembers = 0;
-        for (AstNode* mp = nodep->membersp(); mp; mp = mp->nextp()) ++nMembers;
-
-        if (!nodep->packed()) {
-            addToSubFunc(new AstTracePushPrefix{flp, m_traName,  //
-                                                VTracePrefixType::STRUCT_UNPACKED, nMembers});
-            for (const AstMemberDType *itemp = nodep->membersp(), *nextp; itemp; itemp = nextp) {
-                nextp = VN_AS(itemp->nextp(), MemberDType);
-                AstNodeDType* const subtypep = itemp->subDTypep()->skipRefToEnump();
-                m_traName = itemp->prettyName();
-                VL_RESTORER(m_traValuep);
-                m_traValuep = m_traValuep->cloneTree(false);
-                m_traValuep = new AstStructSel{flp, m_traValuep, itemp->name()};
-                m_traValuep->dtypep(subtypep);
-                iterate(subtypep);
-                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
-            }
-            addToSubFunc(new AstTracePopPrefix{flp});
-        } else {
-            addToSubFunc(new AstTracePushPrefix{flp, m_traName,  //
-                                                VTracePrefixType::STRUCT_PACKED, nMembers});
-            for (const AstMemberDType *itemp = nodep->membersp(), *nextp; itemp; itemp = nextp) {
-                nextp = VN_AS(itemp->nextp(), MemberDType);
-                AstNodeDType* const subtypep = itemp->subDTypep()->skipRefToEnump();
-                m_traName = itemp->prettyName();
-                VL_RESTORER(m_traValuep);
-                m_traValuep = m_traValuep->cloneTree(false);
-                m_traValuep = new AstSel{flp, m_traValuep, itemp->lsb(), subtypep->width()};
-                m_traValuep->dtypep(subtypep);
-                iterate(subtypep);
-                VL_DO_DANGLING(m_traValuep->deleteTree(), m_traValuep);
-            }
-            addToSubFunc(new AstTracePopPrefix{flp});
+        // Only create sub functions for top-level structs, i.e. don't have struct funcs
+        // call other struct funcs for child types.  This could easily be done for decl funcs
+        // but full / chg funcs would require copying / aligning data for child types or more
+        // complicated / wonky / generalized data access.
+        if (!(m_skipDtypeFunc || m_dtypeDeclp)) {
+            VL_RESTORER(m_offset);
+            newDeclFunc(nodep);
         }
+        declStruct(nodep, false);
     }
     void visit(AstUnionDType* nodep) override {
         if (!m_traVscp) return;
 
+        VL_RESTORER(m_skipDtypeFunc);
+        m_skipDtypeFunc = true;
+
         if (nodep->packed() && !v3Global.opt.traceStructs()) {
             // Everything downstream is packed, so deal with as one trace unit
             // This may not be the nicest for user presentation, but is

test_regress/driver.py

@@ -2634,49 +2634,85 @@ class VlTest:
             case _:
                 self.error("Unknown trace file format " + traceFn)
 
-    def _vcd_read(self, filename: str) -> dict:
-        data = {}
+    @staticmethod
+    def _vcd_parse_header(filename: str, root_scope: 'str | None' = None) -> 'tuple[dict, dict]':
+        """Parse VCD header into hierarchy data and signal-code mapping.
+
+        Returns (hier_data, var_codes) where:
+          hier_data: dict used by _vcd_read for hierarchy comparison
+                     (scope paths -> scope description, var paths -> $var prefix,
+                      attr paths -> $attrbegin text)
+          var_codes: dict mapping 'scope.signal' -> VCD code identifier
+        """
+        hier_data: dict = {}
+        var_codes: dict = {}
+        hier_stack = [root_scope] if root_scope else []
+        attr: list = []
         with open(filename, 'r', encoding='latin-1') as fh:
-            hier_stack = ["TOP"]
-            var = []
-            attr = []
             for line in fh:
-                match1 = re.search(r'\$scope (\S*)\s+(\S+)', line)
-                match2 = re.search(r'(\$var \S+\s+\d+\s+)\S+\s+(.+)\s+\$end', line)
-                match3 = re.search(r'(\$attrbegin .* \$end)', line)
-                line = line.rstrip()
-                # print("VR"+ ' '*len(hier_stack) +" L " + line)
-                if match1:  # $scope
-                    name = match1.group(2)
-                    # print("VR"+ ' '*len(hier_stack) +" scope " + line)
-                    hier_stack += [name]
+                m_scope = re.search(r'\$scope\s+(\S*)\s+(\S+)', line)
+                m_var = re.search(r'(\$var\s+\S+\s+\d+\s+)(\S+)\s+(.+)\s+\$end', line)
+                m_attr = re.search(r'(\$attrbegin .* \$end)', line)
+                if m_scope:
+                    scope_type = m_scope.group(1)
+                    name = m_scope.group(2)
+                    hier_stack.append(name)
                     scope = '.'.join(hier_stack)
-                    data[scope] = match1.group(1) + " " + name
+                    hier_data[scope] = scope_type + " " + name
                     if attr:
-                        data[scope + "#"] = " ".join(attr)
+                        hier_data[scope + "#"] = " ".join(attr)
                         attr = []
-                elif match2:  # $var
-                    # print("VR"+ ' '*len(hier_stack) +" var " + line)
+                elif m_var:
                     scope = '.'.join(hier_stack)
-                    var = match2.group(2)
-                    data[scope + "." + var] = match2.group(1)
+                    decl_prefix = m_var.group(1)
+                    code = m_var.group(2)
+                    var_name = m_var.group(3)
+                    hier_data[scope + "." + var_name] = decl_prefix
                     if attr:
-                        data[scope + "." + var + "#"] = " ".join(attr)
+                        hier_data[scope + "." + var_name + "#"] = " ".join(attr)
                         attr = []
-                elif match3:  # $attrbegin
-                    # print("VR"+ ' '*len(hier_stack) +" attr " + line)
-                    attr.append(match3.group(1))
+                    bare_name = var_name.split()[0]
+                    var_codes[scope + "." + bare_name] = code
+                elif m_attr:
+                    attr.append(m_attr.group(1))
                 elif re.search(r'\$enddefinitions', line):
                     break
                 n = len(re.findall(r'\$upscope', line))
                 if n:
-                    for i in range(0, n):  # pylint: disable=unused-variable
-                        # print("VR"+ ' '*len(hier_stack) +" upscope " + line)
+                    for _i in range(0, n):
                         hier_stack.pop()
-            if attr:
-                self.error(f"Unhandled attribute: {attr}")
+        return hier_data, var_codes
+
+    def _vcd_read(self, filename: str) -> dict:
+        data, _ = self._vcd_parse_header(filename, root_scope="TOP")
         return data
 
+    def vcd_extract_codes(self, filename: str) -> dict:
+        _, codes = self._vcd_parse_header(filename)
+        return codes
+
+    def vcd_check_aliased(self, codes: dict, sig_a: str, sig_b: str) -> None:
+        code_a = codes.get(sig_a)
+        code_b = codes.get(sig_b)
+        if code_a is None:
+            self.error(f"Signal '{sig_a}' not found in VCD")
+        if code_b is None:
+            self.error(f"Signal '{sig_b}' not found in VCD")
+        if code_a != code_b:
+            self.error(f"Expected '{sig_a}' (code {code_a}) to alias "
+                       f"'{sig_b}' (code {code_b})")
+
+    def vcd_check_not_aliased(self, codes: dict, sig_a: str, sig_b: str) -> None:
+        code_a = codes.get(sig_a)
+        code_b = codes.get(sig_b)
+        if code_a is None:
+            self.error(f"Signal '{sig_a}' not found in VCD")
+        if code_b is None:
+            self.error(f"Signal '{sig_b}' not found in VCD")
+        if code_a == code_b:
+            self.error(f"Expected '{sig_a}' and '{sig_b}' to have different codes, "
+                       f"both have code {code_a}")
+
     def inline_checks(self) -> None:
         covfn = self.coverage_filename
         contents = self.file_contents(covfn)
@@ -2771,7 +2807,7 @@ class VlTest:
         contents = self.file_contents(filename)
         if contents == "_Already_Errored_":
             return
-        count = len(re.findall(regexp, contents))
+        count = len(re.findall(regexp, contents, re.MULTILINE))
         if expcount != count:
             self.error("File_grep_count: " + filename + ": Got='" + str(count) + "' Expected='" +
                        str(expcount) + "' in regexp: '" + regexp + "'")
@@ -2781,7 +2817,7 @@ class VlTest:
             contents = self.file_contents(filename)
             if contents == "_Already_Errored_":
                 return
-            match = re.search(regexp, contents)
+            match = re.search(regexp, contents, re.MULTILINE)
             if match:
                 if expvalue is not None and str(expvalue) != match.group(1):
                     self.error("file_grep: " + filename + ": Got='" + match.group(1) +

test_regress/t/t_cast_signed.v

@@ -13,7 +13,6 @@ module t;
   initial begin
     smaller = 8'hfa;
     bigger = bigger_t'(signed'(smaller));
-    $display("%x", bigger);  // NOCOMMIT
     if (bigger != 16'hfffa) $stop;
 
     $write("*-* All Finished *-*\n");

test_regress/t/t_mem_trace_split.py

@@ -14,8 +14,11 @@ test.scenarios('simulator')
 test.compile(verilator_flags2=["--trace-vcd", "--trace-structs", "--output-split-ctrace", "32"])
 
 if test.vlt_all:
-    test.file_grep_count(test.obj_dir + "/V" + test.name + "__Trace__0.cpp",
-                         r'void Vt.*trace_chg_.*sub.*{', 3)
+    test.file_grep_count(
+        test.obj_dir + "/V" + test.name + "__Trace__0.cpp",
+        # dtype sub funcs prevent trace_chg splitting, but --vltmt still forces three of them
+        r'void Vt.*trace_chg_.*sub.*{',
+        3 if test.vltmt else 1)
 
 test.execute()
 

test_regress/t/t_trace_abort_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:24 2026
+Tue Apr 14 15:20:27 2026
 
 $end
 $version

test_regress/t/t_trace_abort_cc_vcd.out

@@ -1,51 +1,50 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
-
  $scope module top $end
-  $var wire 1 # clk $end
+  $var wire 1 " clk $end
   $scope module t $end
-   $var wire 1 # clk $end
-   $var wire 3 $ cyc [2:0] $end
+   $var wire 1 " clk $end
+   $var wire 3 # cyc [2:0] $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
-b000 $
+0"
+b000 #
 #10
-1#
-b001 $
+1"
+b001 #
 #15
-0#
+0"
 #20
-1#
-b010 $
+1"
+b010 #
 #25
-0#
+0"
 #30
-1#
-b011 $
+1"
+b011 #
 #35
-0#
+0"
 #40
-1#
-b100 $
+1"
+b100 #
 #45
-0#
+0"
 #50
-1#
-b101 $
+1"
+b101 #
 #55
-0#
+0"
 #60
-1#
-b110 $
+1"
+b110 #
 #65
-0#
+0"
 #70
-1#
-b111 $
+1"
+b111 #
 #75
-0#
+0"

test_regress/t/t_trace_abort_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:46 2026
+Tue Apr 14 15:20:28 2026
 
 $end
 $version

test_regress/t/t_trace_array_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:42 2026
+Tue Apr 14 15:20:28 2026
 
 $end
 $version

test_regress/t/t_trace_array_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:51 2026
+Tue Apr 14 15:20:31 2026
 
 $end
 $version

test_regress/t/t_trace_ascendingrange_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:14 2026
+Tue Apr 14 15:20:31 2026
 
 $end
 $version

test_regress/t/t_trace_ascendingrange_cc_vcd.out

@@ -1,142 +1,141 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
-
  $scope module top $end
-  $var wire 1 } clk $end
+  $var wire 1 | clk $end
   $scope module t $end
-   $var wire 8 ~ P [0:7] $end
-   $var wire 1 } clk $end
-   $var wire 32 # cyc [31:0] $end
-   $var wire 8 !! Q [0:7] $end
-   $var wire 1 $ v_a [0:0] $end
-   $var wire 2 % v_b [0:1] $end
-   $var wire 8 & v_c [0:7] $end
-   $var wire 9 ' v_d [0:8] $end
-   $var wire 16 ( v_e [0:15] $end
-   $var wire 17 ) v_f [0:16] $end
-   $var wire 32 * v_g [0:31] $end
-   $var wire 33 + v_h [0:32] $end
-   $var wire 64 - v_i [0:63] $end
-   $var wire 65 / v_j [0:64] $end
-   $var wire 128 2 v_k [0:127] $end
-   $var wire 129 6 v_l [0:128] $end
-   $var wire 256 ; v_m [0:255] $end
-   $var wire 257 C v_n [0:256] $end
-   $var wire 512 L v_o [0:511] $end
-   $var wire 3 \ v_p [-1:1] $end
-   $var wire 15 ] v_q [-7:7] $end
-   $var wire 31 ^ v_r [-15:15] $end
-   $var wire 63 _ v_s [-31:31] $end
-   $var wire 127 a v_t [-63:63] $end
-   $var wire 255 e v_u [-127:127] $end
-   $var wire 511 m v_v [-255:255] $end
+   $var wire 8 } P [0:7] $end
+   $var wire 1 | clk $end
+   $var wire 32 " cyc [31:0] $end
+   $var wire 8 ~ Q [0:7] $end
+   $var wire 1 # v_a [0:0] $end
+   $var wire 2 $ v_b [0:1] $end
+   $var wire 8 % v_c [0:7] $end
+   $var wire 9 & v_d [0:8] $end
+   $var wire 16 ' v_e [0:15] $end
+   $var wire 17 ( v_f [0:16] $end
+   $var wire 32 ) v_g [0:31] $end
+   $var wire 33 * v_h [0:32] $end
+   $var wire 64 , v_i [0:63] $end
+   $var wire 65 . v_j [0:64] $end
+   $var wire 128 1 v_k [0:127] $end
+   $var wire 129 5 v_l [0:128] $end
+   $var wire 256 : v_m [0:255] $end
+   $var wire 257 B v_n [0:256] $end
+   $var wire 512 K v_o [0:511] $end
+   $var wire 3 [ v_p [-1:1] $end
+   $var wire 15 \ v_q [-7:7] $end
+   $var wire 31 ] v_r [-15:15] $end
+   $var wire 63 ^ v_s [-31:31] $end
+   $var wire 127 ` v_t [-63:63] $end
+   $var wire 255 d v_u [-127:127] $end
+   $var wire 511 l v_v [-255:255] $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
-0$
-b00 %
-b00000000 &
-b000000000 '
-b0000000000000000 (
-b00000000000000000 )
-b00000000000000000000000000000000 *
-b000000000000000000000000000000000 +
-b0000000000000000000000000000000000000000000000000000000000000000 -
-b00000000000000000000000000000000000000000000000000000000000000000 /
-b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 2
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 6
-b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ;
-b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 C
-b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 L
-b000 \
-b000000000000000 ]
-b0000000000000000000000000000000 ^
-b000000000000000000000000000000000000000000000000000000000000000 _
-b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 a
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 e
-b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 m
-0}
-b00001010 ~
-b00010100 !!
+b00000000000000000000000000000000 "
+0#
+b00 $
+b00000000 %
+b000000000 &
+b0000000000000000 '
+b00000000000000000 (
+b00000000000000000000000000000000 )
+b000000000000000000000000000000000 *
+b0000000000000000000000000000000000000000000000000000000000000000 ,
+b00000000000000000000000000000000000000000000000000000000000000000 .
+b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 1
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 5
+b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 :
+b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 B
+b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 K
+b000 [
+b000000000000000 \
+b0000000000000000000000000000000 ]
+b000000000000000000000000000000000000000000000000000000000000000 ^
+b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 `
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 d
+b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 l
+0|
+b00001010 }
+b00010100 ~
 #10
-b00000000000000000000000000000001 #
-1$
-b11 %
-b11111111 &
-b111111111 '
-b1111111111111111 (
-b11111111111111111 )
-b11111111111111111111111111111111 *
-b111111111111111111111111111111111 +
-b1111111111111111111111111111111111111111111111111111111111111111 -
-b11111111111111111111111111111111111111111111111111111111111111111 /
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 2
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 6
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 ;
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 C
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 L
-b111 \
-b111111111111111 ]
-b1111111111111111111111111111111 ^
-b111111111111111111111111111111111111111111111111111111111111111 _
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 a
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 e
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 m
-1}
+b00000000000000000000000000000001 "
+1#
+b11 $
+b11111111 %
+b111111111 &
+b1111111111111111 '
+b11111111111111111 (
+b11111111111111111111111111111111 )
+b111111111111111111111111111111111 *
+b1111111111111111111111111111111111111111111111111111111111111111 ,
+b11111111111111111111111111111111111111111111111111111111111111111 .
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 1
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 5
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 :
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 B
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 K
+b111 [
+b111111111111111 \
+b1111111111111111111111111111111 ]
+b111111111111111111111111111111111111111111111111111111111111111 ^
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 `
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 d
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 l
+1|
 #15
-0}
+0|
 #20
-b00000000000000000000000000000010 #
-0$
-b10 %
-b11111110 &
-b111111110 '
-b1111111111111110 (
-b11111111111111110 )
-b11111111111111111111111111111110 *
-b111111111111111111111111111111110 +
-b1111111111111111111111111111111111111111111111111111111111111110 -
-b11111111111111111111111111111111111111111111111111111111111111110 /
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 2
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 6
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 ;
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 C
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 L
-b110 \
-b111111111111110 ]
-b1111111111111111111111111111110 ^
-b111111111111111111111111111111111111111111111111111111111111110 _
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 a
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 e
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 m
-1}
+b00000000000000000000000000000010 "
+0#
+b10 $
+b11111110 %
+b111111110 &
+b1111111111111110 '
+b11111111111111110 (
+b11111111111111111111111111111110 )
+b111111111111111111111111111111110 *
+b1111111111111111111111111111111111111111111111111111111111111110 ,
+b11111111111111111111111111111111111111111111111111111111111111110 .
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 1
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 5
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 :
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 B
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 K
+b110 [
+b111111111111110 \
+b1111111111111111111111111111110 ]
+b111111111111111111111111111111111111111111111111111111111111110 ^
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 `
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 d
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110 l
+1|
 #25
-0}
+0|
 #30
-b00000000000000000000000000000011 #
-b00 %
-b11111100 &
-b111111100 '
-b1111111111111100 (
-b11111111111111100 )
-b11111111111111111111111111111100 *
-b111111111111111111111111111111100 +
-b1111111111111111111111111111111111111111111111111111111111111100 -
-b11111111111111111111111111111111111111111111111111111111111111100 /
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 2
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 6
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 ;
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 C
-b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 L
-b100 \
-b111111111111100 ]
-b1111111111111111111111111111100 ^
-b111111111111111111111111111111111111111111111111111111111111100 _
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 a
-b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 e
-b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 m
-1}
+b00000000000000000000000000000011 "
+b00 $
+b11111100 %
+b111111100 &
+b1111111111111100 '
+b11111111111111100 (
+b11111111111111111111111111111100 )
+b111111111111111111111111111111100 *
+b1111111111111111111111111111111111111111111111111111111111111100 ,
+b11111111111111111111111111111111111111111111111111111111111111100 .
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 1
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 5
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 :
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 B
+b11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 K
+b100 [
+b111111111111100 \
+b1111111111111111111111111111100 ]
+b111111111111111111111111111111111111111111111111111111111111100 ^
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 `
+b111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 d
+b1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100 l
+1|

test_regress/t/t_trace_ascendingrange_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:01 2026
+Tue Apr 14 15:20:31 2026
 
 $end
 $version

test_regress/t/t_trace_basic_cc_vcd.out

@@ -7,33 +7,33 @@ $timescale 1ps $end
   $scope module t $end
    $var wire 1 & clk $end
    $var wire 5 ' state [4:0] $end
-   $var wire 1 , fst_inout $end
+   $var wire 1 - fst_inout $end
    $var wire 32 ( cyc [31:0] $end
    $var wire 1 ) rstn $end
-   $var real 64 - fst_gparam_real $end
-   $var real 64 / fst_lparam_real $end
-   $var real 64 - fst_real $end
-   $var wire 32 1 fst_integer [31:0] $end
-   $var wire 1 2 fst_bit $end
-   $var wire 1 3 fst_logic $end
-   $var wire 32 4 fst_int [31:0] $end
-   $var wire 16 5 fst_shortint [15:0] $end
-   $var wire 64 6 fst_longint [63:0] $end
-   $var wire 8 8 fst_byte [7:0] $end
+   $var real 64 . fst_gparam_real $end
+   $var real 64 0 fst_lparam_real $end
+   $var real 64 . fst_real $end
+   $var wire 32 2 fst_integer [31:0] $end
+   $var wire 1 3 fst_bit $end
+   $var wire 1 4 fst_logic $end
+   $var wire 32 5 fst_int [31:0] $end
+   $var wire 16 6 fst_shortint [15:0] $end
+   $var wire 64 7 fst_longint [63:0] $end
+   $var wire 8 9 fst_byte [7:0] $end
    $var wire 64 * fst_time [63:0] $end
-   $var wire 32 9 fst_parameter [31:0] $end
-   $var wire 32 : fst_lparam [31:0] $end
-   $var wire 1 , fst_supply0 $end
-   $var wire 1 ; fst_supply1 $end
-   $var wire 1 , fst_tri0 $end
-   $var wire 1 ; fst_tri1 $end
-   $var wire 1 < fst_tri $end
-   $var wire 1 = fst_triand $end
-   $var wire 1 > fst_trior $end
-   $var wire 1 ? fst_wand $end
-   $var wire 1 @ fst_wor $end
-   $var wire 1 A fst_wire $end
-   $var wire 1 B fst_uwire $end
+   $var wire 32 : fst_parameter [31:0] $end
+   $var wire 32 ; fst_lparam [31:0] $end
+   $var wire 1 - fst_supply0 $end
+   $var wire 1 < fst_supply1 $end
+   $var wire 1 - fst_tri0 $end
+   $var wire 1 < fst_tri1 $end
+   $var wire 1 = fst_tri $end
+   $var wire 1 > fst_triand $end
+   $var wire 1 ? fst_trior $end
+   $var wire 1 @ fst_wand $end
+   $var wire 1 A fst_wor $end
+   $var wire 1 B fst_wire $end
+   $var wire 1 C fst_uwire $end
    $scope module test $end
     $var wire 1 & clk $end
     $var wire 1 ) rstn $end
@@ -59,25 +59,26 @@ b00000000000000000000000000000000 (
 0)
 b0000000000000000000000000000000000000000000000000000000000000000 *
 0,
-r1.23 -
-r4.56 /
-b00000000000000000000000000000000 1
-02
+0-
+r1.23 .
+r4.56 0
+b00000000000000000000000000000000 2
 03
-b00000000000000000000000000000000 4
-b0000000000000000 5
-b0000000000000000000000000000000000000000000000000000000000000000 6
-b00000000 8
-b00000000000000000000000001111011 9
-b00000000000000000000000111001000 :
-1;
-0<
+04
+b00000000000000000000000000000000 5
+b0000000000000000 6
+b0000000000000000000000000000000000000000000000000000000000000000 7
+b00000000 9
+b00000000000000000000000001111011 :
+b00000000000000000000000111001000 ;
+1<
 0=
 0>
 0?
 0@
 0A
 0B
+0C
 #10
 b10100 "
 b00001 #

test_regress/t/t_trace_basic_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:04 2026
+Tue Apr 14 15:20:34 2026
 
 $end
 $version

test_regress/t/t_trace_binary.out

@@ -1,12 +1,12 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module t $end
-  $var wire 32 # sig [31:0] $end
+  $var wire 32 " sig [31:0] $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000001010 #
+b00000000000000000000000000001010 "
 #20
-b00000000000000000000000000010100 #
+b00000000000000000000000000010100 "

test_regress/t/t_trace_cat_renew_fst_part_0000.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:00 2026
+Tue Apr 14 15:20:35 2026
 
 $end
 $version

test_regress/t/t_trace_cat_renew_fst_part_0100.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:49 2026
+Tue Apr 14 15:21:24 2026
 
 $end
 $version

test_regress/t/t_trace_cat_reopen_fst_part_0000.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:55 2026
+Tue Apr 14 15:20:36 2026
 
 $end
 $version

test_regress/t/t_trace_cat_reopen_fst_part_0100.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:45 2026
+Tue Apr 14 15:21:24 2026
 
 $end
 $version

test_regress/t/t_trace_class.out

@@ -1,10 +1,10 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module $unit::Cls__P0__Vclpkg $end
-  $var wire 32 # PARAM [31:0] $end
+  $var wire 32 " PARAM [31:0] $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
+b00000000000000000000000000000000 "

test_regress/t/t_trace_complex.v

@@ -38,6 +38,7 @@ module t (
   typedef strp_t arru_strp_t[4:3];
 
   strp_t v_strp;
+  strp_t v_strp2;
   strp_strp_t v_strp_strp;
   unip_strp_t v_unip_strp;
   arrp_t v_arrp;
@@ -98,6 +99,7 @@ module t (
   always @(posedge clk) begin
     cyc <= cyc + 1;
     v_strp <= ~v_strp;
+    v_strp2 <= ~v_strp2;
     v_strp_strp <= ~v_strp_strp;
     v_unip_strp <= ~v_unip_strp;
     v_arrp_strp <= ~v_arrp_strp;

test_regress/t/t_trace_complex_default_cc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:16:56 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:37 2026
+=======
+Tue Mar 31 17:14:29 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -19,106 +23,108 @@ $end
    $var wire 1 ! clk $end
    $var integer 32 # cyc [31:0] $end
    $var bit 2 $ v_strp [1:0] $end
-   $var bit 4 % v_strp_strp [3:0] $end
-   $var bit 2 & v_unip_strp [1:0] $end
-   $var bit 2 ' v_arrp [2:1] $end
-   $var bit 4 ( v_arrp_arrp [3:0] $end
-   $var bit 4 ) v_arrp_strp [3:0] $end
+   $var bit 2 % v_strp2 [1:0] $end
+   $var bit 4 & v_strp_strp [3:0] $end
+   $var bit 2 ' v_unip_strp [1:0] $end
+   $var bit 2 ( v_arrp [2:1] $end
+   $var bit 4 ) v_arrp_arrp [3:0] $end
+   $var bit 4 * v_arrp_strp [3:0] $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 * v_arru[2] $end
-    $var bit 1 + v_arru[1] $end
+    $var bit 1 + v_arru[2] $end
+    $var bit 1 , v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 , v_arru_arru[4][2] $end
-     $var bit 1 - v_arru_arru[4][1] $end
+     $var bit 1 - v_arru_arru[4][2] $end
+     $var bit 1 . v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 . v_arru_arru[3][2] $end
-     $var bit 1 / v_arru_arru[3][1] $end
+     $var bit 1 / v_arru_arru[3][2] $end
+     $var bit 1 0 v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 0 v_arru_arrp[4] [2:1] $end
-    $var bit 2 1 v_arru_arrp[3] [2:1] $end
+    $var bit 2 1 v_arru_arrp[4] [2:1] $end
+    $var bit 2 2 v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
-    $var bit 2 2 v_arru_strp[4] [1:0] $end
-    $var bit 2 3 v_arru_strp[3] [1:0] $end
+    $var bit 2 3 v_arru_strp[4] [1:0] $end
+    $var bit 2 4 v_arru_strp[3] [1:0] $end
    $upscope $end
-   $var real 64 4 v_real $end
+   $var real 64 5 v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 5 v_arr_real[0] $end
-    $var real 64 6 v_arr_real[1] $end
+    $var real 64 6 v_arr_real[0] $end
+    $var real 64 7 v_arr_real[1] $end
    $upscope $end
-   $var longint 64 7 v_chandle [63:0] $end
-   $var logic 64 8 v_str32x2 [63:0] $end
+   $var longint 64 8 v_chandle [63:0] $end
+   $var logic 64 9 v_str32x2 [63:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 9 v_enumed [31:0] $end
+   $var int 32 : v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 : v_enumed2 [31:0] $end
+   $var int 32 ; v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 ; v_enumb [2:0] $end
-   $var logic 6 < v_enumb2_str [5:0] $end
+   $var logic 3 < v_enumb [2:0] $end
+   $var logic 6 = v_enumb2_str [5:0] $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 = unpacked_array[-2] [7:0] $end
-    $var logic 8 > unpacked_array[-1] [7:0] $end
-    $var logic 8 ? unpacked_array[0] [7:0] $end
+    $var logic 8 > unpacked_array[-2] [7:0] $end
+    $var logic 8 ? unpacked_array[-1] [7:0] $end
+    $var logic 8 @ unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 @ LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 A LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var parameter 32 A PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var parameter 32 B PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var parameter 32 C PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var parameter 32 D PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-b00000000000000000000000000000011 C
-b00000000000000000000000000000010 B
-b00000000000000000000000000000100 A
-0@
+b00000000000000000000000000000011 D
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 B
+0A
+b00000000 @
 b00000000 ?
 b00000000 >
-b00000000 =
-b000000 <
-b000 ;
+b000000 =
+b000 <
+b00000000000000000000000000000000 ;
 b00000000000000000000000000000000 :
-b00000000000000000000000000000000 9
-b0000000000000000000000000000000000000000000000000000000011111111 8
-b0000000000000000000000000000000000000000000000000000000000000000 7
+b0000000000000000000000000000000000000000000000000000000011111111 9
+b0000000000000000000000000000000000000000000000000000000000000000 8
+r0 7
 r0 6
 r0 5
-r0 4
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+00
 0/
 0.
 0-
 0,
 0+
-0*
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000000 #
 1"
@@ -128,134 +134,140 @@ $end
 1!
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.1 4
-r0.2 5
-r0.3 6
-b0000000000000000000000000000000100000000000000000000000011111110 8
-b00000000000000000000000000000001 9
-b00000000000000000000000000000010 :
-b111 ;
+b11 4
+r0.1 5
+r0.2 6
+r0.3 7
+b0000000000000000000000000000000100000000000000000000000011111110 9
+b00000000000000000000000000000001 :
+b00000000000000000000000000000010 ;
+b111 <
 #15
 0!
 #20
 1!
-b110 ;
-b00000000000000000000000000000100 :
-b00000000000000000000000000000010 9
-b0000000000000000000000000000001000000000000000000000000011111101 8
-r0.6 6
-r0.4 5
-r0.2 4
+b110 <
+b00000000000000000000000000000100 ;
+b00000000000000000000000000000010 :
+b0000000000000000000000000000001000000000000000000000000011111101 9
+r0.6 7
+r0.4 6
+r0.2 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000010 #
-b111111 <
+b111111 =
 #25
 0!
 #30
 1!
-b110110 <
+b110110 =
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.3 4
-r0.6000000000000001 5
-r0.8999999999999999 6
-b0000000000000000000000000000001100000000000000000000000011111100 8
-b00000000000000000000000000000011 9
-b00000000000000000000000000000110 :
-b101 ;
+b11 4
+r0.3 5
+r0.6000000000000001 6
+r0.8999999999999999 7
+b0000000000000000000000000000001100000000000000000000000011111100 9
+b00000000000000000000000000000011 :
+b00000000000000000000000000000110 ;
+b101 <
 #35
 0!
 #40
 1!
-b100 ;
-b00000000000000000000000000001000 :
-b00000000000000000000000000000100 9
-b0000000000000000000000000000010000000000000000000000000011111011 8
-r1.2 6
-r0.8 5
-r0.4 4
+b100 <
+b00000000000000000000000000001000 ;
+b00000000000000000000000000000100 :
+b0000000000000000000000000000010000000000000000000000000011111011 9
+r1.2 7
+r0.8 6
+r0.4 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000100 #
-b101101 <
+b101101 =
 #45
 0!
 #50
 1!
-b100100 <
+b100100 =
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.5 4
-r1 5
-r1.5 6
-b0000000000000000000000000000010100000000000000000000000011111010 8
-b00000000000000000000000000000101 9
-b00000000000000000000000000001010 :
-b011 ;
+b11 4
+r0.5 5
+r1 6
+r1.5 7
+b0000000000000000000000000000010100000000000000000000000011111010 9
+b00000000000000000000000000000101 :
+b00000000000000000000000000001010 ;
+b011 <
 #55
 0!
 #60
 1!
-b010 ;
-b00000000000000000000000000001100 :
-b00000000000000000000000000000110 9
-b0000000000000000000000000000011000000000000000000000000011111001 8
-r1.8 6
-r1.2 5
-r0.6 4
+b010 <
+b00000000000000000000000000001100 ;
+b00000000000000000000000000000110 :
+b0000000000000000000000000000011000000000000000000000000011111001 9
+r1.8 7
+r1.2 6
+r0.6 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000110 #
-b011011 <
+b011011 =

test_regress/t/t_trace_complex_default_cc_saif.out

@@ -52,6 +52,8 @@
     (cyc\[31\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_strp\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_strp2\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_strp2\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[2\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
@@ -68,20 +70,20 @@
     (v_arrp_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_strp\[2\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_strp\[3\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru[2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arru[4][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arrp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_arrp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_strp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_strp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_strp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_strp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_strp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_strp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_real\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))

test_regress/t/t_trace_complex_default_cc_vcd.out

@@ -1,51 +1,52 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 : clk $end
+  $var wire 1 ; clk $end
   $scope module $unit $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 : clk $end
+   $var wire 1 ; clk $end
    $var wire 32 # cyc [31:0] $end
    $var wire 2 $ v_strp [1:0] $end
-   $var wire 4 % v_strp_strp [3:0] $end
-   $var wire 2 & v_unip_strp [1:0] $end
-   $var wire 2 ' v_arrp [2:1] $end
-   $var wire 4 ( v_arrp_arrp [3:0] $end
-   $var wire 4 ) v_arrp_strp [3:0] $end
-   $var wire 1 ; v_arru[1] $end
+   $var wire 2 % v_strp2 [1:0] $end
+   $var wire 4 & v_strp_strp [3:0] $end
+   $var wire 2 ' v_unip_strp [1:0] $end
+   $var wire 2 ( v_arrp [2:1] $end
+   $var wire 4 ) v_arrp_arrp [3:0] $end
+   $var wire 4 * v_arrp_strp [3:0] $end
    $var wire 1 < v_arru[2] $end
-   $var wire 1 = v_arru_arru[3][1] $end
-   $var wire 1 > v_arru_arru[3][2] $end
+   $var wire 1 = v_arru[1] $end
+   $var wire 1 > v_arru_arru[4][2] $end
    $var wire 1 ? v_arru_arru[4][1] $end
-   $var wire 1 @ v_arru_arru[4][2] $end
-   $var wire 2 * v_arru_arrp[3] [2:1] $end
+   $var wire 1 @ v_arru_arru[3][2] $end
+   $var wire 1 A v_arru_arru[3][1] $end
    $var wire 2 + v_arru_arrp[4] [2:1] $end
-   $var wire 2 , v_arru_strp[3] [1:0] $end
+   $var wire 2 , v_arru_arrp[3] [2:1] $end
    $var wire 2 - v_arru_strp[4] [1:0] $end
-   $var real 64 . v_real $end
-   $var real 64 0 v_arr_real[0] $end
-   $var real 64 2 v_arr_real[1] $end
-   $var wire 64 A v_chandle [63:0] $end
-   $var wire 64 4 v_str32x2 [63:0] $end
-   $var wire 32 6 v_enumed [31:0] $end
-   $var wire 32 7 v_enumed2 [31:0] $end
-   $var wire 3 8 v_enumb [2:0] $end
-   $var wire 6 9 v_enumb2_str [5:0] $end
-   $var wire 8 C unpacked_array[-2] [7:0] $end
-   $var wire 8 D unpacked_array[-1] [7:0] $end
-   $var wire 8 E unpacked_array[0] [7:0] $end
-   $var wire 1 F LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 2 . v_arru_strp[3] [1:0] $end
+   $var real 64 / v_real $end
+   $var real 64 1 v_arr_real[0] $end
+   $var real 64 3 v_arr_real[1] $end
+   $var wire 64 B v_chandle [63:0] $end
+   $var wire 64 5 v_str32x2 [63:0] $end
+   $var wire 32 7 v_enumed [31:0] $end
+   $var wire 32 8 v_enumed2 [31:0] $end
+   $var wire 3 9 v_enumb [2:0] $end
+   $var wire 6 : v_enumb2_str [5:0] $end
+   $var wire 8 D unpacked_array[-2] [7:0] $end
+   $var wire 8 E unpacked_array[-1] [7:0] $end
+   $var wire 8 F unpacked_array[0] [7:0] $end
+   $var wire 1 G LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var wire 32 G PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var wire 32 H PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var wire 32 I PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var wire 32 J PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
@@ -55,170 +56,177 @@ $enddefinitions $end
 1"
 b00000000000000000000000000000000 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0 .
-r0 0
-r0 2
-b0000000000000000000000000000000000000000000000000000000011111111 4
-b00000000000000000000000000000000 6
+b00 .
+r0 /
+r0 1
+r0 3
+b0000000000000000000000000000000000000000000000000000000011111111 5
 b00000000000000000000000000000000 7
-b000 8
-b000000 9
-0:
+b00000000000000000000000000000000 8
+b000 9
+b000000 :
 0;
 0<
 0=
 0>
 0?
 0@
-b0000000000000000000000000000000000000000000000000000000000000000 A
-b00000000 C
+0A
+b0000000000000000000000000000000000000000000000000000000000000000 B
 b00000000 D
 b00000000 E
-0F
-b00000000000000000000000000000100 G
-b00000000000000000000000000000010 H
-b00000000000000000000000000000011 I
+b00000000 F
+0G
+b00000000000000000000000000000100 H
+b00000000000000000000000000000010 I
+b00000000000000000000000000000011 J
 #10
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.1 .
-r0.2 0
-r0.3 2
-b0000000000000000000000000000000100000000000000000000000011111110 4
-b00000000000000000000000000000001 6
-b00000000000000000000000000000010 7
-b111 8
-1:
+b11 .
+r0.1 /
+r0.2 1
+r0.3 3
+b0000000000000000000000000000000100000000000000000000000011111110 5
+b00000000000000000000000000000001 7
+b00000000000000000000000000000010 8
+b111 9
+1;
 #15
-0:
+0;
 #20
 b00000000000000000000000000000010 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.2 .
-r0.4 0
-r0.6 2
-b0000000000000000000000000000001000000000000000000000000011111101 4
-b00000000000000000000000000000010 6
-b00000000000000000000000000000100 7
-b110 8
-b111111 9
-1:
+b00 .
+r0.2 /
+r0.4 1
+r0.6 3
+b0000000000000000000000000000001000000000000000000000000011111101 5
+b00000000000000000000000000000010 7
+b00000000000000000000000000000100 8
+b110 9
+b111111 :
+1;
 #25
-0:
+0;
 #30
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.3 .
-r0.6000000000000001 0
-r0.8999999999999999 2
-b0000000000000000000000000000001100000000000000000000000011111100 4
-b00000000000000000000000000000011 6
-b00000000000000000000000000000110 7
-b101 8
-b110110 9
-1:
+b11 .
+r0.3 /
+r0.6000000000000001 1
+r0.8999999999999999 3
+b0000000000000000000000000000001100000000000000000000000011111100 5
+b00000000000000000000000000000011 7
+b00000000000000000000000000000110 8
+b101 9
+b110110 :
+1;
 #35
-0:
+0;
 #40
 b00000000000000000000000000000100 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.4 .
-r0.8 0
-r1.2 2
-b0000000000000000000000000000010000000000000000000000000011111011 4
-b00000000000000000000000000000100 6
-b00000000000000000000000000001000 7
-b100 8
-b101101 9
-1:
+b00 .
+r0.4 /
+r0.8 1
+r1.2 3
+b0000000000000000000000000000010000000000000000000000000011111011 5
+b00000000000000000000000000000100 7
+b00000000000000000000000000001000 8
+b100 9
+b101101 :
+1;
 #45
-0:
+0;
 #50
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.5 .
-r1 0
-r1.5 2
-b0000000000000000000000000000010100000000000000000000000011111010 4
-b00000000000000000000000000000101 6
-b00000000000000000000000000001010 7
-b011 8
-b100100 9
-1:
+b11 .
+r0.5 /
+r1 1
+r1.5 3
+b0000000000000000000000000000010100000000000000000000000011111010 5
+b00000000000000000000000000000101 7
+b00000000000000000000000000001010 8
+b011 9
+b100100 :
+1;
 #55
-0:
+0;
 #60
 b00000000000000000000000000000110 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.6 .
-r1.2 0
-r1.8 2
-b0000000000000000000000000000011000000000000000000000000011111001 4
-b00000000000000000000000000000110 6
-b00000000000000000000000000001100 7
-b010 8
-b011011 9
-1:
+b00 .
+r0.6 /
+r1.2 1
+r1.8 3
+b0000000000000000000000000000011000000000000000000000000011111001 5
+b00000000000000000000000000000110 7
+b00000000000000000000000000001100 8
+b010 9
+b011011 :
+1;

test_regress/t/t_trace_complex_default_sc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:16:46 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:39 2026
+=======
+Tue Mar 31 17:14:34 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -18,106 +22,108 @@ $end
    $var wire 1 " clk $end
    $var integer 32 # cyc [31:0] $end
    $var bit 2 $ v_strp [1:0] $end
-   $var bit 4 % v_strp_strp [3:0] $end
-   $var bit 2 & v_unip_strp [1:0] $end
-   $var bit 2 ' v_arrp [2:1] $end
-   $var bit 4 ( v_arrp_arrp [3:0] $end
-   $var bit 4 ) v_arrp_strp [3:0] $end
+   $var bit 2 % v_strp2 [1:0] $end
+   $var bit 4 & v_strp_strp [3:0] $end
+   $var bit 2 ' v_unip_strp [1:0] $end
+   $var bit 2 ( v_arrp [2:1] $end
+   $var bit 4 ) v_arrp_arrp [3:0] $end
+   $var bit 4 * v_arrp_strp [3:0] $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 * v_arru[2] $end
-    $var bit 1 + v_arru[1] $end
+    $var bit 1 + v_arru[2] $end
+    $var bit 1 , v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 , v_arru_arru[4][2] $end
-     $var bit 1 - v_arru_arru[4][1] $end
+     $var bit 1 - v_arru_arru[4][2] $end
+     $var bit 1 . v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 . v_arru_arru[3][2] $end
-     $var bit 1 / v_arru_arru[3][1] $end
+     $var bit 1 / v_arru_arru[3][2] $end
+     $var bit 1 0 v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 0 v_arru_arrp[4] [2:1] $end
-    $var bit 2 1 v_arru_arrp[3] [2:1] $end
+    $var bit 2 1 v_arru_arrp[4] [2:1] $end
+    $var bit 2 2 v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
-    $var bit 2 2 v_arru_strp[4] [1:0] $end
-    $var bit 2 3 v_arru_strp[3] [1:0] $end
+    $var bit 2 3 v_arru_strp[4] [1:0] $end
+    $var bit 2 4 v_arru_strp[3] [1:0] $end
    $upscope $end
-   $var real 64 4 v_real $end
+   $var real 64 5 v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 5 v_arr_real[0] $end
-    $var real 64 6 v_arr_real[1] $end
+    $var real 64 6 v_arr_real[0] $end
+    $var real 64 7 v_arr_real[1] $end
    $upscope $end
-   $var longint 64 7 v_chandle [63:0] $end
-   $var logic 64 8 v_str32x2 [63:0] $end
+   $var longint 64 8 v_chandle [63:0] $end
+   $var logic 64 9 v_str32x2 [63:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 9 v_enumed [31:0] $end
+   $var int 32 : v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 : v_enumed2 [31:0] $end
+   $var int 32 ; v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 ; v_enumb [2:0] $end
-   $var logic 6 < v_enumb2_str [5:0] $end
+   $var logic 3 < v_enumb [2:0] $end
+   $var logic 6 = v_enumb2_str [5:0] $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 = unpacked_array[-2] [7:0] $end
-    $var logic 8 > unpacked_array[-1] [7:0] $end
-    $var logic 8 ? unpacked_array[0] [7:0] $end
+    $var logic 8 > unpacked_array[-2] [7:0] $end
+    $var logic 8 ? unpacked_array[-1] [7:0] $end
+    $var logic 8 @ unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 @ LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 A LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var parameter 32 A PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var parameter 32 B PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var parameter 32 C PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var parameter 32 D PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-b00000000000000000000000000000011 C
-b00000000000000000000000000000010 B
-b00000000000000000000000000000100 A
-0@
+b00000000000000000000000000000011 D
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 B
+0A
+b00000000 @
 b00000000 ?
 b00000000 >
-b00000000 =
-b000000 <
-b000 ;
+b000000 =
+b000 <
+b00000000000000000000000000000000 ;
 b00000000000000000000000000000000 :
-b00000000000000000000000000000000 9
-b0000000000000000000000000000000000000000000000000000000011111111 8
-b0000000000000000000000000000000000000000000000000000000000000000 7
+b0000000000000000000000000000000000000000000000000000000011111111 9
+b0000000000000000000000000000000000000000000000000000000000000000 8
+r0 7
 r0 6
 r0 5
-r0 4
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+00
 0/
 0.
 0-
 0,
 0+
-0*
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000000 #
 0"
@@ -127,135 +133,141 @@ $end
 1"
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.1 4
-r0.2 5
-r0.3 6
-b0000000000000000000000000000000100000000000000000000000011111110 8
-b00000000000000000000000000000001 9
-b00000000000000000000000000000010 :
-b111 ;
+b11 4
+r0.1 5
+r0.2 6
+r0.3 7
+b0000000000000000000000000000000100000000000000000000000011111110 9
+b00000000000000000000000000000001 :
+b00000000000000000000000000000010 ;
+b111 <
 #15
 0"
 #20
 1"
-b110 ;
-b00000000000000000000000000000100 :
-b00000000000000000000000000000010 9
-b0000000000000000000000000000001000000000000000000000000011111101 8
-r0.6 6
-r0.4 5
-r0.2 4
+b110 <
+b00000000000000000000000000000100 ;
+b00000000000000000000000000000010 :
+b0000000000000000000000000000001000000000000000000000000011111101 9
+r0.6 7
+r0.4 6
+r0.2 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000010 #
-b111111 <
+b111111 =
 #25
 0"
 #30
 1"
-b110110 <
+b110110 =
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.3 4
-r0.6000000000000001 5
-r0.8999999999999999 6
-b0000000000000000000000000000001100000000000000000000000011111100 8
-b00000000000000000000000000000011 9
-b00000000000000000000000000000110 :
-b101 ;
+b11 4
+r0.3 5
+r0.6000000000000001 6
+r0.8999999999999999 7
+b0000000000000000000000000000001100000000000000000000000011111100 9
+b00000000000000000000000000000011 :
+b00000000000000000000000000000110 ;
+b101 <
 #35
 0"
 #40
 1"
-b100 ;
-b00000000000000000000000000001000 :
-b00000000000000000000000000000100 9
-b0000000000000000000000000000010000000000000000000000000011111011 8
-r1.2 6
-r0.8 5
-r0.4 4
+b100 <
+b00000000000000000000000000001000 ;
+b00000000000000000000000000000100 :
+b0000000000000000000000000000010000000000000000000000000011111011 9
+r1.2 7
+r0.8 6
+r0.4 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000100 #
-b101101 <
+b101101 =
 #45
 0"
 #50
 1"
-b100100 <
+b100100 =
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.5 4
-r1 5
-r1.5 6
-b0000000000000000000000000000010100000000000000000000000011111010 8
-b00000000000000000000000000000101 9
-b00000000000000000000000000001010 :
-b011 ;
+b11 4
+r0.5 5
+r1 6
+r1.5 7
+b0000000000000000000000000000010100000000000000000000000011111010 9
+b00000000000000000000000000000101 :
+b00000000000000000000000000001010 ;
+b011 <
 #55
 0"
 #60
 1"
-b010 ;
-b00000000000000000000000000001100 :
-b00000000000000000000000000000110 9
-b0000000000000000000000000000011000000000000000000000000011111001 8
-r1.8 6
-r1.2 5
-r0.6 4
+b010 <
+b00000000000000000000000000001100 ;
+b00000000000000000000000000000110 :
+b0000000000000000000000000000011000000000000000000000000011111001 9
+r1.8 7
+r1.2 6
+r0.6 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000110 #
-b011011 <
+b011011 =
 #64

test_regress/t/t_trace_complex_default_sc_vcd.out

@@ -5,46 +5,47 @@ $timescale 1ps $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 : clk $end
+   $var wire 1 ; clk $end
    $var wire 32 # cyc [31:0] $end
    $var wire 2 $ v_strp [1:0] $end
-   $var wire 4 % v_strp_strp [3:0] $end
-   $var wire 2 & v_unip_strp [1:0] $end
-   $var wire 2 ' v_arrp [2:1] $end
-   $var wire 4 ( v_arrp_arrp [3:0] $end
-   $var wire 4 ) v_arrp_strp [3:0] $end
-   $var wire 1 ; v_arru[2] $end
-   $var wire 1 < v_arru[1] $end
-   $var wire 1 = v_arru_arru[4][2] $end
-   $var wire 1 > v_arru_arru[4][1] $end
-   $var wire 1 ? v_arru_arru[3][2] $end
-   $var wire 1 @ v_arru_arru[3][1] $end
-   $var wire 2 * v_arru_arrp[4] [2:1] $end
-   $var wire 2 + v_arru_arrp[3] [2:1] $end
-   $var wire 2 , v_arru_strp[4] [1:0] $end
-   $var wire 2 - v_arru_strp[3] [1:0] $end
-   $var real 64 . v_real $end
-   $var real 64 0 v_arr_real[0] $end
-   $var real 64 2 v_arr_real[1] $end
-   $var wire 64 A v_chandle [63:0] $end
-   $var wire 64 4 v_str32x2 [63:0] $end
-   $var wire 32 6 v_enumed [31:0] $end
-   $var wire 32 7 v_enumed2 [31:0] $end
-   $var wire 3 8 v_enumb [2:0] $end
-   $var wire 6 9 v_enumb2_str [5:0] $end
-   $var wire 8 C unpacked_array[-2] [7:0] $end
-   $var wire 8 D unpacked_array[-1] [7:0] $end
-   $var wire 8 E unpacked_array[0] [7:0] $end
-   $var wire 1 F LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 2 % v_strp2 [1:0] $end
+   $var wire 4 & v_strp_strp [3:0] $end
+   $var wire 2 ' v_unip_strp [1:0] $end
+   $var wire 2 ( v_arrp [2:1] $end
+   $var wire 4 ) v_arrp_arrp [3:0] $end
+   $var wire 4 * v_arrp_strp [3:0] $end
+   $var wire 1 < v_arru[2] $end
+   $var wire 1 = v_arru[1] $end
+   $var wire 1 > v_arru_arru[4][2] $end
+   $var wire 1 ? v_arru_arru[4][1] $end
+   $var wire 1 @ v_arru_arru[3][2] $end
+   $var wire 1 A v_arru_arru[3][1] $end
+   $var wire 2 + v_arru_arrp[4] [2:1] $end
+   $var wire 2 , v_arru_arrp[3] [2:1] $end
+   $var wire 2 - v_arru_strp[4] [1:0] $end
+   $var wire 2 . v_arru_strp[3] [1:0] $end
+   $var real 64 / v_real $end
+   $var real 64 1 v_arr_real[0] $end
+   $var real 64 3 v_arr_real[1] $end
+   $var wire 64 B v_chandle [63:0] $end
+   $var wire 64 5 v_str32x2 [63:0] $end
+   $var wire 32 7 v_enumed [31:0] $end
+   $var wire 32 8 v_enumed2 [31:0] $end
+   $var wire 3 9 v_enumb [2:0] $end
+   $var wire 6 : v_enumb2_str [5:0] $end
+   $var wire 8 D unpacked_array[-2] [7:0] $end
+   $var wire 8 E unpacked_array[-1] [7:0] $end
+   $var wire 8 F unpacked_array[0] [7:0] $end
+   $var wire 1 G LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var wire 32 G PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var wire 32 H PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var wire 32 I PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var wire 32 J PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
@@ -54,171 +55,178 @@ $enddefinitions $end
 1"
 b00000000000000000000000000000000 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0 .
-r0 0
-r0 2
-b0000000000000000000000000000000000000000000000000000000011111111 4
-b00000000000000000000000000000000 6
+b00 .
+r0 /
+r0 1
+r0 3
+b0000000000000000000000000000000000000000000000000000000011111111 5
 b00000000000000000000000000000000 7
-b000 8
-b000000 9
-0:
+b00000000000000000000000000000000 8
+b000 9
+b000000 :
 0;
 0<
 0=
 0>
 0?
 0@
-b0000000000000000000000000000000000000000000000000000000000000000 A
-b00000000 C
+0A
+b0000000000000000000000000000000000000000000000000000000000000000 B
 b00000000 D
 b00000000 E
-0F
-b00000000000000000000000000000100 G
-b00000000000000000000000000000010 H
-b00000000000000000000000000000011 I
+b00000000 F
+0G
+b00000000000000000000000000000100 H
+b00000000000000000000000000000010 I
+b00000000000000000000000000000011 J
 #10
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.1 .
-r0.2 0
-r0.3 2
-b0000000000000000000000000000000100000000000000000000000011111110 4
-b00000000000000000000000000000001 6
-b00000000000000000000000000000010 7
-b111 8
-1:
+b11 .
+r0.1 /
+r0.2 1
+r0.3 3
+b0000000000000000000000000000000100000000000000000000000011111110 5
+b00000000000000000000000000000001 7
+b00000000000000000000000000000010 8
+b111 9
+1;
 #15
-0:
+0;
 #20
 b00000000000000000000000000000010 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.2 .
-r0.4 0
-r0.6 2
-b0000000000000000000000000000001000000000000000000000000011111101 4
-b00000000000000000000000000000010 6
-b00000000000000000000000000000100 7
-b110 8
-b111111 9
-1:
+b00 .
+r0.2 /
+r0.4 1
+r0.6 3
+b0000000000000000000000000000001000000000000000000000000011111101 5
+b00000000000000000000000000000010 7
+b00000000000000000000000000000100 8
+b110 9
+b111111 :
+1;
 #25
-0:
+0;
 #30
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.3 .
-r0.6000000000000001 0
-r0.8999999999999999 2
-b0000000000000000000000000000001100000000000000000000000011111100 4
-b00000000000000000000000000000011 6
-b00000000000000000000000000000110 7
-b101 8
-b110110 9
-1:
+b11 .
+r0.3 /
+r0.6000000000000001 1
+r0.8999999999999999 3
+b0000000000000000000000000000001100000000000000000000000011111100 5
+b00000000000000000000000000000011 7
+b00000000000000000000000000000110 8
+b101 9
+b110110 :
+1;
 #35
-0:
+0;
 #40
 b00000000000000000000000000000100 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.4 .
-r0.8 0
-r1.2 2
-b0000000000000000000000000000010000000000000000000000000011111011 4
-b00000000000000000000000000000100 6
-b00000000000000000000000000001000 7
-b100 8
-b101101 9
-1:
+b00 .
+r0.4 /
+r0.8 1
+r1.2 3
+b0000000000000000000000000000010000000000000000000000000011111011 5
+b00000000000000000000000000000100 7
+b00000000000000000000000000001000 8
+b100 9
+b101101 :
+1;
 #45
-0:
+0;
 #50
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.5 .
-r1 0
-r1.5 2
-b0000000000000000000000000000010100000000000000000000000011111010 4
-b00000000000000000000000000000101 6
-b00000000000000000000000000001010 7
-b011 8
-b100100 9
-1:
+b11 .
+r0.5 /
+r1 1
+r1.5 3
+b0000000000000000000000000000010100000000000000000000000011111010 5
+b00000000000000000000000000000101 7
+b00000000000000000000000000001010 8
+b011 9
+b100100 :
+1;
 #55
-0:
+0;
 #60
 b00000000000000000000000000000110 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.6 .
-r1.2 0
-r1.8 2
-b0000000000000000000000000000011000000000000000000000000011111001 4
-b00000000000000000000000000000110 6
-b00000000000000000000000000001100 7
-b010 8
-b011011 9
-1:
+b00 .
+r0.6 /
+r1.2 1
+r1.8 3
+b0000000000000000000000000000011000000000000000000000000011111001 5
+b00000000000000000000000000000110 7
+b00000000000000000000000000001100 8
+b010 9
+b011011 :
+1;
 #64

test_regress/t/t_trace_complex_params_cc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:16:42 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:39 2026
+=======
+Tue Mar 31 17:14:36 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -19,106 +23,108 @@ $end
    $var wire 1 ! clk $end
    $var integer 32 # cyc [31:0] $end
    $var bit 2 $ v_strp [1:0] $end
-   $var bit 4 % v_strp_strp [3:0] $end
-   $var bit 2 & v_unip_strp [1:0] $end
-   $var bit 2 ' v_arrp [2:1] $end
-   $var bit 4 ( v_arrp_arrp [3:0] $end
-   $var bit 4 ) v_arrp_strp [3:0] $end
+   $var bit 2 % v_strp2 [1:0] $end
+   $var bit 4 & v_strp_strp [3:0] $end
+   $var bit 2 ' v_unip_strp [1:0] $end
+   $var bit 2 ( v_arrp [2:1] $end
+   $var bit 4 ) v_arrp_arrp [3:0] $end
+   $var bit 4 * v_arrp_strp [3:0] $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 * v_arru[2] $end
-    $var bit 1 + v_arru[1] $end
+    $var bit 1 + v_arru[2] $end
+    $var bit 1 , v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 , v_arru_arru[4][2] $end
-     $var bit 1 - v_arru_arru[4][1] $end
+     $var bit 1 - v_arru_arru[4][2] $end
+     $var bit 1 . v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 . v_arru_arru[3][2] $end
-     $var bit 1 / v_arru_arru[3][1] $end
+     $var bit 1 / v_arru_arru[3][2] $end
+     $var bit 1 0 v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 0 v_arru_arrp[4] [2:1] $end
-    $var bit 2 1 v_arru_arrp[3] [2:1] $end
+    $var bit 2 1 v_arru_arrp[4] [2:1] $end
+    $var bit 2 2 v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
-    $var bit 2 2 v_arru_strp[4] [1:0] $end
-    $var bit 2 3 v_arru_strp[3] [1:0] $end
+    $var bit 2 3 v_arru_strp[4] [1:0] $end
+    $var bit 2 4 v_arru_strp[3] [1:0] $end
    $upscope $end
-   $var real 64 4 v_real $end
+   $var real 64 5 v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 5 v_arr_real[0] $end
-    $var real 64 6 v_arr_real[1] $end
+    $var real 64 6 v_arr_real[0] $end
+    $var real 64 7 v_arr_real[1] $end
    $upscope $end
-   $var longint 64 7 v_chandle [63:0] $end
-   $var logic 64 8 v_str32x2 [63:0] $end
+   $var longint 64 8 v_chandle [63:0] $end
+   $var logic 64 9 v_str32x2 [63:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 9 v_enumed [31:0] $end
+   $var int 32 : v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 : v_enumed2 [31:0] $end
+   $var int 32 ; v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 ; v_enumb [2:0] $end
-   $var logic 6 < v_enumb2_str [5:0] $end
+   $var logic 3 < v_enumb [2:0] $end
+   $var logic 6 = v_enumb2_str [5:0] $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 = unpacked_array[-2] [7:0] $end
-    $var logic 8 > unpacked_array[-1] [7:0] $end
-    $var logic 8 ? unpacked_array[0] [7:0] $end
+    $var logic 8 > unpacked_array[-2] [7:0] $end
+    $var logic 8 ? unpacked_array[-1] [7:0] $end
+    $var logic 8 @ unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 @ LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 A LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var parameter 32 A PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var parameter 32 B PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var parameter 32 C PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var parameter 32 D PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-b00000000000000000000000000000011 C
-b00000000000000000000000000000010 B
-b00000000000000000000000000000100 A
-0@
+b00000000000000000000000000000011 D
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 B
+0A
+b00000000 @
 b00000000 ?
 b00000000 >
-b00000000 =
-b000000 <
-b000 ;
+b000000 =
+b000 <
+b00000000000000000000000000000000 ;
 b00000000000000000000000000000000 :
-b00000000000000000000000000000000 9
-b0000000000000000000000000000000000000000000000000000000011111111 8
-b0000000000000000000000000000000000000000000000000000000000000000 7
+b0000000000000000000000000000000000000000000000000000000011111111 9
+b0000000000000000000000000000000000000000000000000000000000000000 8
+r0 7
 r0 6
 r0 5
-r0 4
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+00
 0/
 0.
 0-
 0,
 0+
-0*
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000000 #
 1"
@@ -128,134 +134,140 @@ $end
 1!
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.1 4
-r0.2 5
-r0.3 6
-b0000000000000000000000000000000100000000000000000000000011111110 8
-b00000000000000000000000000000001 9
-b00000000000000000000000000000010 :
-b111 ;
+b11 4
+r0.1 5
+r0.2 6
+r0.3 7
+b0000000000000000000000000000000100000000000000000000000011111110 9
+b00000000000000000000000000000001 :
+b00000000000000000000000000000010 ;
+b111 <
 #15
 0!
 #20
 1!
-b110 ;
-b00000000000000000000000000000100 :
-b00000000000000000000000000000010 9
-b0000000000000000000000000000001000000000000000000000000011111101 8
-r0.6 6
-r0.4 5
-r0.2 4
+b110 <
+b00000000000000000000000000000100 ;
+b00000000000000000000000000000010 :
+b0000000000000000000000000000001000000000000000000000000011111101 9
+r0.6 7
+r0.4 6
+r0.2 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000010 #
-b111111 <
+b111111 =
 #25
 0!
 #30
 1!
-b110110 <
+b110110 =
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.3 4
-r0.6000000000000001 5
-r0.8999999999999999 6
-b0000000000000000000000000000001100000000000000000000000011111100 8
-b00000000000000000000000000000011 9
-b00000000000000000000000000000110 :
-b101 ;
+b11 4
+r0.3 5
+r0.6000000000000001 6
+r0.8999999999999999 7
+b0000000000000000000000000000001100000000000000000000000011111100 9
+b00000000000000000000000000000011 :
+b00000000000000000000000000000110 ;
+b101 <
 #35
 0!
 #40
 1!
-b100 ;
-b00000000000000000000000000001000 :
-b00000000000000000000000000000100 9
-b0000000000000000000000000000010000000000000000000000000011111011 8
-r1.2 6
-r0.8 5
-r0.4 4
+b100 <
+b00000000000000000000000000001000 ;
+b00000000000000000000000000000100 :
+b0000000000000000000000000000010000000000000000000000000011111011 9
+r1.2 7
+r0.8 6
+r0.4 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000100 #
-b101101 <
+b101101 =
 #45
 0!
 #50
 1!
-b100100 <
+b100100 =
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.5 4
-r1 5
-r1.5 6
-b0000000000000000000000000000010100000000000000000000000011111010 8
-b00000000000000000000000000000101 9
-b00000000000000000000000000001010 :
-b011 ;
+b11 4
+r0.5 5
+r1 6
+r1.5 7
+b0000000000000000000000000000010100000000000000000000000011111010 9
+b00000000000000000000000000000101 :
+b00000000000000000000000000001010 ;
+b011 <
 #55
 0!
 #60
 1!
-b010 ;
-b00000000000000000000000000001100 :
-b00000000000000000000000000000110 9
-b0000000000000000000000000000011000000000000000000000000011111001 8
-r1.8 6
-r1.2 5
-r0.6 4
+b010 <
+b00000000000000000000000000001100 ;
+b00000000000000000000000000000110 :
+b0000000000000000000000000000011000000000000000000000000011111001 9
+r1.8 7
+r1.2 6
+r0.6 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000110 #
-b011011 <
+b011011 =

test_regress/t/t_trace_complex_params_cc_saif.out

@@ -52,6 +52,8 @@
     (cyc\[31\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_strp\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_strp2\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_strp2\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_strp_strp\[2\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
@@ -68,20 +70,20 @@
     (v_arrp_strp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_strp\[2\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_strp\[3\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru[2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arru[4][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arrp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_arrp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_strp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_strp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_strp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_strp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_strp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_strp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_real\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))

test_regress/t/t_trace_complex_params_cc_vcd.out

@@ -1,44 +1,45 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 : clk $end
+  $var wire 1 ; clk $end
   $scope module $unit $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 : clk $end
+   $var wire 1 ; clk $end
    $var wire 32 # cyc [31:0] $end
    $var wire 2 $ v_strp [1:0] $end
-   $var wire 4 % v_strp_strp [3:0] $end
-   $var wire 2 & v_unip_strp [1:0] $end
-   $var wire 2 ' v_arrp [2:1] $end
-   $var wire 4 ( v_arrp_arrp [3:0] $end
-   $var wire 4 ) v_arrp_strp [3:0] $end
-   $var wire 1 ; v_arru[1] $end
+   $var wire 2 % v_strp2 [1:0] $end
+   $var wire 4 & v_strp_strp [3:0] $end
+   $var wire 2 ' v_unip_strp [1:0] $end
+   $var wire 2 ( v_arrp [2:1] $end
+   $var wire 4 ) v_arrp_arrp [3:0] $end
+   $var wire 4 * v_arrp_strp [3:0] $end
    $var wire 1 < v_arru[2] $end
-   $var wire 1 = v_arru_arru[3][1] $end
-   $var wire 1 > v_arru_arru[3][2] $end
+   $var wire 1 = v_arru[1] $end
+   $var wire 1 > v_arru_arru[4][2] $end
    $var wire 1 ? v_arru_arru[4][1] $end
-   $var wire 1 @ v_arru_arru[4][2] $end
-   $var wire 2 * v_arru_arrp[3] [2:1] $end
+   $var wire 1 @ v_arru_arru[3][2] $end
+   $var wire 1 A v_arru_arru[3][1] $end
    $var wire 2 + v_arru_arrp[4] [2:1] $end
-   $var wire 2 , v_arru_strp[3] [1:0] $end
+   $var wire 2 , v_arru_arrp[3] [2:1] $end
    $var wire 2 - v_arru_strp[4] [1:0] $end
-   $var real 64 . v_real $end
-   $var real 64 0 v_arr_real[0] $end
-   $var real 64 2 v_arr_real[1] $end
-   $var wire 64 A v_chandle [63:0] $end
-   $var wire 64 4 v_str32x2 [63:0] $end
-   $var wire 32 6 v_enumed [31:0] $end
-   $var wire 32 7 v_enumed2 [31:0] $end
-   $var wire 3 8 v_enumb [2:0] $end
-   $var wire 6 9 v_enumb2_str [5:0] $end
-   $var wire 8 C unpacked_array[-2] [7:0] $end
-   $var wire 8 D unpacked_array[-1] [7:0] $end
-   $var wire 8 E unpacked_array[0] [7:0] $end
-   $var wire 1 F LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 2 . v_arru_strp[3] [1:0] $end
+   $var real 64 / v_real $end
+   $var real 64 1 v_arr_real[0] $end
+   $var real 64 3 v_arr_real[1] $end
+   $var wire 64 B v_chandle [63:0] $end
+   $var wire 64 5 v_str32x2 [63:0] $end
+   $var wire 32 7 v_enumed [31:0] $end
+   $var wire 32 8 v_enumed2 [31:0] $end
+   $var wire 3 9 v_enumb [2:0] $end
+   $var wire 6 : v_enumb2_str [5:0] $end
+   $var wire 8 D unpacked_array[-2] [7:0] $end
+   $var wire 8 E unpacked_array[-1] [7:0] $end
+   $var wire 8 F unpacked_array[0] [7:0] $end
+   $var wire 1 G LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var wire 32 G PARAM [31:0] $end
+    $var wire 32 J PARAM [31:0] $end
    $upscope $end
    $scope module p2 $end
     $var wire 32 H PARAM [31:0] $end
@@ -55,170 +56,177 @@ $enddefinitions $end
 1"
 b00000000000000000000000000000000 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0 .
-r0 0
-r0 2
-b0000000000000000000000000000000000000000000000000000000011111111 4
-b00000000000000000000000000000000 6
+b00 .
+r0 /
+r0 1
+r0 3
+b0000000000000000000000000000000000000000000000000000000011111111 5
 b00000000000000000000000000000000 7
-b000 8
-b000000 9
-0:
+b00000000000000000000000000000000 8
+b000 9
+b000000 :
 0;
 0<
 0=
 0>
 0?
 0@
-b0000000000000000000000000000000000000000000000000000000000000000 A
-b00000000 C
+0A
+b0000000000000000000000000000000000000000000000000000000000000000 B
 b00000000 D
 b00000000 E
-0F
-b00000000000000000000000000000100 G
+b00000000 F
+0G
 b00000000000000000000000000000010 H
 b00000000000000000000000000000011 I
+b00000000000000000000000000000100 J
 #10
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.1 .
-r0.2 0
-r0.3 2
-b0000000000000000000000000000000100000000000000000000000011111110 4
-b00000000000000000000000000000001 6
-b00000000000000000000000000000010 7
-b111 8
-1:
+b11 .
+r0.1 /
+r0.2 1
+r0.3 3
+b0000000000000000000000000000000100000000000000000000000011111110 5
+b00000000000000000000000000000001 7
+b00000000000000000000000000000010 8
+b111 9
+1;
 #15
-0:
+0;
 #20
 b00000000000000000000000000000010 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.2 .
-r0.4 0
-r0.6 2
-b0000000000000000000000000000001000000000000000000000000011111101 4
-b00000000000000000000000000000010 6
-b00000000000000000000000000000100 7
-b110 8
-b111111 9
-1:
+b00 .
+r0.2 /
+r0.4 1
+r0.6 3
+b0000000000000000000000000000001000000000000000000000000011111101 5
+b00000000000000000000000000000010 7
+b00000000000000000000000000000100 8
+b110 9
+b111111 :
+1;
 #25
-0:
+0;
 #30
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.3 .
-r0.6000000000000001 0
-r0.8999999999999999 2
-b0000000000000000000000000000001100000000000000000000000011111100 4
-b00000000000000000000000000000011 6
-b00000000000000000000000000000110 7
-b101 8
-b110110 9
-1:
+b11 .
+r0.3 /
+r0.6000000000000001 1
+r0.8999999999999999 3
+b0000000000000000000000000000001100000000000000000000000011111100 5
+b00000000000000000000000000000011 7
+b00000000000000000000000000000110 8
+b101 9
+b110110 :
+1;
 #35
-0:
+0;
 #40
 b00000000000000000000000000000100 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.4 .
-r0.8 0
-r1.2 2
-b0000000000000000000000000000010000000000000000000000000011111011 4
-b00000000000000000000000000000100 6
-b00000000000000000000000000001000 7
-b100 8
-b101101 9
-1:
+b00 .
+r0.4 /
+r0.8 1
+r1.2 3
+b0000000000000000000000000000010000000000000000000000000011111011 5
+b00000000000000000000000000000100 7
+b00000000000000000000000000001000 8
+b100 9
+b101101 :
+1;
 #45
-0:
+0;
 #50
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.5 .
-r1 0
-r1.5 2
-b0000000000000000000000000000010100000000000000000000000011111010 4
-b00000000000000000000000000000101 6
-b00000000000000000000000000001010 7
-b011 8
-b100100 9
-1:
+b11 .
+r0.5 /
+r1 1
+r1.5 3
+b0000000000000000000000000000010100000000000000000000000011111010 5
+b00000000000000000000000000000101 7
+b00000000000000000000000000001010 8
+b011 9
+b100100 :
+1;
 #55
-0:
+0;
 #60
 b00000000000000000000000000000110 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.6 .
-r1.2 0
-r1.8 2
-b0000000000000000000000000000011000000000000000000000000011111001 4
-b00000000000000000000000000000110 6
-b00000000000000000000000000001100 7
-b010 8
-b011011 9
-1:
+b00 .
+r0.6 /
+r1.2 1
+r1.8 3
+b0000000000000000000000000000011000000000000000000000000011111001 5
+b00000000000000000000000000000110 7
+b00000000000000000000000000001100 8
+b010 9
+b011011 :
+1;

test_regress/t/t_trace_complex_params_sc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:17:23 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:41 2026
+=======
+Tue Mar 31 17:14:39 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -18,106 +22,108 @@ $end
    $var wire 1 " clk $end
    $var integer 32 # cyc [31:0] $end
    $var bit 2 $ v_strp [1:0] $end
-   $var bit 4 % v_strp_strp [3:0] $end
-   $var bit 2 & v_unip_strp [1:0] $end
-   $var bit 2 ' v_arrp [2:1] $end
-   $var bit 4 ( v_arrp_arrp [3:0] $end
-   $var bit 4 ) v_arrp_strp [3:0] $end
+   $var bit 2 % v_strp2 [1:0] $end
+   $var bit 4 & v_strp_strp [3:0] $end
+   $var bit 2 ' v_unip_strp [1:0] $end
+   $var bit 2 ( v_arrp [2:1] $end
+   $var bit 4 ) v_arrp_arrp [3:0] $end
+   $var bit 4 * v_arrp_strp [3:0] $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 * v_arru[2] $end
-    $var bit 1 + v_arru[1] $end
+    $var bit 1 + v_arru[2] $end
+    $var bit 1 , v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 , v_arru_arru[4][2] $end
-     $var bit 1 - v_arru_arru[4][1] $end
+     $var bit 1 - v_arru_arru[4][2] $end
+     $var bit 1 . v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 . v_arru_arru[3][2] $end
-     $var bit 1 / v_arru_arru[3][1] $end
+     $var bit 1 / v_arru_arru[3][2] $end
+     $var bit 1 0 v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 0 v_arru_arrp[4] [2:1] $end
-    $var bit 2 1 v_arru_arrp[3] [2:1] $end
+    $var bit 2 1 v_arru_arrp[4] [2:1] $end
+    $var bit 2 2 v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
-    $var bit 2 2 v_arru_strp[4] [1:0] $end
-    $var bit 2 3 v_arru_strp[3] [1:0] $end
+    $var bit 2 3 v_arru_strp[4] [1:0] $end
+    $var bit 2 4 v_arru_strp[3] [1:0] $end
    $upscope $end
-   $var real 64 4 v_real $end
+   $var real 64 5 v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 5 v_arr_real[0] $end
-    $var real 64 6 v_arr_real[1] $end
+    $var real 64 6 v_arr_real[0] $end
+    $var real 64 7 v_arr_real[1] $end
    $upscope $end
-   $var longint 64 7 v_chandle [63:0] $end
-   $var logic 64 8 v_str32x2 [63:0] $end
+   $var longint 64 8 v_chandle [63:0] $end
+   $var logic 64 9 v_str32x2 [63:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 9 v_enumed [31:0] $end
+   $var int 32 : v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 : v_enumed2 [31:0] $end
+   $var int 32 ; v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 ; v_enumb [2:0] $end
-   $var logic 6 < v_enumb2_str [5:0] $end
+   $var logic 3 < v_enumb [2:0] $end
+   $var logic 6 = v_enumb2_str [5:0] $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 = unpacked_array[-2] [7:0] $end
-    $var logic 8 > unpacked_array[-1] [7:0] $end
-    $var logic 8 ? unpacked_array[0] [7:0] $end
+    $var logic 8 > unpacked_array[-2] [7:0] $end
+    $var logic 8 ? unpacked_array[-1] [7:0] $end
+    $var logic 8 @ unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 @ LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 A LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var parameter 32 A PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var parameter 32 B PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var parameter 32 C PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var parameter 32 D PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-b00000000000000000000000000000011 C
-b00000000000000000000000000000010 B
-b00000000000000000000000000000100 A
-0@
+b00000000000000000000000000000011 D
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 B
+0A
+b00000000 @
 b00000000 ?
 b00000000 >
-b00000000 =
-b000000 <
-b000 ;
+b000000 =
+b000 <
+b00000000000000000000000000000000 ;
 b00000000000000000000000000000000 :
-b00000000000000000000000000000000 9
-b0000000000000000000000000000000000000000000000000000000011111111 8
-b0000000000000000000000000000000000000000000000000000000000000000 7
+b0000000000000000000000000000000000000000000000000000000011111111 9
+b0000000000000000000000000000000000000000000000000000000000000000 8
+r0 7
 r0 6
 r0 5
-r0 4
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+00
 0/
 0.
 0-
 0,
 0+
-0*
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000000 #
 0"
@@ -127,135 +133,141 @@ $end
 1"
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.1 4
-r0.2 5
-r0.3 6
-b0000000000000000000000000000000100000000000000000000000011111110 8
-b00000000000000000000000000000001 9
-b00000000000000000000000000000010 :
-b111 ;
+b11 4
+r0.1 5
+r0.2 6
+r0.3 7
+b0000000000000000000000000000000100000000000000000000000011111110 9
+b00000000000000000000000000000001 :
+b00000000000000000000000000000010 ;
+b111 <
 #15
 0"
 #20
 1"
-b110 ;
-b00000000000000000000000000000100 :
-b00000000000000000000000000000010 9
-b0000000000000000000000000000001000000000000000000000000011111101 8
-r0.6 6
-r0.4 5
-r0.2 4
+b110 <
+b00000000000000000000000000000100 ;
+b00000000000000000000000000000010 :
+b0000000000000000000000000000001000000000000000000000000011111101 9
+r0.6 7
+r0.4 6
+r0.2 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000010 #
-b111111 <
+b111111 =
 #25
 0"
 #30
 1"
-b110110 <
+b110110 =
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.3 4
-r0.6000000000000001 5
-r0.8999999999999999 6
-b0000000000000000000000000000001100000000000000000000000011111100 8
-b00000000000000000000000000000011 9
-b00000000000000000000000000000110 :
-b101 ;
+b11 4
+r0.3 5
+r0.6000000000000001 6
+r0.8999999999999999 7
+b0000000000000000000000000000001100000000000000000000000011111100 9
+b00000000000000000000000000000011 :
+b00000000000000000000000000000110 ;
+b101 <
 #35
 0"
 #40
 1"
-b100 ;
-b00000000000000000000000000001000 :
-b00000000000000000000000000000100 9
-b0000000000000000000000000000010000000000000000000000000011111011 8
-r1.2 6
-r0.8 5
-r0.4 4
+b100 <
+b00000000000000000000000000001000 ;
+b00000000000000000000000000000100 :
+b0000000000000000000000000000010000000000000000000000000011111011 9
+r1.2 7
+r0.8 6
+r0.4 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000100 #
-b101101 <
+b101101 =
 #45
 0"
 #50
 1"
-b100100 <
+b100100 =
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 0
+b1111 *
 b11 1
 b11 2
 b11 3
-r0.5 4
-r1 5
-r1.5 6
-b0000000000000000000000000000010100000000000000000000000011111010 8
-b00000000000000000000000000000101 9
-b00000000000000000000000000001010 :
-b011 ;
+b11 4
+r0.5 5
+r1 6
+r1.5 7
+b0000000000000000000000000000010100000000000000000000000011111010 9
+b00000000000000000000000000000101 :
+b00000000000000000000000000001010 ;
+b011 <
 #55
 0"
 #60
 1"
-b010 ;
-b00000000000000000000000000001100 :
-b00000000000000000000000000000110 9
-b0000000000000000000000000000011000000000000000000000000011111001 8
-r1.8 6
-r1.2 5
-r0.6 4
+b010 <
+b00000000000000000000000000001100 ;
+b00000000000000000000000000000110 :
+b0000000000000000000000000000011000000000000000000000000011111001 9
+r1.8 7
+r1.2 6
+r0.6 5
+b00 4
 b00 3
 b00 2
 b00 1
-b00 0
+b0000 *
 b0000 )
-b0000 (
+b00 (
 b00 '
-b00 &
-b0000 %
+b0000 &
+b00 %
 b00 $
 b00000000000000000000000000000110 #
-b011011 <
+b011011 =
 #64

test_regress/t/t_trace_complex_params_sc_vcd.out

@@ -5,46 +5,47 @@ $timescale 1ps $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 : clk $end
+   $var wire 1 ; clk $end
    $var wire 32 # cyc [31:0] $end
    $var wire 2 $ v_strp [1:0] $end
-   $var wire 4 % v_strp_strp [3:0] $end
-   $var wire 2 & v_unip_strp [1:0] $end
-   $var wire 2 ' v_arrp [2:1] $end
-   $var wire 4 ( v_arrp_arrp [3:0] $end
-   $var wire 4 ) v_arrp_strp [3:0] $end
-   $var wire 1 ; v_arru[2] $end
-   $var wire 1 < v_arru[1] $end
-   $var wire 1 = v_arru_arru[4][2] $end
-   $var wire 1 > v_arru_arru[4][1] $end
-   $var wire 1 ? v_arru_arru[3][2] $end
-   $var wire 1 @ v_arru_arru[3][1] $end
-   $var wire 2 * v_arru_arrp[4] [2:1] $end
-   $var wire 2 + v_arru_arrp[3] [2:1] $end
-   $var wire 2 , v_arru_strp[4] [1:0] $end
-   $var wire 2 - v_arru_strp[3] [1:0] $end
-   $var real 64 . v_real $end
-   $var real 64 0 v_arr_real[0] $end
-   $var real 64 2 v_arr_real[1] $end
-   $var wire 64 A v_chandle [63:0] $end
-   $var wire 64 4 v_str32x2 [63:0] $end
-   $var wire 32 6 v_enumed [31:0] $end
-   $var wire 32 7 v_enumed2 [31:0] $end
-   $var wire 3 8 v_enumb [2:0] $end
-   $var wire 6 9 v_enumb2_str [5:0] $end
-   $var wire 8 C unpacked_array[-2] [7:0] $end
-   $var wire 8 D unpacked_array[-1] [7:0] $end
-   $var wire 8 E unpacked_array[0] [7:0] $end
-   $var wire 1 F LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 2 % v_strp2 [1:0] $end
+   $var wire 4 & v_strp_strp [3:0] $end
+   $var wire 2 ' v_unip_strp [1:0] $end
+   $var wire 2 ( v_arrp [2:1] $end
+   $var wire 4 ) v_arrp_arrp [3:0] $end
+   $var wire 4 * v_arrp_strp [3:0] $end
+   $var wire 1 < v_arru[2] $end
+   $var wire 1 = v_arru[1] $end
+   $var wire 1 > v_arru_arru[4][2] $end
+   $var wire 1 ? v_arru_arru[4][1] $end
+   $var wire 1 @ v_arru_arru[3][2] $end
+   $var wire 1 A v_arru_arru[3][1] $end
+   $var wire 2 + v_arru_arrp[4] [2:1] $end
+   $var wire 2 , v_arru_arrp[3] [2:1] $end
+   $var wire 2 - v_arru_strp[4] [1:0] $end
+   $var wire 2 . v_arru_strp[3] [1:0] $end
+   $var real 64 / v_real $end
+   $var real 64 1 v_arr_real[0] $end
+   $var real 64 3 v_arr_real[1] $end
+   $var wire 64 B v_chandle [63:0] $end
+   $var wire 64 5 v_str32x2 [63:0] $end
+   $var wire 32 7 v_enumed [31:0] $end
+   $var wire 32 8 v_enumed2 [31:0] $end
+   $var wire 3 9 v_enumb [2:0] $end
+   $var wire 6 : v_enumb2_str [5:0] $end
+   $var wire 8 D unpacked_array[-2] [7:0] $end
+   $var wire 8 E unpacked_array[-1] [7:0] $end
+   $var wire 8 F unpacked_array[0] [7:0] $end
+   $var wire 1 G LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
    $scope module a_module_instantiation_with_a_very_long_name_that_once_its_signals_get_concatenated_and_inlined_will_almost_certainly_result_in_them_getting_hashed $end
-    $var wire 32 G PARAM [31:0] $end
-   $upscope $end
-   $scope module p2 $end
     $var wire 32 H PARAM [31:0] $end
    $upscope $end
-   $scope module p3 $end
+   $scope module p2 $end
     $var wire 32 I PARAM [31:0] $end
    $upscope $end
+   $scope module p3 $end
+    $var wire 32 J PARAM [31:0] $end
+   $upscope $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
@@ -54,171 +55,178 @@ $enddefinitions $end
 1"
 b00000000000000000000000000000000 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0 .
-r0 0
-r0 2
-b0000000000000000000000000000000000000000000000000000000011111111 4
-b00000000000000000000000000000000 6
+b00 .
+r0 /
+r0 1
+r0 3
+b0000000000000000000000000000000000000000000000000000000011111111 5
 b00000000000000000000000000000000 7
-b000 8
-b000000 9
-0:
+b00000000000000000000000000000000 8
+b000 9
+b000000 :
 0;
 0<
 0=
 0>
 0?
 0@
-b0000000000000000000000000000000000000000000000000000000000000000 A
-b00000000 C
+0A
+b0000000000000000000000000000000000000000000000000000000000000000 B
 b00000000 D
 b00000000 E
-0F
-b00000000000000000000000000000100 G
-b00000000000000000000000000000010 H
-b00000000000000000000000000000011 I
+b00000000 F
+0G
+b00000000000000000000000000000100 H
+b00000000000000000000000000000010 I
+b00000000000000000000000000000011 J
 #10
 b00000000000000000000000000000001 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.1 .
-r0.2 0
-r0.3 2
-b0000000000000000000000000000000100000000000000000000000011111110 4
-b00000000000000000000000000000001 6
-b00000000000000000000000000000010 7
-b111 8
-1:
+b11 .
+r0.1 /
+r0.2 1
+r0.3 3
+b0000000000000000000000000000000100000000000000000000000011111110 5
+b00000000000000000000000000000001 7
+b00000000000000000000000000000010 8
+b111 9
+1;
 #15
-0:
+0;
 #20
 b00000000000000000000000000000010 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.2 .
-r0.4 0
-r0.6 2
-b0000000000000000000000000000001000000000000000000000000011111101 4
-b00000000000000000000000000000010 6
-b00000000000000000000000000000100 7
-b110 8
-b111111 9
-1:
+b00 .
+r0.2 /
+r0.4 1
+r0.6 3
+b0000000000000000000000000000001000000000000000000000000011111101 5
+b00000000000000000000000000000010 7
+b00000000000000000000000000000100 8
+b110 9
+b111111 :
+1;
 #25
-0:
+0;
 #30
 b00000000000000000000000000000011 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.3 .
-r0.6000000000000001 0
-r0.8999999999999999 2
-b0000000000000000000000000000001100000000000000000000000011111100 4
-b00000000000000000000000000000011 6
-b00000000000000000000000000000110 7
-b101 8
-b110110 9
-1:
+b11 .
+r0.3 /
+r0.6000000000000001 1
+r0.8999999999999999 3
+b0000000000000000000000000000001100000000000000000000000011111100 5
+b00000000000000000000000000000011 7
+b00000000000000000000000000000110 8
+b101 9
+b110110 :
+1;
 #35
-0:
+0;
 #40
 b00000000000000000000000000000100 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.4 .
-r0.8 0
-r1.2 2
-b0000000000000000000000000000010000000000000000000000000011111011 4
-b00000000000000000000000000000100 6
-b00000000000000000000000000001000 7
-b100 8
-b101101 9
-1:
+b00 .
+r0.4 /
+r0.8 1
+r1.2 3
+b0000000000000000000000000000010000000000000000000000000011111011 5
+b00000000000000000000000000000100 7
+b00000000000000000000000000001000 8
+b100 9
+b101101 :
+1;
 #45
-0:
+0;
 #50
 b00000000000000000000000000000101 #
 b11 $
-b1111 %
-b11 &
+b11 %
+b1111 &
 b11 '
-b1111 (
+b11 (
 b1111 )
-b11 *
+b1111 *
 b11 +
 b11 ,
 b11 -
-r0.5 .
-r1 0
-r1.5 2
-b0000000000000000000000000000010100000000000000000000000011111010 4
-b00000000000000000000000000000101 6
-b00000000000000000000000000001010 7
-b011 8
-b100100 9
-1:
+b11 .
+r0.5 /
+r1 1
+r1.5 3
+b0000000000000000000000000000010100000000000000000000000011111010 5
+b00000000000000000000000000000101 7
+b00000000000000000000000000001010 8
+b011 9
+b100100 :
+1;
 #55
-0:
+0;
 #60
 b00000000000000000000000000000110 #
 b00 $
-b0000 %
-b00 &
+b00 %
+b0000 &
 b00 '
-b0000 (
+b00 (
 b0000 )
-b00 *
+b0000 *
 b00 +
 b00 ,
 b00 -
-r0.6 .
-r1.2 0
-r1.8 2
-b0000000000000000000000000000011000000000000000000000000011111001 4
-b00000000000000000000000000000110 6
-b00000000000000000000000000001100 7
-b010 8
-b011011 9
-1:
+b00 .
+r0.6 /
+r1.2 1
+r1.8 3
+b0000000000000000000000000000011000000000000000000000000011111001 5
+b00000000000000000000000000000110 7
+b00000000000000000000000000001100 8
+b010 9
+b011011 :
+1;
 #64

test_regress/t/t_trace_complex_structs_cc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:17:04 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:40 2026
+=======
+Tue Mar 31 17:14:42 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -24,150 +28,157 @@ $end
     $var bit 1 % b0 $end
    $upscope $end
    $attrbegin pack packed members 2 $end
+   $scope struct v_strp2 $end
+    $var bit 1 & b1 $end
+    $var bit 1 ' b0 $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
    $scope struct v_strp_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct x1 $end
-     $var bit 1 & b1 $end
-     $var bit 1 ' b0 $end
+     $var bit 1 ( b1 $end
+     $var bit 1 ) b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct x0 $end
-     $var bit 1 ( b1 $end
-     $var bit 1 ) b0 $end
+     $var bit 1 * b1 $end
+     $var bit 1 + b0 $end
     $upscope $end
    $upscope $end
    $attrbegin pack packed members 2 $end
    $scope union v_unip_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct x1 $end
-     $var bit 1 * b1 $end
-     $var bit 1 + b0 $end
+     $var bit 1 , b1 $end
+     $var bit 1 - b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct x0 $end
-     $var bit 1 * b1 $end
-     $var bit 1 + b0 $end
+     $var bit 1 , b1 $end
+     $var bit 1 - b0 $end
     $upscope $end
    $upscope $end
-   $var bit 2 , v_arrp [2:1] $end
+   $var bit 2 . v_arrp [2:1] $end
    $attrbegin array packed bounds 17179869187 $end
    $scope sv_array v_arrp_arrp $end
-    $var bit 2 - v_arrp_arrp[4] [2:1] $end
-    $var bit 2 . v_arrp_arrp[3] [2:1] $end
+    $var bit 2 / v_arrp_arrp[4] [2:1] $end
+    $var bit 2 0 v_arrp_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array packed bounds 17179869187 $end
    $scope sv_array v_arrp_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct [4] $end
-     $var bit 1 / b1 $end
-     $var bit 1 0 b0 $end
+     $var bit 1 1 b1 $end
+     $var bit 1 2 b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct [3] $end
-     $var bit 1 1 b1 $end
-     $var bit 1 2 b0 $end
+     $var bit 1 3 b1 $end
+     $var bit 1 4 b0 $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 3 v_arru[2] $end
-    $var bit 1 4 v_arru[1] $end
+    $var bit 1 5 v_arru[2] $end
+    $var bit 1 6 v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 5 v_arru_arru[4][2] $end
-     $var bit 1 6 v_arru_arru[4][1] $end
+     $var bit 1 7 v_arru_arru[4][2] $end
+     $var bit 1 8 v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 7 v_arru_arru[3][2] $end
-     $var bit 1 8 v_arru_arru[3][1] $end
+     $var bit 1 9 v_arru_arru[3][2] $end
+     $var bit 1 : v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 9 v_arru_arrp[4] [2:1] $end
-    $var bit 2 : v_arru_arrp[3] [2:1] $end
+    $var bit 2 ; v_arru_arrp[4] [2:1] $end
+    $var bit 2 < v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct [4] $end
-     $var bit 1 ; b1 $end
-     $var bit 1 < b0 $end
-    $upscope $end
-    $attrbegin pack packed members 2 $end
-    $scope struct [3] $end
      $var bit 1 = b1 $end
      $var bit 1 > b0 $end
     $upscope $end
+    $attrbegin pack packed members 2 $end
+    $scope struct [3] $end
+     $var bit 1 ? b1 $end
+     $var bit 1 @ b0 $end
+    $upscope $end
    $upscope $end
-   $var real 64 ? v_real $end
+   $var real 64 A v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 @ v_arr_real[0] $end
-    $var real 64 A v_arr_real[1] $end
+    $var real 64 B v_arr_real[0] $end
+    $var real 64 C v_arr_real[1] $end
    $upscope $end
-   $var longint 64 B v_chandle [63:0] $end
+   $var longint 64 D v_chandle [63:0] $end
    $attrbegin array packed bounds 4294967296 $end
    $scope sv_array v_str32x2 $end
     $attrbegin pack packed members 1 $end
     $scope struct [1] $end
-     $var logic 32 C data [31:0] $end
+     $var logic 32 E data [31:0] $end
     $upscope $end
     $attrbegin pack packed members 1 $end
     $scope struct [0] $end
-     $var logic 32 D data [31:0] $end
+     $var logic 32 F data [31:0] $end
     $upscope $end
    $upscope $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 E v_enumed [31:0] $end
+   $var int 32 G v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 F v_enumed2 [31:0] $end
+   $var int 32 H v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 G v_enumb [2:0] $end
+   $var logic 3 I v_enumb [2:0] $end
    $attrbegin pack packed members 2 $end
    $scope struct v_enumb2_str $end
     $attrbegin misc 07 "" 2 $end
-    $var logic 3 H a [2:0] $end
+    $var logic 3 J a [2:0] $end
     $attrbegin misc 07 "" 2 $end
-    $var logic 3 I b [2:0] $end
+    $var logic 3 K b [2:0] $end
    $upscope $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 J unpacked_array[-2] [7:0] $end
-    $var logic 8 K unpacked_array[-1] [7:0] $end
-    $var logic 8 L unpacked_array[0] [7:0] $end
+    $var logic 8 L unpacked_array[-2] [7:0] $end
+    $var logic 8 M unpacked_array[-1] [7:0] $end
+    $var logic 8 N unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 M LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 O LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-0M
+0O
+b00000000 N
+b00000000 M
 b00000000 L
-b00000000 K
-b00000000 J
+b000 K
+b000 J
 b000 I
-b000 H
-b000 G
-b00000000000000000000000000000000 F
+b00000000000000000000000000000000 H
+b00000000000000000000000000000000 G
+b00000000000000000000000011111111 F
 b00000000000000000000000000000000 E
-b00000000000000000000000011111111 D
-b00000000000000000000000000000000 C
-b0000000000000000000000000000000000000000000000000000000000000000 B
+b0000000000000000000000000000000000000000000000000000000000000000 D
+r0 C
+r0 B
 r0 A
-r0 @
-r0 ?
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+0:
+09
 08
 07
 06
@@ -176,11 +187,11 @@ b00 9
 03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -204,52 +215,56 @@ b00000000000000000000000000000001 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.1 ?
-r0.2 @
-r0.3 A
-b00000000000000000000000000000001 C
-b00000000000000000000000011111110 D
+1?
+1@
+r0.1 A
+r0.2 B
+r0.3 C
 b00000000000000000000000000000001 E
-b00000000000000000000000000000010 F
-b111 G
+b00000000000000000000000011111110 F
+b00000000000000000000000000000001 G
+b00000000000000000000000000000010 H
+b111 I
 #15
 0!
 #20
 1!
-b110 G
-b00000000000000000000000000000100 F
+b110 I
+b00000000000000000000000000000100 H
+b00000000000000000000000000000010 G
+b00000000000000000000000011111101 F
 b00000000000000000000000000000010 E
-b00000000000000000000000011111101 D
-b00000000000000000000000000000010 C
-r0.6 A
-r0.4 @
-r0.2 ?
+r0.6 C
+r0.4 B
+r0.2 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -259,14 +274,14 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000010 #
-b111 H
-b111 I
+b111 J
+b111 K
 #25
 0!
 #30
 1!
-b110 I
-b110 H
+b110 K
+b110 J
 b00000000000000000000000000000011 #
 1$
 1%
@@ -276,52 +291,56 @@ b00000000000000000000000000000011 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.3 ?
-r0.6000000000000001 @
-r0.8999999999999999 A
-b00000000000000000000000000000011 C
-b00000000000000000000000011111100 D
+1?
+1@
+r0.3 A
+r0.6000000000000001 B
+r0.8999999999999999 C
 b00000000000000000000000000000011 E
-b00000000000000000000000000000110 F
-b101 G
+b00000000000000000000000011111100 F
+b00000000000000000000000000000011 G
+b00000000000000000000000000000110 H
+b101 I
 #35
 0!
 #40
 1!
-b100 G
-b00000000000000000000000000001000 F
+b100 I
+b00000000000000000000000000001000 H
+b00000000000000000000000000000100 G
+b00000000000000000000000011111011 F
 b00000000000000000000000000000100 E
-b00000000000000000000000011111011 D
-b00000000000000000000000000000100 C
-r1.2 A
-r0.8 @
-r0.4 ?
+r1.2 C
+r0.8 B
+r0.4 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -331,14 +350,14 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000100 #
-b101 H
-b101 I
+b101 J
+b101 K
 #45
 0!
 #50
 1!
-b100 I
-b100 H
+b100 K
+b100 J
 b00000000000000000000000000000101 #
 1$
 1%
@@ -348,52 +367,56 @@ b00000000000000000000000000000101 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.5 ?
-r1 @
-r1.5 A
-b00000000000000000000000000000101 C
-b00000000000000000000000011111010 D
+1?
+1@
+r0.5 A
+r1 B
+r1.5 C
 b00000000000000000000000000000101 E
-b00000000000000000000000000001010 F
-b011 G
+b00000000000000000000000011111010 F
+b00000000000000000000000000000101 G
+b00000000000000000000000000001010 H
+b011 I
 #55
 0!
 #60
 1!
-b010 G
-b00000000000000000000000000001100 F
+b010 I
+b00000000000000000000000000001100 H
+b00000000000000000000000000000110 G
+b00000000000000000000000011111001 F
 b00000000000000000000000000000110 E
-b00000000000000000000000011111001 D
-b00000000000000000000000000000110 C
-r1.8 A
-r1.2 @
-r0.6 ?
+r1.8 C
+r1.2 B
+r0.6 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -403,5 +426,5 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000110 #
-b011 H
-b011 I
+b011 J
+b011 K

test_regress/t/t_trace_complex_structs_cc_saif.out

@@ -52,20 +52,20 @@
     (cyc\[31\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arrp\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arrp_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arrp_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_arrp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arrp_arrp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arrp_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arrp_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru[2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru[1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arru[4][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arru[4][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][2] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v_arru_arru[3][1] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_arru_arrp[4]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_arru_arrp[4]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (v_arru_arrp[3]\[1\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     (v_real\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v_real\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
@@ -421,6 +421,12 @@
      (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     )
    )
+   (INSTANCE v_strp2
+    (NET
+     (b1 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+     (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    )
+   )
    (INSTANCE v_strp_strp
     (INSTANCE x1
      (NET
@@ -449,19 +455,13 @@
      )
     )
    )
-   (INSTANCE v_arrp_strp[3]
-    (NET
-     (b1 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-     (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-    )
-   )
    (INSTANCE v_arrp_strp[4]
     (NET
      (b1 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
      (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     )
    )
-   (INSTANCE v_arru_strp[3]
+   (INSTANCE v_arrp_strp[3]
     (NET
      (b1 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
      (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
@@ -473,16 +473,22 @@
      (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
     )
    )
-   (INSTANCE v_str32x2[0]
+   (INSTANCE v_arru_strp[3]
     (NET
-     (data\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 7))
-     (data\[1\] (T0 20) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 4))
-     (data\[2\] (T0 20) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 2))
-     (data\[3\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
-     (data\[4\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
-     (data\[5\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
-     (data\[6\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
-     (data\[7\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (b1 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+     (b0 (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    )
+   )
+   (INSTANCE v_str32x2[1]
+    (NET
+     (data\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+     (data\[1\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 3))
+     (data\[2\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (data\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (data\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (data\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (data\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (data\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
      (data\[8\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
      (data\[9\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
      (data\[10\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
@@ -509,16 +515,16 @@
      (data\[31\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     )
    )
-   (INSTANCE v_str32x2[1]
+   (INSTANCE v_str32x2[0]
     (NET
-     (data\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
-     (data\[1\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 3))
-     (data\[2\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 1))
-     (data\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-     (data\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-     (data\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-     (data\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-     (data\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (data\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 7))
+     (data\[1\] (T0 20) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 4))
+     (data\[2\] (T0 20) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 2))
+     (data\[3\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (data\[4\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (data\[5\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (data\[6\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
+     (data\[7\] (T0 0) (T1 60) (TZ 0) (TX 0) (TB 0) (TC 1))
      (data\[8\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
      (data\[9\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
      (data\[10\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))

test_regress/t/t_trace_complex_structs_cc_vcd.out

@@ -1,85 +1,89 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 F clk $end
+  $var wire 1 H clk $end
   $scope module $unit $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 F clk $end
+   $var wire 1 H clk $end
    $var wire 32 # cyc [31:0] $end
    $scope module v_strp $end
     $var wire 1 $ b1 $end
     $var wire 1 % b0 $end
    $upscope $end
+   $scope module v_strp2 $end
+    $var wire 1 & b1 $end
+    $var wire 1 ' b0 $end
+   $upscope $end
    $scope module v_strp_strp $end
     $scope module x1 $end
-     $var wire 1 & b1 $end
-     $var wire 1 ' b0 $end
-    $upscope $end
-    $scope module x0 $end
      $var wire 1 ( b1 $end
      $var wire 1 ) b0 $end
     $upscope $end
+    $scope module x0 $end
+     $var wire 1 * b1 $end
+     $var wire 1 + b0 $end
+    $upscope $end
    $upscope $end
    $scope module v_unip_strp $end
     $scope module x1 $end
-     $var wire 1 * b1 $end
-     $var wire 1 + b0 $end
+     $var wire 1 , b1 $end
+     $var wire 1 - b0 $end
     $upscope $end
     $scope module x0 $end
-     $var wire 1 * b1 $end
-     $var wire 1 + b0 $end
+     $var wire 1 , b1 $end
+     $var wire 1 - b0 $end
     $upscope $end
    $upscope $end
-   $var wire 2 , v_arrp [2:1] $end
-   $var wire 2 - v_arrp_arrp[3] [2:1] $end
-   $var wire 2 . v_arrp_arrp[4] [2:1] $end
-   $scope module v_arrp_strp[3] $end
-    $var wire 1 / b1 $end
-    $var wire 1 0 b0 $end
-   $upscope $end
+   $var wire 2 . v_arrp [2:1] $end
+   $var wire 2 / v_arrp_arrp[4] [2:1] $end
+   $var wire 2 0 v_arrp_arrp[3] [2:1] $end
    $scope module v_arrp_strp[4] $end
     $var wire 1 1 b1 $end
     $var wire 1 2 b0 $end
    $upscope $end
-   $var wire 1 G v_arru[1] $end
-   $var wire 1 H v_arru[2] $end
-   $var wire 1 I v_arru_arru[3][1] $end
-   $var wire 1 J v_arru_arru[3][2] $end
-   $var wire 1 K v_arru_arru[4][1] $end
-   $var wire 1 L v_arru_arru[4][2] $end
-   $var wire 2 3 v_arru_arrp[3] [2:1] $end
-   $var wire 2 4 v_arru_arrp[4] [2:1] $end
-   $scope module v_arru_strp[3] $end
-    $var wire 1 5 b1 $end
-    $var wire 1 6 b0 $end
+   $scope module v_arrp_strp[3] $end
+    $var wire 1 3 b1 $end
+    $var wire 1 4 b0 $end
    $upscope $end
+   $var wire 1 I v_arru[2] $end
+   $var wire 1 J v_arru[1] $end
+   $var wire 1 K v_arru_arru[4][2] $end
+   $var wire 1 L v_arru_arru[4][1] $end
+   $var wire 1 M v_arru_arru[3][2] $end
+   $var wire 1 N v_arru_arru[3][1] $end
+   $var wire 2 5 v_arru_arrp[4] [2:1] $end
+   $var wire 2 6 v_arru_arrp[3] [2:1] $end
    $scope module v_arru_strp[4] $end
     $var wire 1 7 b1 $end
     $var wire 1 8 b0 $end
    $upscope $end
-   $var real 64 9 v_real $end
-   $var real 64 ; v_arr_real[0] $end
-   $var real 64 = v_arr_real[1] $end
-   $var wire 64 M v_chandle [63:0] $end
-   $scope module v_str32x2[0] $end
-    $var wire 32 ? data [31:0] $end
+   $scope module v_arru_strp[3] $end
+    $var wire 1 9 b1 $end
+    $var wire 1 : b0 $end
    $upscope $end
+   $var real 64 ; v_real $end
+   $var real 64 = v_arr_real[0] $end
+   $var real 64 ? v_arr_real[1] $end
+   $var wire 64 O v_chandle [63:0] $end
    $scope module v_str32x2[1] $end
-    $var wire 32 @ data [31:0] $end
+    $var wire 32 A data [31:0] $end
    $upscope $end
-   $var wire 32 A v_enumed [31:0] $end
-   $var wire 32 B v_enumed2 [31:0] $end
-   $var wire 3 C v_enumb [2:0] $end
+   $scope module v_str32x2[0] $end
+    $var wire 32 B data [31:0] $end
+   $upscope $end
+   $var wire 32 C v_enumed [31:0] $end
+   $var wire 32 D v_enumed2 [31:0] $end
+   $var wire 3 E v_enumb [2:0] $end
    $scope module v_enumb2_str $end
-    $var wire 3 D a [2:0] $end
-    $var wire 3 E b [2:0] $end
+    $var wire 3 F a [2:0] $end
+    $var wire 3 G b [2:0] $end
    $upscope $end
-   $var wire 8 O unpacked_array[-2] [7:0] $end
-   $var wire 8 P unpacked_array[-1] [7:0] $end
-   $var wire 8 Q unpacked_array[0] [7:0] $end
-   $var wire 1 R LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 8 Q unpacked_array[-2] [7:0] $end
+   $var wire 8 R unpacked_array[-1] [7:0] $end
+   $var wire 8 S unpacked_array[0] [7:0] $end
+   $var wire 1 T LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
@@ -96,41 +100,43 @@ b00000000000000000000000000000000 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0 9
+09
+0:
 r0 ;
 r0 =
-b00000000000000000000000011111111 ?
-b00000000000000000000000000000000 @
+r0 ?
 b00000000000000000000000000000000 A
-b00000000000000000000000000000000 B
-b000 C
-b000 D
+b00000000000000000000000011111111 B
+b00000000000000000000000000000000 C
+b00000000000000000000000000000000 D
 b000 E
-0F
-0G
+b000 F
+b000 G
 0H
 0I
 0J
 0K
 0L
-b0000000000000000000000000000000000000000000000000000000000000000 M
-b00000000 O
-b00000000 P
+0M
+0N
+b0000000000000000000000000000000000000000000000000000000000000000 O
 b00000000 Q
-0R
+b00000000 R
+b00000000 S
+0T
 #10
 b00000000000000000000000000000001 #
 1$
@@ -141,30 +147,32 @@ b00000000000000000000000000000001 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.1 9
-r0.2 ;
-r0.3 =
-b00000000000000000000000011111110 ?
-b00000000000000000000000000000001 @
+19
+1:
+r0.1 ;
+r0.2 =
+r0.3 ?
 b00000000000000000000000000000001 A
-b00000000000000000000000000000010 B
-b111 C
-1F
+b00000000000000000000000011111110 B
+b00000000000000000000000000000001 C
+b00000000000000000000000000000010 D
+b111 E
+1H
 #15
-0F
+0H
 #20
 b00000000000000000000000000000010 #
 0$
@@ -175,32 +183,34 @@ b00000000000000000000000000000010 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.2 9
-r0.4 ;
-r0.6 =
-b00000000000000000000000011111101 ?
-b00000000000000000000000000000010 @
+09
+0:
+r0.2 ;
+r0.4 =
+r0.6 ?
 b00000000000000000000000000000010 A
-b00000000000000000000000000000100 B
-b110 C
-b111 D
-b111 E
-1F
+b00000000000000000000000011111101 B
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 D
+b110 E
+b111 F
+b111 G
+1H
 #25
-0F
+0H
 #30
 b00000000000000000000000000000011 #
 1$
@@ -211,32 +221,34 @@ b00000000000000000000000000000011 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.3 9
-r0.6000000000000001 ;
-r0.8999999999999999 =
-b00000000000000000000000011111100 ?
-b00000000000000000000000000000011 @
+19
+1:
+r0.3 ;
+r0.6000000000000001 =
+r0.8999999999999999 ?
 b00000000000000000000000000000011 A
-b00000000000000000000000000000110 B
-b101 C
-b110 D
-b110 E
-1F
+b00000000000000000000000011111100 B
+b00000000000000000000000000000011 C
+b00000000000000000000000000000110 D
+b101 E
+b110 F
+b110 G
+1H
 #35
-0F
+0H
 #40
 b00000000000000000000000000000100 #
 0$
@@ -247,32 +259,34 @@ b00000000000000000000000000000100 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.4 9
-r0.8 ;
-r1.2 =
-b00000000000000000000000011111011 ?
-b00000000000000000000000000000100 @
+09
+0:
+r0.4 ;
+r0.8 =
+r1.2 ?
 b00000000000000000000000000000100 A
-b00000000000000000000000000001000 B
-b100 C
-b101 D
-b101 E
-1F
+b00000000000000000000000011111011 B
+b00000000000000000000000000000100 C
+b00000000000000000000000000001000 D
+b100 E
+b101 F
+b101 G
+1H
 #45
-0F
+0H
 #50
 b00000000000000000000000000000101 #
 1$
@@ -283,32 +297,34 @@ b00000000000000000000000000000101 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.5 9
-r1 ;
-r1.5 =
-b00000000000000000000000011111010 ?
-b00000000000000000000000000000101 @
+19
+1:
+r0.5 ;
+r1 =
+r1.5 ?
 b00000000000000000000000000000101 A
-b00000000000000000000000000001010 B
-b011 C
-b100 D
-b100 E
-1F
+b00000000000000000000000011111010 B
+b00000000000000000000000000000101 C
+b00000000000000000000000000001010 D
+b011 E
+b100 F
+b100 G
+1H
 #55
-0F
+0H
 #60
 b00000000000000000000000000000110 #
 0$
@@ -319,27 +335,29 @@ b00000000000000000000000000000110 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.6 9
-r1.2 ;
-r1.8 =
-b00000000000000000000000011111001 ?
-b00000000000000000000000000000110 @
+09
+0:
+r0.6 ;
+r1.2 =
+r1.8 ?
 b00000000000000000000000000000110 A
-b00000000000000000000000000001100 B
-b010 C
-b011 D
-b011 E
-1F
+b00000000000000000000000011111001 B
+b00000000000000000000000000000110 C
+b00000000000000000000000000001100 D
+b010 E
+b011 F
+b011 G
+1H

test_regress/t/t_trace_complex_structs_sc_fst.out

@@ -1,5 +1,9 @@
 $date
-Sat Mar 14 09:16:58 2026
+<<<<<<< HEAD
+Tue Apr 14 15:20:41 2026
+=======
+Tue Mar 31 17:14:45 2026
+>>>>>>> 8895f96e4 (CR)
 
 $end
 $version
@@ -23,150 +27,157 @@ $end
     $var bit 1 % b0 $end
    $upscope $end
    $attrbegin pack packed members 2 $end
+   $scope struct v_strp2 $end
+    $var bit 1 & b1 $end
+    $var bit 1 ' b0 $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
    $scope struct v_strp_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct x1 $end
-     $var bit 1 & b1 $end
-     $var bit 1 ' b0 $end
+     $var bit 1 ( b1 $end
+     $var bit 1 ) b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct x0 $end
-     $var bit 1 ( b1 $end
-     $var bit 1 ) b0 $end
+     $var bit 1 * b1 $end
+     $var bit 1 + b0 $end
     $upscope $end
    $upscope $end
    $attrbegin pack packed members 2 $end
    $scope union v_unip_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct x1 $end
-     $var bit 1 * b1 $end
-     $var bit 1 + b0 $end
+     $var bit 1 , b1 $end
+     $var bit 1 - b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct x0 $end
-     $var bit 1 * b1 $end
-     $var bit 1 + b0 $end
+     $var bit 1 , b1 $end
+     $var bit 1 - b0 $end
     $upscope $end
    $upscope $end
-   $var bit 2 , v_arrp [2:1] $end
+   $var bit 2 . v_arrp [2:1] $end
    $attrbegin array packed bounds 17179869187 $end
    $scope sv_array v_arrp_arrp $end
-    $var bit 2 - v_arrp_arrp[4] [2:1] $end
-    $var bit 2 . v_arrp_arrp[3] [2:1] $end
+    $var bit 2 / v_arrp_arrp[4] [2:1] $end
+    $var bit 2 0 v_arrp_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array packed bounds 17179869187 $end
    $scope sv_array v_arrp_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct [4] $end
-     $var bit 1 / b1 $end
-     $var bit 1 0 b0 $end
+     $var bit 1 1 b1 $end
+     $var bit 1 2 b0 $end
     $upscope $end
     $attrbegin pack packed members 2 $end
     $scope struct [3] $end
-     $var bit 1 1 b1 $end
-     $var bit 1 2 b0 $end
+     $var bit 1 3 b1 $end
+     $var bit 1 4 b0 $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 8589934593 $end
    $scope sv_array v_arru $end
-    $var bit 1 3 v_arru[2] $end
-    $var bit 1 4 v_arru[1] $end
+    $var bit 1 5 v_arru[2] $end
+    $var bit 1 6 v_arru[1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arru $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [4] $end
-     $var bit 1 5 v_arru_arru[4][2] $end
-     $var bit 1 6 v_arru_arru[4][1] $end
+     $var bit 1 7 v_arru_arru[4][2] $end
+     $var bit 1 8 v_arru_arru[4][1] $end
     $upscope $end
     $attrbegin array unpacked bounds 8589934593 $end
     $scope sv_array [3] $end
-     $var bit 1 7 v_arru_arru[3][2] $end
-     $var bit 1 8 v_arru_arru[3][1] $end
+     $var bit 1 9 v_arru_arru[3][2] $end
+     $var bit 1 : v_arru_arru[3][1] $end
     $upscope $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_arrp $end
-    $var bit 2 9 v_arru_arrp[4] [2:1] $end
-    $var bit 2 : v_arru_arrp[3] [2:1] $end
+    $var bit 2 ; v_arru_arrp[4] [2:1] $end
+    $var bit 2 < v_arru_arrp[3] [2:1] $end
    $upscope $end
    $attrbegin array unpacked bounds 17179869187 $end
    $scope sv_array v_arru_strp $end
     $attrbegin pack packed members 2 $end
     $scope struct [4] $end
-     $var bit 1 ; b1 $end
-     $var bit 1 < b0 $end
-    $upscope $end
-    $attrbegin pack packed members 2 $end
-    $scope struct [3] $end
      $var bit 1 = b1 $end
      $var bit 1 > b0 $end
     $upscope $end
+    $attrbegin pack packed members 2 $end
+    $scope struct [3] $end
+     $var bit 1 ? b1 $end
+     $var bit 1 @ b0 $end
+    $upscope $end
    $upscope $end
-   $var real 64 ? v_real $end
+   $var real 64 A v_real $end
    $attrbegin array unpacked bounds 1 $end
    $scope sv_array v_arr_real $end
-    $var real 64 @ v_arr_real[0] $end
-    $var real 64 A v_arr_real[1] $end
+    $var real 64 B v_arr_real[0] $end
+    $var real 64 C v_arr_real[1] $end
    $upscope $end
-   $var longint 64 B v_chandle [63:0] $end
+   $var longint 64 D v_chandle [63:0] $end
    $attrbegin array packed bounds 4294967296 $end
    $scope sv_array v_str32x2 $end
     $attrbegin pack packed members 1 $end
     $scope struct [1] $end
-     $var logic 32 C data [31:0] $end
+     $var logic 32 E data [31:0] $end
     $upscope $end
     $attrbegin pack packed members 1 $end
     $scope struct [0] $end
-     $var logic 32 D data [31:0] $end
+     $var logic 32 F data [31:0] $end
     $upscope $end
    $upscope $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 E v_enumed [31:0] $end
+   $var int 32 G v_enumed [31:0] $end
    $attrbegin misc 07 "" 1 $end
-   $var int 32 F v_enumed2 [31:0] $end
+   $var int 32 H v_enumed2 [31:0] $end
    $attrbegin misc 07 "" 2 $end
-   $var logic 3 G v_enumb [2:0] $end
+   $var logic 3 I v_enumb [2:0] $end
    $attrbegin pack packed members 2 $end
    $scope struct v_enumb2_str $end
     $attrbegin misc 07 "" 2 $end
-    $var logic 3 H a [2:0] $end
+    $var logic 3 J a [2:0] $end
     $attrbegin misc 07 "" 2 $end
-    $var logic 3 I b [2:0] $end
+    $var logic 3 K b [2:0] $end
    $upscope $end
    $attrbegin array unpacked bounds -8589934592 $end
    $scope sv_array unpacked_array $end
-    $var logic 8 J unpacked_array[-2] [7:0] $end
-    $var logic 8 K unpacked_array[-1] [7:0] $end
-    $var logic 8 L unpacked_array[0] [7:0] $end
+    $var logic 8 L unpacked_array[-2] [7:0] $end
+    $var logic 8 M unpacked_array[-1] [7:0] $end
+    $var logic 8 N unpacked_array[0] [7:0] $end
    $upscope $end
-   $var bit 1 M LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var bit 1 O LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 #0
 $dumpvars
-0M
+0O
+b00000000 N
+b00000000 M
 b00000000 L
-b00000000 K
-b00000000 J
+b000 K
+b000 J
 b000 I
-b000 H
-b000 G
-b00000000000000000000000000000000 F
+b00000000000000000000000000000000 H
+b00000000000000000000000000000000 G
+b00000000000000000000000011111111 F
 b00000000000000000000000000000000 E
-b00000000000000000000000011111111 D
-b00000000000000000000000000000000 C
-b0000000000000000000000000000000000000000000000000000000000000000 B
+b0000000000000000000000000000000000000000000000000000000000000000 D
+r0 C
+r0 B
 r0 A
-r0 @
-r0 ?
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+0:
+09
 08
 07
 06
@@ -175,11 +186,11 @@ b00 9
 03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -203,52 +214,56 @@ b00000000000000000000000000000001 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.1 ?
-r0.2 @
-r0.3 A
-b00000000000000000000000000000001 C
-b00000000000000000000000011111110 D
+1?
+1@
+r0.1 A
+r0.2 B
+r0.3 C
 b00000000000000000000000000000001 E
-b00000000000000000000000000000010 F
-b111 G
+b00000000000000000000000011111110 F
+b00000000000000000000000000000001 G
+b00000000000000000000000000000010 H
+b111 I
 #15
 0"
 #20
 1"
-b110 G
-b00000000000000000000000000000100 F
+b110 I
+b00000000000000000000000000000100 H
+b00000000000000000000000000000010 G
+b00000000000000000000000011111101 F
 b00000000000000000000000000000010 E
-b00000000000000000000000011111101 D
-b00000000000000000000000000000010 C
-r0.6 A
-r0.4 @
-r0.2 ?
+r0.6 C
+r0.4 B
+r0.2 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -258,14 +273,14 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000010 #
-b111 H
-b111 I
+b111 J
+b111 K
 #25
 0"
 #30
 1"
-b110 I
-b110 H
+b110 K
+b110 J
 b00000000000000000000000000000011 #
 1$
 1%
@@ -275,52 +290,56 @@ b00000000000000000000000000000011 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.3 ?
-r0.6000000000000001 @
-r0.8999999999999999 A
-b00000000000000000000000000000011 C
-b00000000000000000000000011111100 D
+1?
+1@
+r0.3 A
+r0.6000000000000001 B
+r0.8999999999999999 C
 b00000000000000000000000000000011 E
-b00000000000000000000000000000110 F
-b101 G
+b00000000000000000000000011111100 F
+b00000000000000000000000000000011 G
+b00000000000000000000000000000110 H
+b101 I
 #35
 0"
 #40
 1"
-b100 G
-b00000000000000000000000000001000 F
+b100 I
+b00000000000000000000000000001000 H
+b00000000000000000000000000000100 G
+b00000000000000000000000011111011 F
 b00000000000000000000000000000100 E
-b00000000000000000000000011111011 D
-b00000000000000000000000000000100 C
-r1.2 A
-r0.8 @
-r0.4 ?
+r1.2 C
+r0.8 B
+r0.4 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -330,14 +349,14 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000100 #
-b101 H
-b101 I
+b101 J
+b101 K
 #45
 0"
 #50
 1"
-b100 I
-b100 H
+b100 K
+b100 J
 b00000000000000000000000000000101 #
 1$
 1%
@@ -347,52 +366,56 @@ b00000000000000000000000000000101 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 9
-b11 :
-1;
-1<
+13
+14
+b11 ;
+b11 <
 1=
 1>
-r0.5 ?
-r1 @
-r1.5 A
-b00000000000000000000000000000101 C
-b00000000000000000000000011111010 D
+1?
+1@
+r0.5 A
+r1 B
+r1.5 C
 b00000000000000000000000000000101 E
-b00000000000000000000000000001010 F
-b011 G
+b00000000000000000000000011111010 F
+b00000000000000000000000000000101 G
+b00000000000000000000000000001010 H
+b011 I
 #55
 0"
 #60
 1"
-b010 G
-b00000000000000000000000000001100 F
+b010 I
+b00000000000000000000000000001100 H
+b00000000000000000000000000000110 G
+b00000000000000000000000011111001 F
 b00000000000000000000000000000110 E
-b00000000000000000000000011111001 D
-b00000000000000000000000000000110 C
-r1.8 A
-r1.2 @
-r0.6 ?
+r1.8 C
+r1.2 B
+r0.6 A
+0@
+0?
 0>
 0=
-0<
-0;
-b00 :
-b00 9
+b00 <
+b00 ;
+04
+03
 02
 01
-00
-0/
+b00 0
+b00 /
 b00 .
-b00 -
-b00 ,
+0-
+0,
 0+
 0*
 0)
@@ -402,6 +425,6 @@ b00 ,
 0%
 0$
 b00000000000000000000000000000110 #
-b011 H
-b011 I
+b011 J
+b011 K
 #64

test_regress/t/t_trace_complex_structs_sc_vcd.out

@@ -5,80 +5,84 @@ $timescale 1ps $end
    $var wire 1 " global_bit $end
   $upscope $end
   $scope module t $end
-   $var wire 1 F clk $end
+   $var wire 1 H clk $end
    $var wire 32 # cyc [31:0] $end
    $scope module v_strp $end
     $var wire 1 $ b1 $end
     $var wire 1 % b0 $end
    $upscope $end
+   $scope module v_strp2 $end
+    $var wire 1 & b1 $end
+    $var wire 1 ' b0 $end
+   $upscope $end
    $scope module v_strp_strp $end
     $scope module x1 $end
-     $var wire 1 & b1 $end
-     $var wire 1 ' b0 $end
-    $upscope $end
-    $scope module x0 $end
      $var wire 1 ( b1 $end
      $var wire 1 ) b0 $end
     $upscope $end
+    $scope module x0 $end
+     $var wire 1 * b1 $end
+     $var wire 1 + b0 $end
+    $upscope $end
    $upscope $end
    $scope module v_unip_strp $end
     $scope module x1 $end
-     $var wire 1 * b1 $end
-     $var wire 1 + b0 $end
+     $var wire 1 , b1 $end
+     $var wire 1 - b0 $end
     $upscope $end
     $scope module x0 $end
-     $var wire 1 * b1 $end
-     $var wire 1 + b0 $end
+     $var wire 1 , b1 $end
+     $var wire 1 - b0 $end
     $upscope $end
    $upscope $end
-   $var wire 2 , v_arrp [2:1] $end
-   $var wire 2 - v_arrp_arrp[4] [2:1] $end
-   $var wire 2 . v_arrp_arrp[3] [2:1] $end
+   $var wire 2 . v_arrp [2:1] $end
+   $var wire 2 / v_arrp_arrp[4] [2:1] $end
+   $var wire 2 0 v_arrp_arrp[3] [2:1] $end
    $scope module v_arrp_strp[4] $end
-    $var wire 1 / b1 $end
-    $var wire 1 0 b0 $end
-   $upscope $end
-   $scope module v_arrp_strp[3] $end
     $var wire 1 1 b1 $end
     $var wire 1 2 b0 $end
    $upscope $end
-   $var wire 1 G v_arru[2] $end
-   $var wire 1 H v_arru[1] $end
-   $var wire 1 I v_arru_arru[4][2] $end
-   $var wire 1 J v_arru_arru[4][1] $end
-   $var wire 1 K v_arru_arru[3][2] $end
-   $var wire 1 L v_arru_arru[3][1] $end
-   $var wire 2 3 v_arru_arrp[4] [2:1] $end
-   $var wire 2 4 v_arru_arrp[3] [2:1] $end
-   $scope module v_arru_strp[4] $end
-    $var wire 1 5 b1 $end
-    $var wire 1 6 b0 $end
+   $scope module v_arrp_strp[3] $end
+    $var wire 1 3 b1 $end
+    $var wire 1 4 b0 $end
    $upscope $end
-   $scope module v_arru_strp[3] $end
+   $var wire 1 I v_arru[2] $end
+   $var wire 1 J v_arru[1] $end
+   $var wire 1 K v_arru_arru[4][2] $end
+   $var wire 1 L v_arru_arru[4][1] $end
+   $var wire 1 M v_arru_arru[3][2] $end
+   $var wire 1 N v_arru_arru[3][1] $end
+   $var wire 2 5 v_arru_arrp[4] [2:1] $end
+   $var wire 2 6 v_arru_arrp[3] [2:1] $end
+   $scope module v_arru_strp[4] $end
     $var wire 1 7 b1 $end
     $var wire 1 8 b0 $end
    $upscope $end
-   $var real 64 9 v_real $end
-   $var real 64 ; v_arr_real[0] $end
-   $var real 64 = v_arr_real[1] $end
-   $var wire 64 M v_chandle [63:0] $end
+   $scope module v_arru_strp[3] $end
+    $var wire 1 9 b1 $end
+    $var wire 1 : b0 $end
+   $upscope $end
+   $var real 64 ; v_real $end
+   $var real 64 = v_arr_real[0] $end
+   $var real 64 ? v_arr_real[1] $end
+   $var wire 64 O v_chandle [63:0] $end
    $scope module v_str32x2[1] $end
-    $var wire 32 ? data [31:0] $end
+    $var wire 32 A data [31:0] $end
    $upscope $end
    $scope module v_str32x2[0] $end
-    $var wire 32 @ data [31:0] $end
+    $var wire 32 B data [31:0] $end
    $upscope $end
-   $var wire 32 A v_enumed [31:0] $end
-   $var wire 32 B v_enumed2 [31:0] $end
-   $var wire 3 C v_enumb [2:0] $end
+   $var wire 32 C v_enumed [31:0] $end
+   $var wire 32 D v_enumed2 [31:0] $end
+   $var wire 3 E v_enumb [2:0] $end
    $scope module v_enumb2_str $end
-    $var wire 3 D a [2:0] $end
-    $var wire 3 E b [2:0] $end
+    $var wire 3 F a [2:0] $end
+    $var wire 3 G b [2:0] $end
    $upscope $end
-   $var wire 8 O unpacked_array[-2] [7:0] $end
-   $var wire 8 P unpacked_array[-1] [7:0] $end
-   $var wire 8 Q unpacked_array[0] [7:0] $end
-   $var wire 1 R LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
+   $var wire 8 Q unpacked_array[-2] [7:0] $end
+   $var wire 8 R unpacked_array[-1] [7:0] $end
+   $var wire 8 S unpacked_array[0] [7:0] $end
+   $var wire 1 T LONGSTART_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_a_very_long_name_which_will_get_hashed_LONGEND $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
@@ -95,41 +99,43 @@ b00000000000000000000000000000000 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0 9
+09
+0:
 r0 ;
 r0 =
-b00000000000000000000000000000000 ?
-b00000000000000000000000011111111 @
+r0 ?
 b00000000000000000000000000000000 A
-b00000000000000000000000000000000 B
-b000 C
-b000 D
+b00000000000000000000000011111111 B
+b00000000000000000000000000000000 C
+b00000000000000000000000000000000 D
 b000 E
-0F
-0G
+b000 F
+b000 G
 0H
 0I
 0J
 0K
 0L
-b0000000000000000000000000000000000000000000000000000000000000000 M
-b00000000 O
-b00000000 P
+0M
+0N
+b0000000000000000000000000000000000000000000000000000000000000000 O
 b00000000 Q
-0R
+b00000000 R
+b00000000 S
+0T
 #10
 b00000000000000000000000000000001 #
 1$
@@ -140,30 +146,32 @@ b00000000000000000000000000000001 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.1 9
-r0.2 ;
-r0.3 =
-b00000000000000000000000000000001 ?
-b00000000000000000000000011111110 @
+19
+1:
+r0.1 ;
+r0.2 =
+r0.3 ?
 b00000000000000000000000000000001 A
-b00000000000000000000000000000010 B
-b111 C
-1F
+b00000000000000000000000011111110 B
+b00000000000000000000000000000001 C
+b00000000000000000000000000000010 D
+b111 E
+1H
 #15
-0F
+0H
 #20
 b00000000000000000000000000000010 #
 0$
@@ -174,32 +182,34 @@ b00000000000000000000000000000010 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.2 9
-r0.4 ;
-r0.6 =
-b00000000000000000000000000000010 ?
-b00000000000000000000000011111101 @
+09
+0:
+r0.2 ;
+r0.4 =
+r0.6 ?
 b00000000000000000000000000000010 A
-b00000000000000000000000000000100 B
-b110 C
-b111 D
-b111 E
-1F
+b00000000000000000000000011111101 B
+b00000000000000000000000000000010 C
+b00000000000000000000000000000100 D
+b110 E
+b111 F
+b111 G
+1H
 #25
-0F
+0H
 #30
 b00000000000000000000000000000011 #
 1$
@@ -210,32 +220,34 @@ b00000000000000000000000000000011 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.3 9
-r0.6000000000000001 ;
-r0.8999999999999999 =
-b00000000000000000000000000000011 ?
-b00000000000000000000000011111100 @
+19
+1:
+r0.3 ;
+r0.6000000000000001 =
+r0.8999999999999999 ?
 b00000000000000000000000000000011 A
-b00000000000000000000000000000110 B
-b101 C
-b110 D
-b110 E
-1F
+b00000000000000000000000011111100 B
+b00000000000000000000000000000011 C
+b00000000000000000000000000000110 D
+b101 E
+b110 F
+b110 G
+1H
 #35
-0F
+0H
 #40
 b00000000000000000000000000000100 #
 0$
@@ -246,32 +258,34 @@ b00000000000000000000000000000100 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.4 9
-r0.8 ;
-r1.2 =
-b00000000000000000000000000000100 ?
-b00000000000000000000000011111011 @
+09
+0:
+r0.4 ;
+r0.8 =
+r1.2 ?
 b00000000000000000000000000000100 A
-b00000000000000000000000000001000 B
-b100 C
-b101 D
-b101 E
-1F
+b00000000000000000000000011111011 B
+b00000000000000000000000000000100 C
+b00000000000000000000000000001000 D
+b100 E
+b101 F
+b101 G
+1H
 #45
-0F
+0H
 #50
 b00000000000000000000000000000101 #
 1$
@@ -282,32 +296,34 @@ b00000000000000000000000000000101 #
 1)
 1*
 1+
-b11 ,
-b11 -
+1,
+1-
 b11 .
-1/
-10
+b11 /
+b11 0
 11
 12
-b11 3
-b11 4
-15
-16
+13
+14
+b11 5
+b11 6
 17
 18
-r0.5 9
-r1 ;
-r1.5 =
-b00000000000000000000000000000101 ?
-b00000000000000000000000011111010 @
+19
+1:
+r0.5 ;
+r1 =
+r1.5 ?
 b00000000000000000000000000000101 A
-b00000000000000000000000000001010 B
-b011 C
-b100 D
-b100 E
-1F
+b00000000000000000000000011111010 B
+b00000000000000000000000000000101 C
+b00000000000000000000000000001010 D
+b011 E
+b100 F
+b100 G
+1H
 #55
-0F
+0H
 #60
 b00000000000000000000000000000110 #
 0$
@@ -318,28 +334,30 @@ b00000000000000000000000000000110 #
 0)
 0*
 0+
-b00 ,
-b00 -
+0,
+0-
 b00 .
-0/
-00
+b00 /
+b00 0
 01
 02
-b00 3
-b00 4
-05
-06
+03
+04
+b00 5
+b00 6
 07
 08
-r0.6 9
-r1.2 ;
-r1.8 =
-b00000000000000000000000000000110 ?
-b00000000000000000000000011111001 @
+09
+0:
+r0.6 ;
+r1.2 =
+r1.8 ?
 b00000000000000000000000000000110 A
-b00000000000000000000000000001100 B
-b010 C
-b011 D
-b011 E
-1F
+b00000000000000000000000011111001 B
+b00000000000000000000000000000110 C
+b00000000000000000000000000001100 D
+b010 E
+b011 F
+b011 G
+1H
 #64

test_regress/t/t_trace_dumpvars_dyn_0_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:08 2026
+Tue Apr 14 15:20:41 2026
 
 $end
 $version

test_regress/t/t_trace_dumpvars_dyn_0_cc_vcd.out

@@ -1,49 +1,48 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
-
  $scope module top $end
-  $var wire 1 , clk $end
+  $var wire 1 + clk $end
   $scope module t $end
-   $var wire 1 , clk $end
-   $var wire 32 # cyc [31:0] $end
+   $var wire 1 + clk $end
+   $var wire 32 " cyc [31:0] $end
    $scope module sub1a $end
-    $var wire 32 - ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 $ value [31:0] $end
+    $var wire 32 , ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 # value [31:0] $end
     $scope module sub2a $end
-     $var wire 32 . ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 % value [31:0] $end
+     $var wire 32 - ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 $ value [31:0] $end
     $upscope $end
     $scope module sub2b $end
-     $var wire 32 / ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 & value [31:0] $end
+     $var wire 32 . ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 % value [31:0] $end
     $upscope $end
     $scope module sub2c $end
-     $var wire 32 0 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 ' value [31:0] $end
+     $var wire 32 / ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 & value [31:0] $end
     $upscope $end
    $upscope $end
    $scope module sub1b $end
-    $var wire 32 1 ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 ( value [31:0] $end
+    $var wire 32 0 ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 ' value [31:0] $end
     $scope module sub2a $end
-     $var wire 32 2 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 ) value [31:0] $end
+     $var wire 32 1 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 ( value [31:0] $end
     $upscope $end
     $scope module sub2b $end
-     $var wire 32 3 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 * value [31:0] $end
+     $var wire 32 2 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 ) value [31:0] $end
     $upscope $end
     $scope module sub2c $end
-     $var wire 32 4 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 + value [31:0] $end
+     $var wire 32 3 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 * value [31:0] $end
     $upscope $end
    $upscope $end
   $upscope $end
@@ -52,151 +51,151 @@ $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
-b00000000000000000000000000001010 $
-b00000000000000000000000000001011 %
-b00000000000000000000000000001100 &
-b00000000000000000000000000001101 '
-b00000000000000000000000000010100 (
-b00000000000000000000000000010101 )
-b00000000000000000000000000010110 *
-b00000000000000000000000000010111 +
-0,
-b00000000000000000000000000001010 -
-b00000000000000000000000000001011 .
-b00000000000000000000000000001100 /
-b00000000000000000000000000001101 0
-b00000000000000000000000000010100 1
-b00000000000000000000000000010101 2
-b00000000000000000000000000010110 3
-b00000000000000000000000000010111 4
-#1
-b00000000000000000000000000000001 #
+b00000000000000000000000000000000 "
+b00000000000000000000000000001010 #
 b00000000000000000000000000001011 $
 b00000000000000000000000000001100 %
 b00000000000000000000000000001101 &
-b00000000000000000000000000001110 '
+b00000000000000000000000000010100 '
 b00000000000000000000000000010101 (
 b00000000000000000000000000010110 )
 b00000000000000000000000000010111 *
-b00000000000000000000000000011000 +
-1,
-#2
-0,
-#3
-b00000000000000000000000000000010 #
+0+
+b00000000000000000000000000001010 ,
+b00000000000000000000000000001011 -
+b00000000000000000000000000001100 .
+b00000000000000000000000000001101 /
+b00000000000000000000000000010100 0
+b00000000000000000000000000010101 1
+b00000000000000000000000000010110 2
+b00000000000000000000000000010111 3
+#1
+b00000000000000000000000000000001 "
+b00000000000000000000000000001011 #
 b00000000000000000000000000001100 $
 b00000000000000000000000000001101 %
 b00000000000000000000000000001110 &
-b00000000000000000000000000001111 '
+b00000000000000000000000000010101 '
 b00000000000000000000000000010110 (
 b00000000000000000000000000010111 )
 b00000000000000000000000000011000 *
-b00000000000000000000000000011001 +
-1,
-#4
-0,
-#5
-b00000000000000000000000000000011 #
+1+
+#2
+0+
+#3
+b00000000000000000000000000000010 "
+b00000000000000000000000000001100 #
 b00000000000000000000000000001101 $
 b00000000000000000000000000001110 %
 b00000000000000000000000000001111 &
-b00000000000000000000000000010000 '
+b00000000000000000000000000010110 '
 b00000000000000000000000000010111 (
 b00000000000000000000000000011000 )
 b00000000000000000000000000011001 *
-b00000000000000000000000000011010 +
-1,
-#6
-0,
-#7
-b00000000000000000000000000000100 #
+1+
+#4
+0+
+#5
+b00000000000000000000000000000011 "
+b00000000000000000000000000001101 #
 b00000000000000000000000000001110 $
 b00000000000000000000000000001111 %
 b00000000000000000000000000010000 &
-b00000000000000000000000000010001 '
+b00000000000000000000000000010111 '
 b00000000000000000000000000011000 (
 b00000000000000000000000000011001 )
 b00000000000000000000000000011010 *
-b00000000000000000000000000011011 +
-1,
-#8
-0,
-#9
-b00000000000000000000000000000101 #
+1+
+#6
+0+
+#7
+b00000000000000000000000000000100 "
+b00000000000000000000000000001110 #
 b00000000000000000000000000001111 $
 b00000000000000000000000000010000 %
 b00000000000000000000000000010001 &
-b00000000000000000000000000010010 '
+b00000000000000000000000000011000 '
 b00000000000000000000000000011001 (
 b00000000000000000000000000011010 )
 b00000000000000000000000000011011 *
-b00000000000000000000000000011100 +
-1,
-#10
-0,
-#11
-b00000000000000000000000000000110 #
+1+
+#8
+0+
+#9
+b00000000000000000000000000000101 "
+b00000000000000000000000000001111 #
 b00000000000000000000000000010000 $
 b00000000000000000000000000010001 %
 b00000000000000000000000000010010 &
-b00000000000000000000000000010011 '
+b00000000000000000000000000011001 '
 b00000000000000000000000000011010 (
 b00000000000000000000000000011011 )
 b00000000000000000000000000011100 *
-b00000000000000000000000000011101 +
-1,
-#12
-0,
-#13
-b00000000000000000000000000000111 #
+1+
+#10
+0+
+#11
+b00000000000000000000000000000110 "
+b00000000000000000000000000010000 #
 b00000000000000000000000000010001 $
 b00000000000000000000000000010010 %
 b00000000000000000000000000010011 &
-b00000000000000000000000000010100 '
+b00000000000000000000000000011010 '
 b00000000000000000000000000011011 (
 b00000000000000000000000000011100 )
 b00000000000000000000000000011101 *
-b00000000000000000000000000011110 +
-1,
-#14
-0,
-#15
-b00000000000000000000000000001000 #
+1+
+#12
+0+
+#13
+b00000000000000000000000000000111 "
+b00000000000000000000000000010001 #
 b00000000000000000000000000010010 $
 b00000000000000000000000000010011 %
 b00000000000000000000000000010100 &
-b00000000000000000000000000010101 '
+b00000000000000000000000000011011 '
 b00000000000000000000000000011100 (
 b00000000000000000000000000011101 )
 b00000000000000000000000000011110 *
-b00000000000000000000000000011111 +
-1,
-#16
-0,
-#17
-b00000000000000000000000000001001 #
+1+
+#14
+0+
+#15
+b00000000000000000000000000001000 "
+b00000000000000000000000000010010 #
 b00000000000000000000000000010011 $
 b00000000000000000000000000010100 %
 b00000000000000000000000000010101 &
-b00000000000000000000000000010110 '
+b00000000000000000000000000011100 '
 b00000000000000000000000000011101 (
 b00000000000000000000000000011110 )
 b00000000000000000000000000011111 *
-b00000000000000000000000000100000 +
-1,
-#18
-0,
-#19
-b00000000000000000000000000001010 #
+1+
+#16
+0+
+#17
+b00000000000000000000000000001001 "
+b00000000000000000000000000010011 #
 b00000000000000000000000000010100 $
 b00000000000000000000000000010101 %
 b00000000000000000000000000010110 &
-b00000000000000000000000000010111 '
+b00000000000000000000000000011101 '
 b00000000000000000000000000011110 (
 b00000000000000000000000000011111 )
 b00000000000000000000000000100000 *
-b00000000000000000000000000100001 +
-1,
+1+
+#18
+0+
+#19
+b00000000000000000000000000001010 "
+b00000000000000000000000000010100 #
+b00000000000000000000000000010101 $
+b00000000000000000000000000010110 %
+b00000000000000000000000000010111 &
+b00000000000000000000000000011110 '
+b00000000000000000000000000011111 (
+b00000000000000000000000000100000 )
+b00000000000000000000000000100001 *
+1+
 #20
-0,
+0+

test_regress/t/t_trace_dumpvars_dyn_1_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:06 2026
+Tue Apr 14 15:20:41 2026
 
 $end
 $version

test_regress/t/t_trace_dumpvars_dyn_1_cc_vcd.out

@@ -2,11 +2,11 @@ $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
   $scope module t $end
-   $var wire 32 # cyc [31:0] $end
+   $var wire 32 " cyc [31:0] $end
    $scope module sub1a $end
-    $var wire 32 - ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 $ value [31:0] $end
+    $var wire 32 , ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 # value [31:0] $end
     $scope module sub2a $end
     $upscope $end
     $scope module sub2b $end
@@ -15,23 +15,23 @@ $timescale 1ps $end
     $upscope $end
    $upscope $end
    $scope module sub1b $end
-    $var wire 32 1 ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 ( value [31:0] $end
+    $var wire 32 0 ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 ' value [31:0] $end
     $scope module sub2a $end
-     $var wire 32 2 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 ) value [31:0] $end
+     $var wire 32 1 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 ( value [31:0] $end
     $upscope $end
     $scope module sub2b $end
-     $var wire 32 3 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 * value [31:0] $end
+     $var wire 32 2 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 ) value [31:0] $end
     $upscope $end
     $scope module sub2c $end
-     $var wire 32 4 ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 + value [31:0] $end
+     $var wire 32 3 ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 * value [31:0] $end
     $upscope $end
    $upscope $end
   $upscope $end
@@ -40,85 +40,85 @@ $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
-b00000000000000000000000000001010 $
-b00000000000000000000000000010100 (
-b00000000000000000000000000010101 )
-b00000000000000000000000000010110 *
-b00000000000000000000000000010111 +
-b00000000000000000000000000001010 -
-b00000000000000000000000000010100 1
-b00000000000000000000000000010101 2
-b00000000000000000000000000010110 3
-b00000000000000000000000000010111 4
-#1
-b00000000000000000000000000000001 #
-b00000000000000000000000000001011 $
+b00000000000000000000000000000000 "
+b00000000000000000000000000001010 #
+b00000000000000000000000000010100 '
 b00000000000000000000000000010101 (
 b00000000000000000000000000010110 )
 b00000000000000000000000000010111 *
-b00000000000000000000000000011000 +
-#3
-b00000000000000000000000000000010 #
-b00000000000000000000000000001100 $
+b00000000000000000000000000001010 ,
+b00000000000000000000000000010100 0
+b00000000000000000000000000010101 1
+b00000000000000000000000000010110 2
+b00000000000000000000000000010111 3
+#1
+b00000000000000000000000000000001 "
+b00000000000000000000000000001011 #
+b00000000000000000000000000010101 '
 b00000000000000000000000000010110 (
 b00000000000000000000000000010111 )
 b00000000000000000000000000011000 *
-b00000000000000000000000000011001 +
-#5
-b00000000000000000000000000000011 #
-b00000000000000000000000000001101 $
+#3
+b00000000000000000000000000000010 "
+b00000000000000000000000000001100 #
+b00000000000000000000000000010110 '
 b00000000000000000000000000010111 (
 b00000000000000000000000000011000 )
 b00000000000000000000000000011001 *
-b00000000000000000000000000011010 +
-#7
-b00000000000000000000000000000100 #
-b00000000000000000000000000001110 $
+#5
+b00000000000000000000000000000011 "
+b00000000000000000000000000001101 #
+b00000000000000000000000000010111 '
 b00000000000000000000000000011000 (
 b00000000000000000000000000011001 )
 b00000000000000000000000000011010 *
-b00000000000000000000000000011011 +
-#9
-b00000000000000000000000000000101 #
-b00000000000000000000000000001111 $
+#7
+b00000000000000000000000000000100 "
+b00000000000000000000000000001110 #
+b00000000000000000000000000011000 '
 b00000000000000000000000000011001 (
 b00000000000000000000000000011010 )
 b00000000000000000000000000011011 *
-b00000000000000000000000000011100 +
-#11
-b00000000000000000000000000000110 #
-b00000000000000000000000000010000 $
+#9
+b00000000000000000000000000000101 "
+b00000000000000000000000000001111 #
+b00000000000000000000000000011001 '
 b00000000000000000000000000011010 (
 b00000000000000000000000000011011 )
 b00000000000000000000000000011100 *
-b00000000000000000000000000011101 +
-#13
-b00000000000000000000000000000111 #
-b00000000000000000000000000010001 $
+#11
+b00000000000000000000000000000110 "
+b00000000000000000000000000010000 #
+b00000000000000000000000000011010 '
 b00000000000000000000000000011011 (
 b00000000000000000000000000011100 )
 b00000000000000000000000000011101 *
-b00000000000000000000000000011110 +
-#15
-b00000000000000000000000000001000 #
-b00000000000000000000000000010010 $
+#13
+b00000000000000000000000000000111 "
+b00000000000000000000000000010001 #
+b00000000000000000000000000011011 '
 b00000000000000000000000000011100 (
 b00000000000000000000000000011101 )
 b00000000000000000000000000011110 *
-b00000000000000000000000000011111 +
-#17
-b00000000000000000000000000001001 #
-b00000000000000000000000000010011 $
+#15
+b00000000000000000000000000001000 "
+b00000000000000000000000000010010 #
+b00000000000000000000000000011100 '
 b00000000000000000000000000011101 (
 b00000000000000000000000000011110 )
 b00000000000000000000000000011111 *
-b00000000000000000000000000100000 +
-#19
-b00000000000000000000000000001010 #
-b00000000000000000000000000010100 $
+#17
+b00000000000000000000000000001001 "
+b00000000000000000000000000010011 #
+b00000000000000000000000000011101 '
 b00000000000000000000000000011110 (
 b00000000000000000000000000011111 )
 b00000000000000000000000000100000 *
-b00000000000000000000000000100001 +
+#19
+b00000000000000000000000000001010 "
+b00000000000000000000000000010100 #
+b00000000000000000000000000011110 '
+b00000000000000000000000000011111 (
+b00000000000000000000000000100000 )
+b00000000000000000000000000100001 *
 #20

test_regress/t/t_trace_ena_cc.out

@@ -1,86 +1,86 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 # clk $end
+  $var wire 1 & clk $end
   $scope module t $end
-   $var wire 1 # clk $end
-   $var wire 32 $ cyc [31:0] $end
-   $var wire 32 % c_trace_on [31:0] $end
-   $var real 64 & r $end
+   $var wire 1 & clk $end
+   $var wire 32 " cyc [31:0] $end
+   $var wire 32 # c_trace_on [31:0] $end
+   $var real 64 $ r $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
-b00000000000000000000000000000001 $
-b00000000000000000000000000000000 %
-r0 &
+b00000000000000000000000000000001 "
+b00000000000000000000000000000000 #
+r0 $
+0&
 #10
-1#
-b00000000000000000000000000000010 $
-r0.1 &
+b00000000000000000000000000000010 "
+r0.1 $
+1&
 #15
-0#
+0&
 #20
-1#
-b00000000000000000000000000000011 $
-b00000000000000000000000000000001 %
-r0.2 &
+b00000000000000000000000000000011 "
+b00000000000000000000000000000001 #
+r0.2 $
+1&
 #25
-0#
+0&
 #30
-1#
-b00000000000000000000000000000100 $
-b00000000000000000000000000000010 %
-r0.3 &
+b00000000000000000000000000000100 "
+b00000000000000000000000000000010 #
+r0.3 $
+1&
 #35
-0#
+0&
 #40
-1#
-b00000000000000000000000000000101 $
-b00000000000000000000000000000011 %
-r0.4 &
+b00000000000000000000000000000101 "
+b00000000000000000000000000000011 #
+r0.4 $
+1&
 #45
-0#
+0&
 #50
-1#
-b00000000000000000000000000000110 $
-b00000000000000000000000000000100 %
-r0.5 &
+b00000000000000000000000000000110 "
+b00000000000000000000000000000100 #
+r0.5 $
+1&
 #55
-0#
+0&
 #60
-1#
-b00000000000000000000000000000111 $
-b00000000000000000000000000000101 %
-r0.6 &
+b00000000000000000000000000000111 "
+b00000000000000000000000000000101 #
+r0.6 $
+1&
 #65
-0#
+0&
 #70
-1#
-b00000000000000000000000000001000 $
-b00000000000000000000000000000110 %
-r0.7 &
+b00000000000000000000000000001000 "
+b00000000000000000000000000000110 #
+r0.7 $
+1&
 #75
-0#
+0&
 #80
-1#
-b00000000000000000000000000001001 $
-b00000000000000000000000000000111 %
-r0.7999999999999999 &
+b00000000000000000000000000001001 "
+b00000000000000000000000000000111 #
+r0.7999999999999999 $
+1&
 #85
-0#
+0&
 #90
-1#
-b00000000000000000000000000001010 $
-b00000000000000000000000000001000 %
-r0.8999999999999999 &
+b00000000000000000000000000001010 "
+b00000000000000000000000000001000 #
+r0.8999999999999999 $
+1&
 #95
-0#
+0&
 #100
-1#
-b00000000000000000000000000001011 $
-b00000000000000000000000000001001 %
-r0.9999999999999999 &
+b00000000000000000000000000001011 "
+b00000000000000000000000000001001 #
+r0.9999999999999999 $
+1&

test_regress/t/t_trace_ena_sc.out

@@ -2,85 +2,85 @@ $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
   $scope module t $end
-   $var wire 1 # clk $end
-   $var wire 32 $ cyc [31:0] $end
-   $var wire 32 % c_trace_on [31:0] $end
-   $var real 64 & r $end
+   $var wire 1 & clk $end
+   $var wire 32 " cyc [31:0] $end
+   $var wire 32 # c_trace_on [31:0] $end
+   $var real 64 $ r $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
-b00000000000000000000000000000001 $
-b00000000000000000000000000000000 %
-r0 &
+b00000000000000000000000000000001 "
+b00000000000000000000000000000000 #
+r0 $
+0&
 #10
-1#
-b00000000000000000000000000000010 $
-r0.1 &
+b00000000000000000000000000000010 "
+r0.1 $
+1&
 #15
-0#
+0&
 #20
-1#
-b00000000000000000000000000000011 $
-b00000000000000000000000000000001 %
-r0.2 &
+b00000000000000000000000000000011 "
+b00000000000000000000000000000001 #
+r0.2 $
+1&
 #25
-0#
+0&
 #30
-1#
-b00000000000000000000000000000100 $
-b00000000000000000000000000000010 %
-r0.3 &
+b00000000000000000000000000000100 "
+b00000000000000000000000000000010 #
+r0.3 $
+1&
 #35
-0#
+0&
 #40
-1#
-b00000000000000000000000000000101 $
-b00000000000000000000000000000011 %
-r0.4 &
+b00000000000000000000000000000101 "
+b00000000000000000000000000000011 #
+r0.4 $
+1&
 #45
-0#
+0&
 #50
-1#
-b00000000000000000000000000000110 $
-b00000000000000000000000000000100 %
-r0.5 &
+b00000000000000000000000000000110 "
+b00000000000000000000000000000100 #
+r0.5 $
+1&
 #55
-0#
+0&
 #60
-1#
-b00000000000000000000000000000111 $
-b00000000000000000000000000000101 %
-r0.6 &
+b00000000000000000000000000000111 "
+b00000000000000000000000000000101 #
+r0.6 $
+1&
 #65
-0#
+0&
 #70
-1#
-b00000000000000000000000000001000 $
-b00000000000000000000000000000110 %
-r0.7 &
+b00000000000000000000000000001000 "
+b00000000000000000000000000000110 #
+r0.7 $
+1&
 #75
-0#
+0&
 #80
-1#
-b00000000000000000000000000001001 $
-b00000000000000000000000000000111 %
-r0.7999999999999999 &
+b00000000000000000000000000001001 "
+b00000000000000000000000000000111 #
+r0.7999999999999999 $
+1&
 #85
-0#
+0&
 #90
-1#
-b00000000000000000000000000001010 $
-b00000000000000000000000000001000 %
-r0.8999999999999999 &
+b00000000000000000000000000001010 "
+b00000000000000000000000000001000 #
+r0.8999999999999999 $
+1&
 #95
-0#
+0&
 #100
-1#
-b00000000000000000000000000001011 $
-b00000000000000000000000000001001 %
-r0.9999999999999999 &
+b00000000000000000000000000001011 "
+b00000000000000000000000000001001 #
+r0.9999999999999999 $
+1&
 #104

test_regress/t/t_trace_enum_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:43 2026
+Tue Apr 14 15:20:42 2026
 
 $end
 $version
@@ -12,8 +12,6 @@ $end
   $attrbegin misc 07 $unit::state_t 4 VAL_A VAL_B VAL_C VAL_D 00 01 10 11 1 $end
   $attrbegin misc 07 t.other_state_t 3 VAL_X VAL_Y VAL_Z 00 01 10 2 $end
   $var wire 1 ! clk $end
-  $scope module $unit $end
-  $upscope $end
   $scope module t $end
    $var wire 1 ! clk $end
    $attrbegin misc 07 "" 1 $end

test_regress/t/t_trace_enum_saif.out

@@ -10,8 +10,6 @@
   (NET
    (clk (T0 10) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 1))
   )
-  (INSTANCE $unit
-  )
   (INSTANCE t
    (NET
     (clk (T0 10) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 1))

test_regress/t/t_trace_enum_vcd.out

@@ -2,8 +2,6 @@ $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
   $var wire 1 " clk $end
-  $scope module $unit $end
-  $upscope $end
   $scope module t $end
    $var wire 1 " clk $end
    $var wire 2 # v_enumed [1:0] $end

test_regress/t/t_trace_event_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:50 2026
+Tue Apr 14 15:20:42 2026
 
 $end
 $version

test_regress/t/t_trace_event_vcd.out

@@ -1,69 +1,69 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module t $end
-  $var event 1 # ev_test $end
-  $var wire 32 $ i [31:0] $end
-  $var wire 1 % toggle $end
-  $var wire 1 & clk $end
+  $var event 1 " ev_test $end
+  $var wire 32 # i [31:0] $end
+  $var wire 1 $ toggle $end
+  $var wire 1 % clk $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 $
+b00000000000000000000000000000000 #
+0$
 0%
-0&
 #10
-b00000000000000000000000000000001 $
-1&
-#20
-0&
-#30
-b00000000000000000000000000000010 $
-1&
-#40
-0&
-#50
-b00000000000000000000000000000011 $
-1&
-#60
-0&
-#70
-b00000000000000000000000000000100 $
-1&
-#80
-0&
-#90
-b00000000000000000000000000000101 $
-1&
-#100
-0&
-#110
-1#
-b00000000000000000000000000000110 $
+b00000000000000000000000000000001 #
+1%
+#20
+0%
+#30
+b00000000000000000000000000000010 #
+1%
+#40
+0%
+#50
+b00000000000000000000000000000011 #
+1%
+#60
+0%
+#70
+b00000000000000000000000000000100 #
+1%
+#80
+0%
+#90
+b00000000000000000000000000000101 #
+1%
+#100
+0%
+#110
+1"
+b00000000000000000000000000000110 #
+1$
 1%
-1&
 #120
-0&
+0%
 #130
-b00000000000000000000000000000111 $
-1&
+b00000000000000000000000000000111 #
+1%
 #140
-0&
+0%
 #150
-b00000000000000000000000000001000 $
-1&
+b00000000000000000000000000001000 #
+1%
 #160
-0&
+0%
 #170
-b00000000000000000000000000001001 $
-1&
+b00000000000000000000000000001001 #
+1%
 #180
-0&
+0%
 #190
-b00000000000000000000000000001010 $
-1&
+b00000000000000000000000000001010 #
+1%
 #200
-0&
+0%
 #210
-1&
+1%

test_regress/t/t_trace_hier_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:58 2026
+Tue Apr 14 17:15:24 2026
 
 $end
 $version

test_regress/t/t_trace_huge_array.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of either the GNU Lesser General Public License Version 3
+# or the Perl Artistic License Version 2.0.
+# SPDX-FileCopyrightText: 2024 Wilson Snyder
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+
+test.scenarios("vlt_all")
+
+test.compile(v_flags2=[
+    "--trace-vcd --trace-max-width 0 --trace-max-array 0 --output-split-ctrace 10 --trace-structs"
+])
+trace_files = glob.glob(test.obj_dir + "/*Trace*.cpp")
+if len(trace_files) < 10:
+    test.error("Too few trace files")
+
+test.execute()
+
+test.passes()

test_regress/t/t_trace_huge_array.v

@@ -0,0 +1,29 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain.
+// SPDX-FileCopyrightText: 2026 Wilson Snyder
+// SPDX-License-Identifier: CC0-1.0
+
+module t (/*AUTOARG*/
+   // Inputs
+   clk
+   );
+
+   input clk;
+   int cyc = 0;
+
+   localparam max = 1000;
+   logic [31:0] foo [max:0];
+   logic [max:0] [15:0] [31:0] bar;
+
+   always_ff @(posedge clk) begin
+      cyc <= cyc + 1;
+      foo[0] <= cyc;
+      for (int i = 1; i <= max; i++) foo[i] <= foo[i-1];
+      bar <= (bar << 32) | type(bar)'(cyc);
+      if (cyc == 10) begin
+         $write("*-* All Finished *-*\n");
+         $finish;
+      end
+   end
+endmodule

test_regress/t/t_trace_iface.out

@@ -1,19 +1,19 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 ( clk $end
+  $var wire 1 ' clk $end
   $scope module t $end
-   $var wire 1 ( clk $end
-   $var wire 32 # cyc [31:0] $end
+   $var wire 1 ' clk $end
+   $var wire 32 " cyc [31:0] $end
    $scope module c5_data $end
-    $var wire 1 $ valid $end
-    $var wire 4 % value [3:0] $end
-    $var wire 1 ) reset $end
+    $var wire 1 # valid $end
+    $var wire 4 $ value [3:0] $end
+    $var wire 1 ( reset $end
    $upscope $end
    $scope module c6_data $end
-    $var wire 1 & valid $end
-    $var wire 4 ' value [3:0] $end
-    $var wire 1 * reset $end
+    $var wire 1 % valid $end
+    $var wire 4 & value [3:0] $end
+    $var wire 1 ) reset $end
    $upscope $end
    $scope module cif2 $end
    $upscope $end
@@ -25,112 +25,112 @@ $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000001 #
-0$
-b0000 %
-0&
-b0000 '
+b00000000000000000000000000000001 "
+0#
+b0000 $
+0%
+b0000 &
+0'
 0(
 0)
-0*
 #10
-b00000000000000000000000000000010 #
-1(
+b00000000000000000000000000000010 "
+1'
 #15
-0(
+0'
 #20
-b00000000000000000000000000000011 #
-b1111 %
-1&
-b1010 '
-1(
+b00000000000000000000000000000011 "
+b1111 $
+1%
+b1010 &
+1'
 #25
-0(
+0'
 #30
-b00000000000000000000000000000100 #
-1(
+b00000000000000000000000000000100 "
+1'
 #35
-0(
+0'
 #40
-b00000000000000000000000000000101 #
-1(
+b00000000000000000000000000000101 "
+1'
 #45
-0(
+0'
 #50
-b00000000000000000000000000000110 #
-1(
+b00000000000000000000000000000110 "
+1'
 #55
-0(
+0'
 #60
-b00000000000000000000000000000111 #
-1(
+b00000000000000000000000000000111 "
+1'
 #65
-0(
+0'
 #70
-b00000000000000000000000000001000 #
-1(
+b00000000000000000000000000001000 "
+1'
 #75
-0(
+0'
 #80
-b00000000000000000000000000001001 #
-1(
+b00000000000000000000000000001001 "
+1'
 #85
-0(
+0'
 #90
-b00000000000000000000000000001010 #
-1(
+b00000000000000000000000000001010 "
+1'
 #95
-0(
+0'
 #100
-b00000000000000000000000000001011 #
-1(
+b00000000000000000000000000001011 "
+1'
 #105
-0(
+0'
 #110
-b00000000000000000000000000001100 #
-1(
+b00000000000000000000000000001100 "
+1'
 #115
-0(
+0'
 #120
-b00000000000000000000000000001101 #
-1(
+b00000000000000000000000000001101 "
+1'
 #125
-0(
+0'
 #130
-b00000000000000000000000000001110 #
-1(
+b00000000000000000000000000001110 "
+1'
 #135
-0(
+0'
 #140
-b00000000000000000000000000001111 #
-1(
+b00000000000000000000000000001111 "
+1'
 #145
-0(
+0'
 #150
-b00000000000000000000000000010000 #
-1(
+b00000000000000000000000000010000 "
+1'
 #155
-0(
+0'
 #160
-b00000000000000000000000000010001 #
-1(
+b00000000000000000000000000010001 "
+1'
 #165
-0(
+0'
 #170
-b00000000000000000000000000010010 #
-1(
+b00000000000000000000000000010010 "
+1'
 #175
-0(
+0'
 #180
-b00000000000000000000000000010011 #
-1(
+b00000000000000000000000000010011 "
+1'
 #185
-0(
+0'
 #190
-b00000000000000000000000000010100 #
-1(
+b00000000000000000000000000010100 "
+1'
 #195
-0(
+0'
 #200
-b00000000000000000000000000010101 #
-1(
+b00000000000000000000000000010101 "
+1'

test_regress/t/t_trace_interface_ref_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:41 2026
+Tue Apr 14 15:20:43 2026
 
 $end
 $version

test_regress/t/t_trace_interface_ref_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:10 2026
+Tue Apr 14 15:20:43 2026
 
 $end
 $version

test_regress/t/t_trace_lib_default_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 21 21:35:43 2026
+Tue Apr 14 15:20:29 2026
 
 $end
 $version

test_regress/t/t_trace_lib_notop_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 21 21:35:35 2026
+Tue Apr 14 15:20:30 2026
 
 $end
 $version

test_regress/t/t_trace_max.out

@@ -1,43 +1,43 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 # clk $end
+  $var wire 1 " clk $end
   $scope module t $end
-   $var wire 1 # clk $end
-   $var wire 32 $ cyc [31:0] $end
+   $var wire 1 " clk $end
+   $var wire 32 # cyc [31:0] $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
-b00000000000000000000000000000000 $
+0"
+b00000000000000000000000000000000 #
 #10
-1#
-b00000000000000000000000000000001 $
+1"
+b00000000000000000000000000000001 #
 #15
-0#
+0"
 #20
-1#
-b00000000000000000000000000000010 $
+1"
+b00000000000000000000000000000010 #
 #25
-0#
+0"
 #30
-1#
-b00000000000000000000000000000011 $
+1"
+b00000000000000000000000000000011 #
 #35
-0#
+0"
 #40
-1#
-b00000000000000000000000000000100 $
+1"
+b00000000000000000000000000000100 #
 #45
-0#
+0"
 #50
-1#
-b00000000000000000000000000000101 $
+1"
+b00000000000000000000000000000101 #
 #55
-0#
+0"
 #60
-1#
-b00000000000000000000000000000110 $
+1"
+b00000000000000000000000000000110 #

test_regress/t/t_trace_max_default.out

@@ -1,59 +1,60 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module top $end
-  $var wire 1 O clk $end
+  $var wire 1 N clk $end
   $scope module t $end
-   $var wire 1 O clk $end
-   $var wire 32 # cyc [31:0] $end
-   $var wire 96 $ wide1 [95:0] $end
-   $var wire 16 ' wide2[0] [15:0] $end
-   $var wire 16 ( wide2[1] [15:0] $end
-   $var wire 16 ) wide2[2] [15:0] $end
-   $var wire 16 * wide2[3] [15:0] $end
-   $var wire 16 + wide2[4] [15:0] $end
-   $var wire 16 , wide2[5] [15:0] $end
-   $var wire 16 - wide2[6] [15:0] $end
-   $var wire 16 . wide2[7] [15:0] $end
-   $var wire 16 / wide2[8] [15:0] $end
-   $var wire 16 0 wide2[9] [15:0] $end
-   $var wire 16 1 wide2[10] [15:0] $end
-   $var wire 16 2 wide2[11] [15:0] $end
-   $var wire 16 3 wide2[12] [15:0] $end
-   $var wire 16 4 wide2[13] [15:0] $end
-   $var wire 16 5 wide2[14] [15:0] $end
-   $var wire 16 6 wide2[15] [15:0] $end
-   $var wire 1 7 deep1[0] $end
-   $var wire 1 8 deep1[1] $end
-   $var wire 1 9 deep1[2] $end
-   $var wire 1 : deep1[3] $end
-   $var wire 1 ; deep1[4] $end
-   $var wire 1 < deep1[5] $end
-   $var wire 1 = deep1[6] $end
-   $var wire 1 > deep1[7] $end
-   $var wire 1 ? deep1[8] $end
-   $var wire 1 @ deep1[9] $end
-   $var wire 1 A deep1[10] $end
-   $var wire 1 B deep1[11] $end
-   $var wire 1 C deep1[12] $end
-   $var wire 1 D deep1[13] $end
-   $var wire 1 E deep1[14] $end
-   $var wire 1 F deep1[15] $end
-   $var wire 1 G deep1[16] $end
-   $var wire 1 H deep1[17] $end
-   $var wire 1 I deep1[18] $end
-   $var wire 1 J deep1[19] $end
-   $var wire 1 K deep1[20] $end
-   $var wire 1 L deep1[21] $end
-   $var wire 1 M deep1[22] $end
-   $var wire 1 N deep1[23] $end
+   $var wire 1 N clk $end
+   $var wire 32 " cyc [31:0] $end
+   $var wire 96 # wide1 [95:0] $end
+   $var wire 16 & wide2[0] [15:0] $end
+   $var wire 16 ' wide2[1] [15:0] $end
+   $var wire 16 ( wide2[2] [15:0] $end
+   $var wire 16 ) wide2[3] [15:0] $end
+   $var wire 16 * wide2[4] [15:0] $end
+   $var wire 16 + wide2[5] [15:0] $end
+   $var wire 16 , wide2[6] [15:0] $end
+   $var wire 16 - wide2[7] [15:0] $end
+   $var wire 16 . wide2[8] [15:0] $end
+   $var wire 16 / wide2[9] [15:0] $end
+   $var wire 16 0 wide2[10] [15:0] $end
+   $var wire 16 1 wide2[11] [15:0] $end
+   $var wire 16 2 wide2[12] [15:0] $end
+   $var wire 16 3 wide2[13] [15:0] $end
+   $var wire 16 4 wide2[14] [15:0] $end
+   $var wire 16 5 wide2[15] [15:0] $end
+   $var wire 1 6 deep1[0] $end
+   $var wire 1 7 deep1[1] $end
+   $var wire 1 8 deep1[2] $end
+   $var wire 1 9 deep1[3] $end
+   $var wire 1 : deep1[4] $end
+   $var wire 1 ; deep1[5] $end
+   $var wire 1 < deep1[6] $end
+   $var wire 1 = deep1[7] $end
+   $var wire 1 > deep1[8] $end
+   $var wire 1 ? deep1[9] $end
+   $var wire 1 @ deep1[10] $end
+   $var wire 1 A deep1[11] $end
+   $var wire 1 B deep1[12] $end
+   $var wire 1 C deep1[13] $end
+   $var wire 1 D deep1[14] $end
+   $var wire 1 E deep1[15] $end
+   $var wire 1 F deep1[16] $end
+   $var wire 1 G deep1[17] $end
+   $var wire 1 H deep1[18] $end
+   $var wire 1 I deep1[19] $end
+   $var wire 1 J deep1[20] $end
+   $var wire 1 K deep1[21] $end
+   $var wire 1 L deep1[22] $end
+   $var wire 1 M deep1[23] $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 $
+b00000000000000000000000000000000 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 #
+b0000000000000000 &
 b0000000000000000 '
 b0000000000000000 (
 b0000000000000000 )
@@ -69,7 +70,7 @@ b0000000000000000 2
 b0000000000000000 3
 b0000000000000000 4
 b0000000000000000 5
-b0000000000000000 6
+06
 07
 08
 09
@@ -94,47 +95,46 @@ b0000000000000000 6
 0L
 0M
 0N
-0O
 #10
-b00000000000000000000000000000001 #
-1O
+b00000000000000000000000000000001 "
+1N
 #15
-0O
+0N
 #20
-b00000000000000000000000000000010 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 $
-b0000000000000001 )
-1:
-1O
+b00000000000000000000000000000010 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 #
+b0000000000000001 (
+19
+1N
 #25
-0O
+0N
 #30
-b00000000000000000000000000000011 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010 $
-b0000000000000010 )
-0:
-1O
+b00000000000000000000000000000011 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010 #
+b0000000000000010 (
+09
+1N
 #35
-0O
+0N
 #40
-b00000000000000000000000000000100 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011 $
-b0000000000000011 )
-1:
-1O
+b00000000000000000000000000000100 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011 #
+b0000000000000011 (
+19
+1N
 #45
-0O
+0N
 #50
-b00000000000000000000000000000101 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100 $
-b0000000000000100 )
-0:
-1O
+b00000000000000000000000000000101 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100 #
+b0000000000000100 (
+09
+1N
 #55
-0O
+0N
 #60
-b00000000000000000000000000000110 #
-b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101 $
-b0000000000000101 )
-1:
-1O
+b00000000000000000000000000000110 "
+b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101 #
+b0000000000000101 (
+19
+1N

test_regress/t/t_trace_no_top_name2_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:09 2026
+Tue Apr 14 15:20:43 2026
 
 $end
 $version

test_regress/t/t_trace_no_top_name2_vcd.out

@@ -1,73 +1,73 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module $rootio $end
-  $var wire 1 # clk $end
+  $var wire 1 " clk $end
  $upscope $end
  $scope module foo_pkg $end
-  $var wire 32 & foo_func__Vstatic__b_current [31:0] $end
+  $var wire 32 % foo_func__Vstatic__b_current [31:0] $end
  $upscope $end
  $scope module t $end
-  $var wire 1 # clk $end
-  $var wire 32 $ cyc [31:0] $end
+  $var wire 1 " clk $end
+  $var wire 32 # cyc [31:0] $end
   $scope module sub $end
-   $var wire 32 % a [31:0] $end
+   $var wire 32 $ a [31:0] $end
   $upscope $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
-b00000000000000000000000000000000 $
-b00000000000000000000010010111100 %
-b00000000000000000000000000000000 &
+0"
+b00000000000000000000000000000000 #
+b00000000000000000000010010111100 $
+b00000000000000000000000000000000 %
 #1
-1#
-b00000000000000000000000000000001 $
+1"
+b00000000000000000000000000000001 #
 #2
-0#
+0"
 #3
-1#
-b00000000000000000000000000000010 $
+1"
+b00000000000000000000000000000010 #
 #4
-0#
+0"
 #5
-1#
-b00000000000000000000000000000011 $
+1"
+b00000000000000000000000000000011 #
 #6
-0#
+0"
 #7
-1#
-b00000000000000000000000000000100 $
+1"
+b00000000000000000000000000000100 #
 #8
-0#
+0"
 #9
-1#
-b00000000000000000000000000000101 $
+1"
+b00000000000000000000000000000101 #
 #10
-0#
+0"
 #11
-1#
-b00000000000000000000000000000110 $
+1"
+b00000000000000000000000000000110 #
 #12
-0#
+0"
 #13
-1#
-b00000000000000000000000000000111 $
+1"
+b00000000000000000000000000000111 #
 #14
-0#
+0"
 #15
-1#
-b00000000000000000000000000001000 $
+1"
+b00000000000000000000000000001000 #
 #16
-0#
+0"
 #17
-1#
-b00000000000000000000000000001001 $
+1"
+b00000000000000000000000000001001 #
 #18
-0#
+0"
 #19
-1#
-b00000000000000000000000000001010 $
+1"
+b00000000000000000000000000001010 #
 #20
-0#
+0"

test_regress/t/t_trace_no_top_name_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:18 2026
+Tue Apr 14 15:20:43 2026
 
 $end
 $version

test_regress/t/t_trace_no_top_name_vcd.out

@@ -1,13 +1,13 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module another_top $end
-  $var wire 1 # b $end
+  $var wire 1 " b $end
  $upscope $end
  $scope module t $end
-  $var wire 1 # a $end
+  $var wire 1 " a $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-0#
+0"

test_regress/t/t_trace_packed_struct_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:23 2026
+Tue Apr 14 15:20:44 2026
 
 $end
 $version

test_regress/t/t_trace_packed_struct_cc_saif.out

@@ -45,198 +45,6 @@
     (cnt\[29\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (cnt\[30\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (cnt\[31\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[0\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[1\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[2\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[3\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[4\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[5\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[6\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[7\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[8\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[9\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[10\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[11\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[12\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[13\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[14\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[15\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[16\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[17\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[18\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[19\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[20\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[21\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[22\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[23\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[24\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[25\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[26\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[27\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[28\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[29\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[30\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[31\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[32\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[33\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[34\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[35\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[36\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[37\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[38\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[39\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[40\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[41\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[42\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[43\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[44\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[45\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[46\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[47\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[48\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[49\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[50\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[51\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[52\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[53\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[54\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[55\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[56\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[57\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[58\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[59\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[60\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[61\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[62\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[63\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[64\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[65\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[66\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[67\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[68\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[69\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[70\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[71\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[72\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[73\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[74\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[75\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[76\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[77\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[78\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[79\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[80\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[81\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[82\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[83\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[84\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[85\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[86\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[87\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[88\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[89\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[90\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[91\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[92\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[93\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[0]\[94\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[0]\[95\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[0\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[1\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[2\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[3\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[4\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[5\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[6\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[7\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[8\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[9\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[10\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[11\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[12\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[13\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[14\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[15\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[16\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[17\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[18\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[19\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[20\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[21\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[22\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[23\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[24\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[25\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[26\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[27\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[28\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[29\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[1]\[30\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[31\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[32\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[1]\[33\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[34\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[35\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[36\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[37\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[38\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[39\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[40\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[41\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[42\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[43\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[44\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[45\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[46\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[47\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[48\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[49\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[50\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[51\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[52\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[53\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[54\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[55\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[56\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[57\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[58\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[59\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[60\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[61\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[1]\[62\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[63\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[64\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[65\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[1]\[66\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[67\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[68\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[69\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[70\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[71\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[72\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[73\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[74\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[75\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[76\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[77\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[78\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[79\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[80\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[81\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[82\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[83\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[84\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[85\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[86\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[87\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[88\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[89\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[90\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[91\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[92\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[93\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
-    (v[1]\[94\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
-    (v[1]\[95\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v[2]\[0\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v[2]\[1\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v[2]\[2\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
@@ -333,6 +141,198 @@
     (v[2]\[93\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v[2]\[94\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
     (v[2]\[95\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[0\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[1\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[2\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[3\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[4\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[5\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[6\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[7\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[8\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[9\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[10\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[11\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[12\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[13\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[14\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[15\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[16\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[17\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[18\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[19\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[20\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[21\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[22\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[23\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[24\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[25\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[26\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[27\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[28\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[29\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[1]\[30\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[31\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[32\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[1]\[33\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[34\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[35\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[36\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[37\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[38\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[39\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[40\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[41\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[42\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[43\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[44\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[45\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[46\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[47\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[48\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[49\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[50\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[51\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[52\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[53\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[54\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[55\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[56\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[57\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[58\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[59\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[60\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[61\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[1]\[62\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[63\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[64\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[65\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[1]\[66\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[67\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[68\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[69\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[70\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[71\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[72\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[73\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[74\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[75\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[76\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[77\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[78\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[79\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[80\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[81\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[82\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[83\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[84\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[85\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[86\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[87\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[88\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[89\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[90\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[91\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[92\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[93\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[1]\[94\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[1]\[95\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[0\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[1\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[2\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[3\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[4\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[5\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[6\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[7\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[8\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[9\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[10\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[11\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[12\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[13\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[14\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[15\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[16\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[17\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[18\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[19\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[20\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[21\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[22\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[23\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[24\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[25\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[26\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[27\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[28\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[29\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[30\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[31\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[32\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[33\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[34\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[35\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[36\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[37\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[38\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[39\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[40\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[41\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[42\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[43\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[44\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[45\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[46\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[47\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[48\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[49\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[50\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[51\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[52\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[53\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[54\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[55\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[56\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[57\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[58\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[59\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[60\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[61\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[62\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[63\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[64\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[65\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[66\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[67\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[68\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[69\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[70\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[71\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[72\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[73\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[74\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[75\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[76\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[77\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[78\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[79\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[80\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[81\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[82\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[83\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[84\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[85\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[86\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[87\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[88\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[89\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[90\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[91\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[92\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[93\] (T0 0) (T1 40) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (v[0]\[94\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (v[0]\[95\] (T0 40) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
    )
   )
  )

test_regress/t/t_trace_packed_struct_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:13 2026
+Tue Apr 14 15:20:44 2026
 
 $end
 $version

test_regress/t/t_trace_param_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:16:46 2026
+Tue Apr 14 15:20:43 2026
 
 $end
 $version

test_regress/t/t_trace_param_override.out

@@ -1,12 +1,12 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
  $scope module t $end
-  $var wire 32 # POVERRODE [31:0] $end
-  $var wire 32 $ PORIG [31:0] $end
+  $var wire 32 " POVERRODE [31:0] $end
+  $var wire 32 # PORIG [31:0] $end
  $upscope $end
 $enddefinitions $end
 
 
 #0
-b00000000000000000000000000011111 #
-b00000000000000000000000000010000 $
+b00000000000000000000000000011111 "
+b00000000000000000000000000010000 #

test_regress/t/t_trace_primitive_cc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:00 2026
+Tue Apr 14 15:20:44 2026
 
 $end
 $version

test_regress/t/t_trace_primitive_sc_fst.out

@@ -1,5 +1,5 @@
 $date
-Sat Mar 14 09:17:00 2026
+Tue Apr 14 15:20:44 2026
 
 $end
 $version

test_regress/t/t_trace_public.out

@@ -6,8 +6,8 @@ $timescale 1ps $end
   $scope module t $end
    $var wire 1 4 CLK $end
    $var wire 1 " RESET $end
-   $var wire 2 # vec[3] [2:1] $end
-   $var wire 2 $ vec[4] [2:1] $end
+   $var wire 2 # vec[4] [2:1] $end
+   $var wire 2 $ vec[3] [2:1] $end
    $var wire 32 % val [31:0] $end
    $scope module glbl $end
     $var wire 1 6 GSR $end

test_regress/t/t_trace_scope_no_inline.out

@@ -5,19 +5,19 @@ $timescale 1ps $end
    $scope module mid_a $end
    $upscope $end
    $scope module mid_b $end
-    $var wire 1 ' clk $end
-    $var wire 32 # cnt [31:0] $end
+    $var wire 1 & clk $end
+    $var wire 32 " cnt [31:0] $end
     $scope module sub_a $end
-     $var wire 1 ' clk $end
-     $var wire 32 $ cnt [31:0] $end
+     $var wire 1 & clk $end
+     $var wire 32 # cnt [31:0] $end
     $upscope $end
     $scope module sub_b $end
-     $var wire 1 ' clk $end
-     $var wire 32 % cnt [31:0] $end
+     $var wire 1 & clk $end
+     $var wire 32 $ cnt [31:0] $end
     $upscope $end
     $scope module sub_c $end
-     $var wire 1 ' clk $end
-     $var wire 32 & cnt [31:0] $end
+     $var wire 1 & clk $end
+     $var wire 32 % cnt [31:0] $end
     $upscope $end
    $upscope $end
    $scope module mid_c $end
@@ -28,54 +28,54 @@ $enddefinitions $end
 
 
 #0
+b00000000000000000000000000000000 "
 b00000000000000000000000000000000 #
 b00000000000000000000000000000000 $
 b00000000000000000000000000000000 %
-b00000000000000000000000000000000 &
-0'
+0&
 #10
-b00000000000000000000000000000001 #
+b00000000000000000000000000000001 "
+b00000000000000000000000000000010 #
 b00000000000000000000000000000010 $
 b00000000000000000000000000000010 %
-b00000000000000000000000000000010 &
-1'
+1&
 #15
-0'
+0&
 #20
-b00000000000000000000000000000010 #
+b00000000000000000000000000000010 "
+b00000000000000000000000000000100 #
 b00000000000000000000000000000100 $
 b00000000000000000000000000000100 %
-b00000000000000000000000000000100 &
-1'
+1&
 #25
-0'
+0&
 #30
-b00000000000000000000000000000011 #
+b00000000000000000000000000000011 "
+b00000000000000000000000000000110 #
 b00000000000000000000000000000110 $
 b00000000000000000000000000000110 %
-b00000000000000000000000000000110 &
-1'
+1&
 #35
-0'
+0&
 #40
-b00000000000000000000000000000100 #
+b00000000000000000000000000000100 "
+b00000000000000000000000000001000 #
 b00000000000000000000000000001000 $
 b00000000000000000000000000001000 %
-b00000000000000000000000000001000 &
-1'
+1&
 #45
-0'
+0&
 #50
-b00000000000000000000000000000101 #
+b00000000000000000000000000000101 "
+b00000000000000000000000000001010 #
 b00000000000000000000000000001010 $
 b00000000000000000000000000001010 %
-b00000000000000000000000000001010 &
-1'
+1&
 #55
-0'
+0&
 #60
-b00000000000000000000000000000110 #
+b00000000000000000000000000000110 "
+b00000000000000000000000000001100 #
 b00000000000000000000000000001100 $
 b00000000000000000000000000001100 %
-b00000000000000000000000000001100 &
-1'
+1&

test_regress/t/t_trace_scope_vlt.out

@@ -1,32 +1,31 @@
 $version Generated by VerilatedVcd $end
 $timescale 1ps $end
-
  $scope module top $end
-  $var wire 1 ) clk $end
+  $var wire 1 ( clk $end
   $scope module t $end
-   $var wire 1 ) clk $end
+   $var wire 1 ( clk $end
    $scope module sub1a $end
-    $var wire 32 * ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 $ value [31:0] $end
+    $var wire 32 ) ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 # value [31:0] $end
    $upscope $end
    $scope module sub1b $end
-    $var wire 32 + ADD [31:0] $end
-    $var wire 32 # cyc [31:0] $end
-    $var wire 32 % value [31:0] $end
+    $var wire 32 * ADD [31:0] $end
+    $var wire 32 " cyc [31:0] $end
+    $var wire 32 $ value [31:0] $end
     $scope module sub2a $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 & value [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 % value [31:0] $end
     $upscope $end
     $scope module sub2b $end
-     $var wire 32 , ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 ' value [31:0] $end
+     $var wire 32 + ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 & value [31:0] $end
     $upscope $end
     $scope module sub2c $end
-     $var wire 32 - ADD [31:0] $end
-     $var wire 32 # cyc [31:0] $end
-     $var wire 32 ( value [31:0] $end
+     $var wire 32 , ADD [31:0] $end
+     $var wire 32 " cyc [31:0] $end
+     $var wire 32 ' value [31:0] $end
     $upscope $end
    $upscope $end
   $upscope $end
@@ -35,122 +34,122 @@ $enddefinitions $end
 
 
 #0
-b00000000000000000000000000000000 #
-b00000000000000000000000000001010 $
-b00000000000000000000000000010100 %
-b00000000000000000000000000010101 &
-b00000000000000000000000000010110 '
-b00000000000000000000000000010111 (
-0)
-b00000000000000000000000000001010 *
-b00000000000000000000000000010100 +
-b00000000000000000000000000010110 ,
-b00000000000000000000000000010111 -
-#10
-b00000000000000000000000000000001 #
-b00000000000000000000000000001011 $
+b00000000000000000000000000000000 "
+b00000000000000000000000000001010 #
+b00000000000000000000000000010100 $
 b00000000000000000000000000010101 %
 b00000000000000000000000000010110 &
 b00000000000000000000000000010111 '
-b00000000000000000000000000011000 (
-1)
-#15
-0)
-#20
-b00000000000000000000000000000010 #
-b00000000000000000000000000001100 $
+0(
+b00000000000000000000000000001010 )
+b00000000000000000000000000010100 *
+b00000000000000000000000000010110 +
+b00000000000000000000000000010111 ,
+#10
+b00000000000000000000000000000001 "
+b00000000000000000000000000001011 #
+b00000000000000000000000000010101 $
 b00000000000000000000000000010110 %
 b00000000000000000000000000010111 &
 b00000000000000000000000000011000 '
-b00000000000000000000000000011001 (
-1)
-#25
-0)
-#30
-b00000000000000000000000000000011 #
-b00000000000000000000000000001101 $
+1(
+#15
+0(
+#20
+b00000000000000000000000000000010 "
+b00000000000000000000000000001100 #
+b00000000000000000000000000010110 $
 b00000000000000000000000000010111 %
 b00000000000000000000000000011000 &
 b00000000000000000000000000011001 '
-b00000000000000000000000000011010 (
-1)
-#35
-0)
-#40
-b00000000000000000000000000000100 #
-b00000000000000000000000000001110 $
+1(
+#25
+0(
+#30
+b00000000000000000000000000000011 "
+b00000000000000000000000000001101 #
+b00000000000000000000000000010111 $
 b00000000000000000000000000011000 %
 b00000000000000000000000000011001 &
 b00000000000000000000000000011010 '
-b00000000000000000000000000011011 (
-1)
-#45
-0)
-#50
-b00000000000000000000000000000101 #
-b00000000000000000000000000001111 $
+1(
+#35
+0(
+#40
+b00000000000000000000000000000100 "
+b00000000000000000000000000001110 #
+b00000000000000000000000000011000 $
 b00000000000000000000000000011001 %
 b00000000000000000000000000011010 &
 b00000000000000000000000000011011 '
-b00000000000000000000000000011100 (
-1)
-#55
-0)
-#60
-b00000000000000000000000000000110 #
-b00000000000000000000000000010000 $
+1(
+#45
+0(
+#50
+b00000000000000000000000000000101 "
+b00000000000000000000000000001111 #
+b00000000000000000000000000011001 $
 b00000000000000000000000000011010 %
 b00000000000000000000000000011011 &
 b00000000000000000000000000011100 '
-b00000000000000000000000000011101 (
-1)
-#65
-0)
-#70
-b00000000000000000000000000000111 #
-b00000000000000000000000000010001 $
+1(
+#55
+0(
+#60
+b00000000000000000000000000000110 "
+b00000000000000000000000000010000 #
+b00000000000000000000000000011010 $
 b00000000000000000000000000011011 %
 b00000000000000000000000000011100 &
 b00000000000000000000000000011101 '
-b00000000000000000000000000011110 (
-1)
-#75
-0)
-#80
-b00000000000000000000000000001000 #
-b00000000000000000000000000010010 $
+1(
+#65
+0(
+#70
+b00000000000000000000000000000111 "
+b00000000000000000000000000010001 #
+b00000000000000000000000000011011 $
 b00000000000000000000000000011100 %
 b00000000000000000000000000011101 &
 b00000000000000000000000000011110 '
-b00000000000000000000000000011111 (
-1)
-#85
-0)
-#90
-b00000000000000000000000000001001 #
-b00000000000000000000000000010011 $
+1(
+#75
+0(
+#80
+b00000000000000000000000000001000 "
+b00000000000000000000000000010010 #
+b00000000000000000000000000011100 $
 b00000000000000000000000000011101 %
 b00000000000000000000000000011110 &
 b00000000000000000000000000011111 '
-b00000000000000000000000000100000 (
-1)
-#95
-0)
-#100
-b00000000000000000000000000001010 #
-b00000000000000000000000000010100 $
+1(
+#85
+0(
+#90
+b00000000000000000000000000001001 "
+b00000000000000000000000000010011 #
+b00000000000000000000000000011101 $
 b00000000000000000000000000011110 %
 b00000000000000000000000000011111 &
 b00000000000000000000000000100000 '
-b00000000000000000000000000100001 (
-1)
-#105
-0)
-#110
-b00000000000000000000000000001011 #
-b00000000000000000000000000010101 $
+1(
+#95
+0(
+#100
+b00000000000000000000000000001010 "
+b00000000000000000000000000010100 #
+b00000000000000000000000000011110 $
 b00000000000000000000000000011111 %
 b00000000000000000000000000100000 &
 b00000000000000000000000000100001 '
-b00000000000000000000000000100010 (
-1)
+1(
+#105
+0(
+#110
+b00000000000000000000000000001011 "
+b00000000000000000000000000010101 #
+b00000000000000000000000000011111 $
+b00000000000000000000000000100000 %
+b00000000000000000000000000100001 &
+b00000000000000000000000000100010 '
+1(

test_regress/t/t_trace_split_struct.v

@@ -0,0 +1,45 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain.
+// SPDX-FileCopyrightText: 2026 Wilson Snyder
+// SPDX-License-Identifier: CC0-1.0
+
+// Test that when struct fields are driven from different clocks,
+// no trace_chg_dtype function is created (fields must be traced individually).
+
+bit global_bit;
+
+module t (clk, clk2);
+   input clk;
+   input clk2;
+   integer cyc = 0;
+
+   typedef struct packed {
+      bit         b1;
+      bit         b0;
+   } strp_t;
+
+   strp_t       v_strp, v_strp2;
+   logic foo;
+
+   logic [7:0]       unpacked_array[-7:0];
+
+   always @ (posedge clk) begin
+      cyc <= cyc + 1;
+      foo <= ~foo;
+      v_strp.b0 <= cyc[0];
+      v_strp2.b0 <= cyc[2];
+      unpacked_array[0] = cyc[8:1];
+      if (cyc == 5) begin
+         $write("*-* All Finished *-*\n");
+         $finish;
+      end
+   end
+
+   always @(posedge clk2) begin
+      v_strp.b1 <= cyc[1];
+      v_strp2.b1 <= cyc[3];
+     for (int i = -1; i > -8; i--)
+       unpacked_array[i] = cyc[7:0];
+   end
+endmodule

test_regress/t/t_trace_split_struct_fst.out

@@ -0,0 +1,107 @@
+$date
+Tue Mar 31 17:23:31 2026
+
+$end
+$version
+Generated by VerilatedFst
+$end
+$timescale
+1ps
+$end
+ $scope module top $end
+  $var wire 1 ! clk $end
+  $var wire 1 " clk2 $end
+  $scope module $unit $end
+   $var bit 1 # global_bit $end
+  $upscope $end
+  $scope module t $end
+   $var wire 1 ! clk $end
+   $var wire 1 " clk2 $end
+   $var integer 32 $ cyc [31:0] $end
+   $attrbegin pack packed members 2 $end
+   $scope struct v_strp $end
+    $var bit 1 % b1 $end
+    $var bit 1 & b0 $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
+   $scope struct v_strp2 $end
+    $var bit 1 ' b1 $end
+    $var bit 1 ( b0 $end
+   $upscope $end
+   $var logic 1 ) foo $end
+   $attrbegin array unpacked bounds -30064771072 $end
+   $scope sv_array unpacked_array $end
+    $var logic 8 * unpacked_array[-7] [7:0] $end
+    $var logic 8 + unpacked_array[-6] [7:0] $end
+    $var logic 8 , unpacked_array[-5] [7:0] $end
+    $var logic 8 - unpacked_array[-4] [7:0] $end
+    $var logic 8 . unpacked_array[-3] [7:0] $end
+    $var logic 8 / unpacked_array[-2] [7:0] $end
+    $var logic 8 0 unpacked_array[-1] [7:0] $end
+    $var logic 8 1 unpacked_array[0] [7:0] $end
+   $upscope $end
+  $upscope $end
+ $upscope $end
+$enddefinitions $end
+#0
+$dumpvars
+b00000000 1
+b00000000 0
+b00000000 /
+b00000000 .
+b00000000 -
+b00000000 ,
+b00000000 +
+b00000000 *
+0)
+0(
+0'
+0&
+0%
+b00000000000000000000000000000000 $
+0#
+0"
+0!
+$end
+#10
+1!
+b00000000000000000000000000000001 $
+1)
+#15
+0!
+#20
+1!
+0)
+b00000000000000000000000000000010 $
+1&
+#25
+0!
+#30
+1!
+0&
+b00000000000000000000000000000011 $
+1)
+b00000001 1
+#35
+0!
+#40
+1!
+0)
+b00000000000000000000000000000100 $
+1&
+#45
+0!
+#50
+1!
+0&
+b00000000000000000000000000000101 $
+1)
+b00000010 1
+1(
+#55
+0!
+#60
+1!
+0)
+b00000000000000000000000000000110 $
+1&

test_regress/t/t_trace_split_struct_fst.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of either the GNU Lesser General Public License Version 3
+# or the Perl Artistic License Version 2.0.
+# SPDX-FileCopyrightText: 2026 Wilson Snyder
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+import trace_split_struct_common
+
+test.scenarios('vlt_all')
+
+trace_split_struct_common.run(test)

test_regress/t/t_trace_split_struct_saif.out

@@ -0,0 +1,135 @@
+// Generated by verilated_saif
+(SAIFILE
+(SAIFVERSION "2.0")
+(DIRECTION "backward")
+(PROGRAM_NAME "Verilator")
+(DIVIDER / )
+(TIMESCALE 1ps)
+(DURATION 60)
+ (INSTANCE top
+  (NET
+   (clk (T0 35) (T1 25) (TZ 0) (TX 0) (TB 0) (TC 11))
+   (clk2 (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+  )
+  (INSTANCE $unit
+   (NET
+    (global_bit (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+   )
+  )
+  (INSTANCE t
+   (NET
+    (clk (T0 35) (T1 25) (TZ 0) (TX 0) (TB 0) (TC 11))
+    (clk2 (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[0\] (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (cyc\[1\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 3))
+    (cyc\[2\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (cyc\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[8\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[9\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[10\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[11\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[12\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[13\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[14\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[15\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[16\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[17\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[18\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[19\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[20\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[21\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[22\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[23\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[24\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[25\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[26\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[27\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[28\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[29\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[30\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (cyc\[31\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (foo (T0 30) (T1 30) (TZ 0) (TX 0) (TB 0) (TC 6))
+    (unpacked_array[-7]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-7]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-6]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-5]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-4]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-3]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-2]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[0\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[1\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[-1]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[0\] (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 2))
+    (unpacked_array[0]\[1\] (T0 50) (T1 10) (TZ 0) (TX 0) (TB 0) (TC 1))
+    (unpacked_array[0]\[2\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[3\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[4\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[5\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[6\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+    (unpacked_array[0]\[7\] (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+   )
+   (INSTANCE v_strp
+    (NET
+     (b1 (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (b0 (T0 40) (T1 20) (TZ 0) (TX 0) (TB 0) (TC 5))
+    )
+   )
+   (INSTANCE v_strp2
+    (NET
+     (b1 (T0 60) (T1 0) (TZ 0) (TX 0) (TB 0) (TC 0))
+     (b0 (T0 50) (T1 10) (TZ 0) (TX 0) (TB 0) (TC 1))
+    )
+   )
+  )
+ )
+)

test_regress/t/t_trace_split_struct_saif.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of either the GNU Lesser General Public License Version 3
+# or the Perl Artistic License Version 2.0.
+# SPDX-FileCopyrightText: 2026 Wilson Snyder
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+import trace_split_struct_common
+
+test.scenarios('vlt_all')
+
+trace_split_struct_common.run(test)

test_regress/t/t_trace_split_struct_vcd.out

@@ -0,0 +1,94 @@
+$version Generated by VerilatedVcd $end
+$timescale 1ps $end
+ $scope module top $end
+  $var wire 1 - clk $end
+  $var wire 1 . clk2 $end
+  $scope module $unit $end
+   $var wire 1 2 global_bit $end
+  $upscope $end
+  $scope module t $end
+   $var wire 1 - clk $end
+   $var wire 1 . clk2 $end
+   $var wire 32 / cyc [31:0] $end
+   $scope module v_strp $end
+    $var wire 1 0 b1 $end
+    $var wire 1 " b0 $end
+   $upscope $end
+   $scope module v_strp2 $end
+    $var wire 1 1 b1 $end
+    $var wire 1 # b0 $end
+   $upscope $end
+   $var wire 1 $ foo $end
+   $var wire 8 % unpacked_array[-7] [7:0] $end
+   $var wire 8 & unpacked_array[-6] [7:0] $end
+   $var wire 8 ' unpacked_array[-5] [7:0] $end
+   $var wire 8 ( unpacked_array[-4] [7:0] $end
+   $var wire 8 ) unpacked_array[-3] [7:0] $end
+   $var wire 8 * unpacked_array[-2] [7:0] $end
+   $var wire 8 + unpacked_array[-1] [7:0] $end
+   $var wire 8 , unpacked_array[0] [7:0] $end
+  $upscope $end
+ $upscope $end
+$enddefinitions $end
+
+
+#0
+0"
+0#
+0$
+b00000000 %
+b00000000 &
+b00000000 '
+b00000000 (
+b00000000 )
+b00000000 *
+b00000000 +
+b00000000 ,
+0-
+0.
+b00000000000000000000000000000000 /
+00
+01
+02
+#10
+1$
+1-
+b00000000000000000000000000000001 /
+#15
+0-
+#20
+1"
+0$
+1-
+b00000000000000000000000000000010 /
+#25
+0-
+#30
+0"
+1$
+b00000001 ,
+1-
+b00000000000000000000000000000011 /
+#35
+0-
+#40
+1"
+0$
+1-
+b00000000000000000000000000000100 /
+#45
+0-
+#50
+0"
+1#
+1$
+b00000010 ,
+1-
+b00000000000000000000000000000101 /
+#55
+0-
+#60
+1"
+0$
+1-
+b00000000000000000000000000000110 /

test_regress/t/t_trace_split_struct_vcd.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of either the GNU Lesser General Public License Version 3
+# or the Perl Artistic License Version 2.0.
+# SPDX-FileCopyrightText: 2026 Wilson Snyder
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+import trace_split_struct_common
+
+test.scenarios('vlt_all')
+
+trace_split_struct_common.run(test)

test_regress/t/t_trace_struct_alias.v

@@ -0,0 +1,47 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain.
+// SPDX-FileCopyrightText: 2026 Wilson Snyder
+// SPDX-License-Identifier: CC0-1.0
+
+module t (/*AUTOARG*/
+   // Inputs
+   clk
+   );
+   input clk;
+   int cyc;
+
+   typedef struct packed {
+      logic [7:0] a;
+      logic [7:0] b;
+   } strp_t;
+
+   strp_t s1;
+   strp_t s2;
+
+   strp_t s3;
+   logic [7:0] alias_of_s3a;
+   assign alias_of_s3a = s3.a;
+
+   strp_t s4;
+   strp_t s5;
+   assign s5 = s4;
+
+   logic [7:0] source_val;
+   strp_t s6;
+   assign s6.a = source_val;
+
+   always @(posedge clk) begin
+      cyc <= cyc + 1;
+      s1 <= {8'(cyc), 8'(cyc + 1)};
+      s2 <= {8'(cyc + 2), 8'(cyc + 3)};
+      s3 <= {8'(cyc + 4), 8'(cyc + 5)};
+      s4 <= {8'(cyc + 6), 8'(cyc + 7)};
+      source_val <= 8'(cyc + 8);
+      s6.b <= 8'(cyc + 9);
+      if (cyc == 9) begin
+         $write("*-* All Finished *-*\n");
+         $finish;
+      end
+   end
+endmodule

test_regress/t/t_trace_struct_alias_fst.out

@@ -0,0 +1,212 @@
+$date
+Tue Mar 31 17:14:59 2026
+
+$end
+$version
+Generated by VerilatedFst
+$end
+$timescale
+1ps
+$end
+ $scope module top $end
+  $var wire 1 ! clk $end
+  $scope module t $end
+   $var wire 1 ! clk $end
+   $var int 32 " cyc [31:0] $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s1 $end
+    $var logic 8 # a [7:0] $end
+    $var logic 8 $ b [7:0] $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s2 $end
+    $var logic 8 % a [7:0] $end
+    $var logic 8 & b [7:0] $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s3 $end
+    $var logic 8 ' a [7:0] $end
+    $var logic 8 ( b [7:0] $end
+   $upscope $end
+   $var logic 8 ' alias_of_s3a [7:0] $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s4 $end
+    $var logic 8 ) a [7:0] $end
+    $var logic 8 * b [7:0] $end
+   $upscope $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s5 $end
+    $var logic 8 ) a [7:0] $end
+    $var logic 8 * b [7:0] $end
+   $upscope $end
+   $var logic 8 + source_val [7:0] $end
+   $attrbegin pack packed members 2 $end
+   $scope struct s6 $end
+    $var logic 8 + a [7:0] $end
+    $var logic 8 , b [7:0] $end
+   $upscope $end
+  $upscope $end
+ $upscope $end
+$enddefinitions $end
+#0
+$dumpvars
+b00000000 ,
+b00000000 +
+b00000000 *
+b00000000 )
+b00000000 (
+b00000000 '
+b00000000 &
+b00000000 %
+b00000000 $
+b00000000 #
+b00000000000000000000000000000000 "
+0!
+$end
+#10
+1!
+b00000000000000000000000000000001 "
+b00000001 $
+b00000010 %
+b00000011 &
+b00000100 '
+b00000101 (
+b00000110 )
+b00000111 *
+b00001000 +
+b00001001 ,
+#15
+0!
+#20
+1!
+b00001010 ,
+b00001001 +
+b00001000 *
+b00000111 )
+b00000110 (
+b00000101 '
+b00000100 &
+b00000011 %
+b00000010 $
+b00000000000000000000000000000010 "
+b00000001 #
+#25
+0!
+#30
+1!
+b00000010 #
+b00000000000000000000000000000011 "
+b00000011 $
+b00000100 %
+b00000101 &
+b00000110 '
+b00000111 (
+b00001000 )
+b00001001 *
+b00001010 +
+b00001011 ,
+#35
+0!
+#40
+1!
+b00001100 ,
+b00001011 +
+b00001010 *
+b00001001 )
+b00001000 (
+b00000111 '
+b00000110 &
+b00000101 %
+b00000100 $
+b00000000000000000000000000000100 "
+b00000011 #
+#45
+0!
+#50
+1!
+b00000100 #
+b00000000000000000000000000000101 "
+b00000101 $
+b00000110 %
+b00000111 &
+b00001000 '
+b00001001 (
+b00001010 )
+b00001011 *
+b00001100 +
+b00001101 ,
+#55
+0!
+#60
+1!
+b00001110 ,
+b00001101 +
+b00001100 *
+b00001011 )
+b00001010 (
+b00001001 '
+b00001000 &
+b00000111 %
+b00000110 $
+b00000000000000000000000000000110 "
+b00000101 #
+#65
+0!
+#70
+1!
+b00000110 #
+b00000000000000000000000000000111 "
+b00000111 $
+b00001000 %
+b00001001 &
+b00001010 '
+b00001011 (
+b00001100 )
+b00001101 *
+b00001110 +
+b00001111 ,
+#75
+0!
+#80
+1!
+b00010000 ,
+b00001111 +
+b00001110 *
+b00001101 )
+b00001100 (
+b00001011 '
+b00001010 &
+b00001001 %
+b00001000 $
+b00000000000000000000000000001000 "
+b00000111 #
+#85
+0!
+#90
+1!
+b00001000 #
+b00000000000000000000000000001001 "
+b00001001 $
+b00001010 %
+b00001011 &
+b00001100 '
+b00001101 (
+b00001110 )
+b00001111 *
+b00010000 +
+b00010001 ,
+#95
+0!
+#100
+1!
+b00010010 ,
+b00010001 +
+b00010000 *
+b00001111 )
+b00001110 (
+b00001101 '
+b00001100 &
+b00001011 %
+b00001010 $
+b00000000000000000000000000001010 "
+b00001001 #