Emit model implementation as loose methods. (#3006)

This patch introduces the concept of 'loose' methods, which semantically
are methods, but are declared as global functions, and are passed an
explicit 'self' pointer. This enables these methods to be declared
outside the class, only when they are needed, therefore removing the
header dependency. The bulk of the emitted model implementation now uses
loose methods.

Changes

@@ -11,6 +11,11 @@ contributors that suggested a given feature are shown in []. Thanks!
 Verilator 4.205 devel
 ==========================
 
+**Major:**
+
+* Generated code is now emitted as global functions rather than methods. '$c'
+  contents might need to be updated, see the docs (#3006). [Geza Lore]
+
 **Minor:**
 
 

docs/guide/extensions.rst

@@ -33,7 +33,12 @@ or "`ifdef`"'s may break other tools.
    that returns up to a 32-bit number (without a trailing ;). This can be
    used to call C++ functions from your Verilog code.
 
-   String arguments will be put directly into the output C++ code.
+   String arguments will be put directly into the output C++ code, except
+   the word 'this' (i.e.: the object pointer) might be replaced with a
+   different pointer as Verilator might implement logic with non-member
+   functions. For this reason, any references to class members must be made
+   via an explicit 'this->' pointer dereference.
+
    Expression arguments will have the code to evaluate the expression
    inserted.  Thus to call a C++ function, :code:`$c("func(",a,")")` will
    result in :code:`func(a)` in the output C++ code.  For input arguments,

include/verilated_threads.cpp

@@ -74,7 +74,7 @@ void VlWorkerThread::workerLoop() {
         if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire))) break;
 
         if (VL_LIKELY(work.m_fnp)) {
-            work.m_fnp(work.m_evenCycle, work.m_sym);
+            work.m_fnp(work.m_selfp, work.m_evenCycle);
             work.m_fnp = nullptr;
         }
     }

include/verilated_threads.h

@@ -48,12 +48,12 @@
 #endif
 // clang-format on
 
-// VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
+// VlMTaskVertex and VlThreadpool will work with multiple model class types.
 // Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
 // as a void* here.
-using VlThrSymTab = void*;
+using VlSelfP = void*;
 
-using VlExecFnp = void (*)(bool, VlThrSymTab);
+using VlExecFnp = void (*)(VlSelfP, bool);
 
 // Track dependencies for a single MTask.
 class VlMTaskVertex final {
@@ -177,15 +177,15 @@ private:
     // TYPES
     struct ExecRec {
         VlExecFnp m_fnp;  // Function to execute
-        VlThrSymTab m_sym;  // Symbol table to execute
+        VlSelfP m_selfp;  // Symbol table to execute
         bool m_evenCycle;  // Even/odd for flag alternation
         ExecRec()
             : m_fnp{nullptr}
-            , m_sym{nullptr}
+            , m_selfp{nullptr}
             , m_evenCycle{false} {}
-        ExecRec(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
+        ExecRec(VlExecFnp fnp, VlSelfP selfp, bool evenCycle)
             : m_fnp{fnp}
-            , m_sym{sym}
+            , m_selfp{selfp}
             , m_evenCycle{evenCycle} {}
     };
 
@@ -237,13 +237,13 @@ public:
         m_ready.erase(m_ready.begin());
         m_ready_size.fetch_sub(1, std::memory_order_relaxed);
     }
-    inline void wakeUp() { addTask(nullptr, false, nullptr); }
+    inline void wakeUp() { addTask(nullptr, nullptr, false); }
-    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
+    inline void addTask(VlExecFnp fnp, VlSelfP selfp, bool evenCycle)
         VL_MT_SAFE_EXCLUDES(m_mutex) {
         bool notify;
         {
             const VerilatedLockGuard lk(m_mutex);
-            m_ready.emplace_back(fnp, evenCycle, sym);
+            m_ready.emplace_back(fnp, selfp, evenCycle);
             m_ready_size.fetch_add(1, std::memory_order_relaxed);
             notify = m_waiting;
         }

src/V3Active.cpp

@@ -474,11 +474,10 @@ private:
         if (!m_scopeFinalp) {
             m_scopeFinalp = new AstCFunc(
                 nodep->fileline(), "_final_" + m_namer.scopep()->nameDotless(), m_namer.scopep());
-            m_scopeFinalp->argTypes(EmitCBaseVisitor::symClassVar());
-            m_scopeFinalp->addInitsp(
-                new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
             m_scopeFinalp->dontCombine(true);
             m_scopeFinalp->formCallTree(true);
+            m_scopeFinalp->isStatic(false);
+            m_scopeFinalp->isLoose(true);
             m_scopeFinalp->slow(true);
             m_namer.scopep()->addActivep(m_scopeFinalp);
         }

src/V3Ast.h

@@ -1687,6 +1687,7 @@ public:
     AstNodeDType* findSigned32DType() { return findBasicDType(AstBasicDTypeKwd::INTEGER); }
     AstNodeDType* findUInt32DType() { return findBasicDType(AstBasicDTypeKwd::UINT32); }
     AstNodeDType* findUInt64DType() { return findBasicDType(AstBasicDTypeKwd::UINT64); }
+    AstNodeDType* findCHandleDType() { return findBasicDType(AstBasicDTypeKwd::CHANDLE); }
     AstNodeDType* findVoidDType() const;
     AstNodeDType* findQueueIndexDType() const;
     AstNodeDType* findBitDType(int width, int widthMin, VSigning numeric) const;
@@ -2272,9 +2273,9 @@ private:
     AstVarScope* m_varScopep = nullptr;  // Varscope for hierarchy
     AstNodeModule* m_classOrPackagep = nullptr;  // Package hierarchy
     string m_name;  // Name of variable
-    string m_hiernameToProt;  // Scope converted into name-> for emitting
+    string m_selfPointer;  // Output code object pointer (e.g.: 'this')
-    string m_hiernameToUnprot;  // Scope converted into name-> for emitting
+    string m_classPrefix;  // Output class prefix (i.e.: the part before ::)
-    bool m_hierThis = false;  // Hiername points to "this" function
+    bool m_hierThis = false;  // m_selfPointer points to "this" function
 
 protected:
     AstNodeVarRef(AstType t, FileLine* fl, const string& name, const VAccess& access)
@@ -2306,13 +2307,14 @@ public:
     void varp(AstVar* varp);
     AstVarScope* varScopep() const { return m_varScopep; }
     void varScopep(AstVarScope* varscp) { m_varScopep = varscp; }
-    string hiernameToProt() const { return m_hiernameToProt; }
-    void hiernameToProt(const string& hn) { m_hiernameToProt = hn; }
-    string hiernameToUnprot() const { return m_hiernameToUnprot; }
-    void hiernameToUnprot(const string& hn) { m_hiernameToUnprot = hn; }
-    string hiernameProtect() const;
     bool hierThis() const { return m_hierThis; }
     void hierThis(bool flag) { m_hierThis = flag; }
+    string selfPointer() const { return m_selfPointer; }
+    void selfPointer(const string& value) { m_selfPointer = value; }
+    string selfPointerProtect(bool useSelfForThis) const;
+    string classPrefix() const { return m_classPrefix; }
+    void classPrefix(const string& value) { m_classPrefix = value; }
+    string classPrefixProtect() const;
     AstNodeModule* classOrPackagep() const { return m_classOrPackagep; }
     void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
     // Know no children, and hot function, so skip iterator for speed
@@ -2615,8 +2617,8 @@ class AstNodeCCall VL_NOT_FINAL : public AstNodeStmt {
     // A call of a C++ function, perhaps a AstCFunc or perhaps globally named
     // Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal.
     AstCFunc* m_funcp;
-    string m_hiernameToProt;
+    string m_selfPointer;  // Output code object pointer (e.g.: 'this')
-    string m_hiernameToUnprot;
+    string m_classPrefix;  // Output class prefix (i.e.: the part before ::)
     string m_argTypes;
 
 protected:
@@ -2642,11 +2644,12 @@ public:
     virtual bool isPure() const override;
     virtual bool isOutputter() const override { return !isPure(); }
     AstCFunc* funcp() const { return m_funcp; }
-    string hiernameToProt() const { return m_hiernameToProt; }
+    string selfPointer() const { return m_selfPointer; }
-    void hiernameToProt(const string& hn) { m_hiernameToProt = hn; }
+    void selfPointer(const string& value) { m_selfPointer = value; }
-    string hiernameToUnprot() const { return m_hiernameToUnprot; }
+    string selfPointerProtect(bool useSelfForThis) const;
-    void hiernameToUnprot(const string& hn) { m_hiernameToUnprot = hn; }
+    string classPrefix() const { return m_classPrefix; }
-    string hiernameProtect() const;
+    void classPrefix(const string& value) { m_classPrefix = value; }
+    string classPrefixProtect() const;
     void argTypes(const string& str) { m_argTypes = str; }
     string argTypes() const { return m_argTypes; }
     // op1p reserved for AstCMethodCall

src/V3AstNodes.cpp

@@ -55,8 +55,23 @@ void AstNodeVarRef::cloneRelink() {
     if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep();
 }
 
-string AstNodeVarRef::hiernameProtect() const {
+string AstNodeVarRef::selfPointerProtect(bool useSelfForThis) const {
-    return hiernameToUnprot() + VIdProtect::protectWordsIf(hiernameToProt(), protect());
+    const string& sp
+        = useSelfForThis ? VString::replaceWord(selfPointer(), "this", "vlSelf") : selfPointer();
+    return VIdProtect::protectWordsIf(sp, protect());
+}
+
+string AstNodeVarRef::classPrefixProtect() const {
+    return v3Global.opt.modPrefix() + "_" + VIdProtect::protectWordsIf(classPrefix(), protect());
+}
+
+void AstAddrOfCFunc::cloneRelink() {
+    if (m_funcp && m_funcp->clonep()) m_funcp = m_funcp->clonep();
+}
+
+const char* AstAddrOfCFunc::broken() const {
+    BROKEN_RTN(m_funcp && !m_funcp->brokeExists());
+    return nullptr;
 }
 
 int AstNodeSel::bitConst() const {
@@ -108,8 +123,13 @@ const char* AstNodeCCall::broken() const {
     return nullptr;
 }
 bool AstNodeCCall::isPure() const { return funcp()->pure(); }
-string AstNodeCCall::hiernameProtect() const {
+string AstNodeCCall::selfPointerProtect(bool useSelfForThis) const {
-    return hiernameToUnprot() + VIdProtect::protectWordsIf(hiernameToProt(), protect());
+    const string& sp
+        = useSelfForThis ? VString::replaceWord(selfPointer(), "this", "vlSelf") : selfPointer();
+    return VIdProtect::protectWordsIf(sp, protect());
+}
+string AstNodeCCall::classPrefixProtect() const {
+    return v3Global.opt.modPrefix() + "_" + VIdProtect::protectWordsIf(classPrefix(), protect());
 }
 
 void AstNodeCond::numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
@@ -221,6 +241,21 @@ AstExecGraph::AstExecGraph(FileLine* fileline)
 }
 AstExecGraph::~AstExecGraph() { VL_DO_DANGLING(delete m_depGraphp, m_depGraphp); }
 
+std::vector<const ExecMTask*> AstExecGraph::rootMTasks() {
+    // Build the list of initial mtasks to start
+    std::vector<const ExecMTask*> execMTasks;
+
+    for (const V3GraphVertex* vxp = depGraphp()->verticesBeginp(); vxp;
+         vxp = vxp->verticesNextp()) {
+        const ExecMTask* etp = dynamic_cast<const ExecMTask*>(vxp);
+        if (etp->threadRoot()) execMTasks.push_back(etp);
+    }
+    UASSERT_OBJ(execMTasks.size() <= static_cast<unsigned>(v3Global.opt.threads()), this,
+                "More root mtasks than available threads");
+
+    return execMTasks;
+}
+
 AstNode* AstInsideRange::newAndFromInside(AstNode* exprp, AstNode* lhsp, AstNode* rhsp) {
     AstNode* ap = new AstGte(fileline(), exprp->cloneTree(true), lhsp);
     AstNode* bp = new AstLte(fileline(), exprp->cloneTree(true), rhsp);

src/V3AstNodes.h

@@ -2388,8 +2388,7 @@ public:
         if (varScopep()) {
             return (varScopep() == samep->varScopep() && access() == samep->access());
         } else {
-            return (hiernameToProt() == samep->hiernameToProt()
+            return (selfPointer() == samep->selfPointer()
-                    && hiernameToUnprot() == samep->hiernameToUnprot()
                     && varp()->name() == samep->varp()->name() && access() == samep->access());
         }
     }
@@ -2397,9 +2396,8 @@ public:
         if (varScopep()) {
             return (varScopep() == samep->varScopep());
         } else {
-            return (hiernameToProt() == samep->hiernameToProt()
+            return (selfPointer() == samep->selfPointer()
-                    && hiernameToUnprot() == samep->hiernameToUnprot()
+                    && (!selfPointer().empty() || !samep->selfPointer().empty())
-                    && (!hiernameToProt().empty() || !samep->hiernameToProt().empty())
                     && varp()->name() == samep->varp()->name());
         }
     }
@@ -2439,12 +2437,33 @@ public:
     virtual int instrCount() const override { return widthInstrs(); }
     virtual bool same(const AstNode* samep) const override {
         const AstVarXRef* asamep = static_cast<const AstVarXRef*>(samep);
-        return (hiernameToProt() == asamep->hiernameToProt()
+        return (selfPointer() == asamep->selfPointer() && varp() == asamep->varp()
-                && hiernameToUnprot() == asamep->hiernameToUnprot() && varp() == asamep->varp()
                 && name() == asamep->name() && dotted() == asamep->dotted());
     }
 };
 
+class AstAddrOfCFunc final : public AstNodeMath {
+    // Get address of CFunc
+private:
+    AstCFunc* m_funcp;  // Pointer to function itself
+
+public:
+    AstAddrOfCFunc(FileLine* fl, AstCFunc* funcp)
+        : ASTGEN_SUPER_AddrOfCFunc(fl)
+        , m_funcp{funcp} {
+        dtypep(findCHandleDType());
+    }
+
+public:
+    ASTNODE_NODE_FUNCS(AddrOfCFunc)
+    virtual void cloneRelink() override;
+    virtual const char* broken() const override;
+    virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); }
+    virtual string emitC() override { V3ERROR_NA_RETURN(""); }
+    virtual bool cleanOut() const override { return true; }
+    AstCFunc* funcp() const { return m_funcp; }
+};
+
 class AstPin final : public AstNode {
     // A pin on a cell
 private:
@@ -8717,7 +8736,6 @@ private:
     VBoolOrUnknown m_isConst;  // Function is declared const (*this not changed)
     VBoolOrUnknown m_isStatic;  // Function is declared static (no this)
     bool m_dontCombine : 1;  // V3Combine shouldn't compare this func tree, it's special
-    bool m_skipDecl : 1;  // Don't declare it
     bool m_declPrivate : 1;  // Declare it private
     bool m_formCallTree : 1;  // Make a global function to call entire tree of functions
     bool m_slow : 1;  // Slow routine, called once or just at init time
@@ -8725,9 +8743,10 @@ private:
     bool m_isConstructor : 1;  // Is C class constructor
     bool m_isDestructor : 1;  // Is C class destructor
     bool m_isMethod : 1;  // Is inside a class definition
+    bool m_isLoose : 1;  // Semantically this is a method, but is implemented as a function
+                         // with an explicitly passed 'self' pointer as the first argument
     bool m_isInline : 1;  // Inline function
     bool m_isVirtual : 1;  // Virtual function
-    bool m_symProlog : 1;  // Setup symbol table for later instructions
     bool m_entryPoint : 1;  // User may call into this top level function
     bool m_pure : 1;  // Pure function
     bool m_dpiExport : 1;  // From dpi export
@@ -8744,7 +8763,6 @@ public:
         m_name = name;
         m_rtnType = rtnType;
         m_dontCombine = false;
-        m_skipDecl = false;
         m_declPrivate = false;
         m_formCallTree = false;
         m_slow = false;
@@ -8752,9 +8770,9 @@ public:
         m_isConstructor = false;
         m_isDestructor = false;
         m_isMethod = true;
+        m_isLoose = false;
         m_isInline = false;
         m_isVirtual = false;
-        m_symProlog = false;
         m_entryPoint = false;
         m_pure = false;
         m_dpiExport = false;
@@ -8774,6 +8792,7 @@ public:
         const AstCFunc* asamep = static_cast<const AstCFunc*>(samep);
         return ((funcType() == asamep->funcType()) && (rtnTypeVoid() == asamep->rtnTypeVoid())
                 && (argTypes() == asamep->argTypes()) && (ctorInits() == asamep->ctorInits())
+                && isLoose() == asamep->isLoose()
                 && (!(dpiImport() || dpiExport()) || name() == asamep->name()));
     }
     //
@@ -8792,9 +8811,7 @@ public:
     string rtnTypeVoid() const { return ((m_rtnType == "") ? "void" : m_rtnType); }
     bool dontCombine() const { return m_dontCombine || funcType() != AstCFuncType::FT_NORMAL; }
     void dontCombine(bool flag) { m_dontCombine = flag; }
-    bool dontInline() const { return dontCombine() || slow() || skipDecl() || funcPublic(); }
+    bool dontInline() const { return dontCombine() || slow() || funcPublic(); }
-    bool skipDecl() const { return m_skipDecl; }
-    void skipDecl(bool flag) { m_skipDecl = flag; }
     bool declPrivate() const { return m_declPrivate; }
     void declPrivate(bool flag) { m_declPrivate = flag; }
     bool formCallTree() const { return m_formCallTree; }
@@ -8817,12 +8834,13 @@ public:
     void isDestructor(bool flag) { m_isDestructor = flag; }
     bool isMethod() const { return m_isMethod; }
     void isMethod(bool flag) { m_isMethod = flag; }
+    bool isLoose() const { return m_isLoose; }
+    void isLoose(bool flag) { m_isLoose = flag; }
+    bool isProperMethod() const { return isMethod() && !isLoose(); }
     bool isInline() const { return m_isInline; }
     void isInline(bool flag) { m_isInline = flag; }
     bool isVirtual() const { return m_isVirtual; }
     void isVirtual(bool flag) { m_isVirtual = flag; }
-    bool symProlog() const { return m_symProlog; }
-    void symProlog(bool flag) { m_symProlog = flag; }
     bool entryPoint() const { return m_entryPoint; }
     void entryPoint(bool flag) { m_entryPoint = flag; }
     bool pure() const { return m_pure; }
@@ -9039,6 +9057,7 @@ public:
     const V3Graph* depGraphp() const { return m_depGraphp; }
     V3Graph* mutableDepGraphp() { return m_depGraphp; }
     void addMTaskBody(AstMTaskBody* bodyp) { addOp1p(bodyp); }
+    std::vector<const ExecMTask*> rootMTasks();
 };
 
 class AstSplitPlaceholder final : public AstNode {

src/V3CCtors.cpp

@@ -61,23 +61,21 @@ private:
         const int funcNum = m_newFunctions.size();
         const string funcName = m_basename + "_" + cvtToStr(funcNum);
         AstCFunc* const funcp = new AstCFunc(m_modp->fileline(), funcName, nullptr, "void");
-        funcp->isStatic(!m_type.isClass());  // Class constructors are non static
+        funcp->isStatic(false);
+        funcp->isLoose(!m_type.isClass());
         funcp->declPrivate(true);
         funcp->slow(!m_type.isClass());  // Only classes construct on fast path
         string preventUnusedStmt;
         if (m_type.isClass()) {
             funcp->argTypes(EmitCBaseVisitor::symClassVar());
-            preventUnusedStmt = "if (false && vlSymsp) {}";
+            preventUnusedStmt = "if (false && vlSymsp) {}  // Prevent unused\n";
         } else if (m_type.isCoverage()) {
-            funcp->argTypes(EmitCBaseVisitor::prefixNameProtect(m_modp) + "* self, "
+            funcp->argTypes("bool first");
-                            + EmitCBaseVisitor::symClassVar() + ", bool first");
+            preventUnusedStmt = "if (false && first) {}  // Prevent unused\n";
-            preventUnusedStmt = "if (false && self && vlSymsp && first) {}";
+        }
-        } else {  // Module
+        if (!preventUnusedStmt.empty()) {
-            funcp->argTypes(EmitCBaseVisitor::prefixNameProtect(m_modp) + "* self");
+            funcp->addStmtsp(new AstCStmt(m_modp->fileline(), preventUnusedStmt));
-            preventUnusedStmt = "if (false && self) {}";
         }
-        preventUnusedStmt += "  // Prevent unused\n";
-        funcp->addStmtsp(new AstCStmt(m_modp->fileline(), preventUnusedStmt));
         m_modp->addStmtp(funcp);
         m_numStmts = 0;
         return funcp;
@@ -113,10 +111,9 @@ public:
                 AstCCall* const callp = new AstCCall(m_modp->fileline(), funcp);
                 if (m_type.isClass()) {
                     callp->argTypes("vlSymsp");
-                } else if (m_type.isCoverage()) {
+                } else {
-                    callp->argTypes("self, vlSymsp, first");
+                    if (m_type.isCoverage()) callp->argTypes("first");
-                } else {  // Module
+                    callp->selfPointer("this");
-                    callp->argTypes("self");
                 }
                 rootFuncp->addStmtsp(callp);
             }
@@ -134,6 +131,7 @@ void V3CCtors::evalAsserts() {
     AstCFunc* funcp = new AstCFunc(modp->fileline(), "_eval_debug_assertions", nullptr, "void");
     funcp->declPrivate(true);
     funcp->isStatic(false);
+    funcp->isLoose(true);
     funcp->slow(false);
     funcp->ifdef("VL_DEBUG");
     modp->addStmtp(funcp);
@@ -145,7 +143,11 @@ void V3CCtors::evalAsserts() {
                     int lastWordWidth = varp->width() % storedWidth;
                     if (lastWordWidth != 0) {
                         // if (signal & CONST(upper_non_clean_mask)) { fail; }
-                        AstNode* newp = new AstVarRef(varp->fileline(), varp, VAccess::READ);
+                        AstVarRef* const vrefp
+                            = new AstVarRef(varp->fileline(), varp, VAccess::READ);
+                        vrefp->selfPointer(v3Global.opt.relativeCFuncs() ? "this"
+                                                                         : "vlSymsp->TOPp");
+                        AstNode* newp = vrefp;
                         if (varp->isWide()) {
                             newp = new AstWordSel(
                                 varp->fileline(), newp,

src/V3Changed.cpp

@@ -61,14 +61,13 @@ public:
             m_chgFuncp
                 = new AstCFunc(m_scopetopp->fileline(), "_change_request_" + cvtToStr(++m_funcNum),
                                m_scopetopp, "QData");
-            m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
+            m_chgFuncp->isStatic(false);
-            m_chgFuncp->symProlog(true);
+            m_chgFuncp->isLoose(true);
             m_chgFuncp->declPrivate(true);
             m_scopetopp->addActivep(m_chgFuncp);
 
             // Add a top call to it
             AstCCall* callp = new AstCCall(m_scopetopp->fileline(), m_chgFuncp);
-            callp->argTypes("vlSymsp");
 
             if (!m_tlChgFuncp->stmtsp()) {
                 m_tlChgFuncp->addStmtsp(new AstCReturn(m_scopetopp->fileline(), callp));
@@ -251,8 +250,8 @@ private:
         // Create a wrapper change detection function that calls each change detection function
         m_statep->m_tlChgFuncp
             = new AstCFunc(nodep->fileline(), "_change_request", scopep, "QData");
-        m_statep->m_tlChgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
+        m_statep->m_tlChgFuncp->isStatic(false);
-        m_statep->m_tlChgFuncp->symProlog(true);
+        m_statep->m_tlChgFuncp->isLoose(true);
         m_statep->m_tlChgFuncp->declPrivate(true);
         m_statep->m_scopetopp->addActivep(m_statep->m_tlChgFuncp);
         // Each change detection function needs at least one AstChangeDet

src/V3Clock.cpp

@@ -164,6 +164,18 @@ private:
         m_lastSenp = nullptr;
         m_lastIfp = nullptr;
     }
+    AstCFunc* makeTopFunction(const string& name, bool slow = false) {
+        AstCFunc* const funcp = new AstCFunc{m_topScopep->fileline(), name, m_topScopep->scopep()};
+        funcp->dontCombine(true);
+        funcp->isStatic(false);
+        funcp->isLoose(true);
+        funcp->entryPoint(true);
+        funcp->slow(slow);
+        funcp->isConst(false);
+        funcp->declPrivate(true);
+        m_topScopep->scopep()->addActivep(funcp);
+        return funcp;
+    }
     void splitCheck(AstCFunc* ofuncp) {
         if (!v3Global.opt.outputSplitCFuncs() || !ofuncp->stmtsp()) return;
         if (EmitCBaseCounterVisitor(ofuncp->stmtsp()).count() < v3Global.opt.outputSplitCFuncs())
@@ -184,15 +196,13 @@ private:
                 // Make a new function
                 funcp = new AstCFunc{ofuncp->fileline(), ofuncp->name() + cvtToStr(++funcnum),
                                      m_topScopep->scopep()};
-                funcp->argTypes(EmitCBaseVisitor::symClassVar());
                 funcp->dontCombine(true);
-                funcp->symProlog(true);
+                funcp->isStatic(false);
-                funcp->isStatic(true);
+                funcp->isLoose(true);
                 funcp->slow(ofuncp->slow());
                 m_topScopep->scopep()->addActivep(funcp);
                 //
                 AstCCall* callp = new AstCCall{funcp->fileline(), funcp};
-                callp->argTypes("vlSymsp");
                 ofuncp->addStmtsp(callp);
                 func_stmts = 0;
             }
@@ -212,55 +222,10 @@ private:
         // VV*****  We reset all user1p()
         AstNode::user1ClearTree();
         // Make top functions
-        {
+        m_evalFuncp = makeTopFunction("_eval");
-            AstCFunc* funcp = new AstCFunc{nodep->fileline(), "_eval", m_topScopep->scopep()};
+        m_initFuncp = makeTopFunction("_eval_initial", /* slow: */ true);
-            funcp->argTypes(EmitCBaseVisitor::symClassVar());
+        m_settleFuncp = makeTopFunction("_eval_settle", /* slow: */ true);
-            funcp->dontCombine(true);
+        m_finalFuncp = makeTopFunction("_final", /* slow: */ true);
-            funcp->symProlog(true);
-            funcp->isStatic(true);
-            funcp->entryPoint(true);
-            m_topScopep->scopep()->addActivep(funcp);
-            m_evalFuncp = funcp;
-        }
-        {
-            AstCFunc* funcp
-                = new AstCFunc{nodep->fileline(), "_eval_initial", m_topScopep->scopep()};
-            funcp->argTypes(EmitCBaseVisitor::symClassVar());
-            funcp->dontCombine(true);
-            funcp->slow(true);
-            funcp->symProlog(true);
-            funcp->isStatic(true);
-            funcp->entryPoint(true);
-            m_topScopep->scopep()->addActivep(funcp);
-            m_initFuncp = funcp;
-        }
-        {
-            AstCFunc* funcp = new AstCFunc{nodep->fileline(), "final", m_topScopep->scopep()};
-            funcp->skipDecl(true);
-            funcp->dontCombine(true);
-            funcp->slow(true);
-            funcp->isStatic(false);
-            funcp->entryPoint(true);
-            funcp->protect(false);
-            funcp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symClassVar()
-                                                                 + " = this->__VlSymsp;\n"));
-            funcp->addInitsp(
-                new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
-            m_topScopep->scopep()->addActivep(funcp);
-            m_finalFuncp = funcp;
-        }
-        {
-            AstCFunc* funcp
-                = new AstCFunc{nodep->fileline(), "_eval_settle", m_topScopep->scopep()};
-            funcp->argTypes(EmitCBaseVisitor::symClassVar());
-            funcp->dontCombine(true);
-            funcp->slow(true);
-            funcp->isStatic(true);
-            funcp->symProlog(true);
-            funcp->entryPoint(true);
-            m_topScopep->scopep()->addActivep(funcp);
-            m_settleFuncp = funcp;
-        }
         // Process the activates
         iterateChildren(nodep);
         UINFO(4, " TOPSCOPE iter done " << nodep << endl);
@@ -324,7 +289,6 @@ private:
         if (nodep->formCallTree()) {
             UINFO(4, "    formCallTree " << nodep << endl);
             AstCCall* callp = new AstCCall(nodep->fileline(), nodep);
-            callp->argTypes("vlSymsp");
             m_finalFuncp->addStmtsp(callp);
         }
     }

src/V3Combine.cpp

@@ -72,8 +72,8 @@ public:
                 AstNode* const argsp
                     = oldp->argsp() ? oldp->argsp()->unlinkFrBackWithNext() : nullptr;
                 AstCCall* const newp = new AstCCall(oldp->fileline(), newfuncp, argsp);
-                newp->hiernameToProt(oldp->hiernameToProt());
+                newp->selfPointer(oldp->selfPointer());
-                newp->hiernameToUnprot(oldp->hiernameToUnprot());
+                newp->classPrefix(oldp->classPrefix());
                 newp->argTypes(oldp->argTypes());
                 addCall(newp);  // Fix the table, in case the newfuncp itself gets replaced
                 oldp->replaceWith(newp);
@@ -86,14 +86,23 @@ public:
         }
     }
     // METHODS
-    void addCall(AstCCall* nodep) {
+    void addCall(AstCCall* nodep) { m_callMmap.emplace(nodep->funcp(), nodep); }
-        if (nodep->funcp()->dontCombine()) return;
-        m_callMmap.emplace(nodep->funcp(), nodep);
-    }
 
 private:
     // VISITORS
-    virtual void visit(AstCCall* nodep) override { addCall(nodep); }
+    virtual void visit(AstCCall* nodep) override {
+        if (nodep->funcp()->dontCombine()) return;
+        addCall(nodep);
+    }
+    // LCOV_EXCL_START
+    virtual void visit(AstAddrOfCFunc* nodep) override {
+        // We cannot yet handle references via AstAddrOfCFunc, but currently those are
+        // only used in tracing functions, which are not combined. Blow up in case this changes.
+        if (nodep->funcp()->dontCombine()) return;
+        nodep->v3fatalSrc(
+            "Don't know how to combine functions that are referenced via AstAddrOfCFunc");
+    }
+    // LCOV_EXCL_END
     // Speed things up
     virtual void visit(AstNodeAssign*) override {}
     virtual void visit(AstNodeMath*) override {}

src/V3DepthBlock.cpp

@@ -51,14 +51,19 @@ private:
         // Create function
         string name = m_cfuncp->name() + "__deep" + cvtToStr(++m_deepNum);
         AstCFunc* funcp = new AstCFunc(nodep->fileline(), name, nullptr);
-        funcp->argTypes(EmitCBaseVisitor::symClassVar());
-        funcp->symProlog(true);
         funcp->slow(m_cfuncp->slow());
+        funcp->isStatic(m_cfuncp->isStatic());
+        funcp->isLoose(m_cfuncp->isLoose());
         funcp->addStmtsp(nodep);
         m_modp->addStmtp(funcp);
         // Call it at the point where the body was removed from
         AstCCall* callp = new AstCCall(nodep->fileline(), funcp);
-        callp->argTypes("vlSymsp");
+        if (VN_IS(m_modp, Class)) {
+            funcp->argTypes(EmitCBaseVisitor::symClassVar());
+            callp->argTypes("vlSymsp");
+        } else if (funcp->isStatic().falseUnknown()) {
+            callp->selfPointer("this");
+        }
         UINFO(6, "      New " << callp << endl);
         //
         relinkHandle.relink(callp);

src/V3Descope.cpp

@@ -56,7 +56,8 @@ private:
     VL_DEBUG_FUNC;  // Declare debug()
 
     static bool modIsSingleton(AstNodeModule* modp) {
-        // True iff there's exactly one instance of this module in the design.
+        // True iff there's exactly one instance of this module in the design (including top).
+        if (modp->isTop()) return true;
         int instances = 0;
         for (AstNode* stmtp = modp->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
             if (VN_IS(stmtp, Scope)) {
@@ -66,85 +67,68 @@ private:
         return (instances == 1);
     }
 
-    // Construct the best prefix to reference an object in 'scopep'
+    // Construct the best self pointer to reference an object in 'scopep'  from a CFunc in
-    // from a CFunc in 'm_scopep'. Result may be relative
+    // 'm_scopep'. Result may be relative ("this->[...]") or absolute ("vlSyms->[...]").
-    // ("this->[...]") or absolute ("vlTOPp->[...]").
     //
-    // Using relative references allows V3Combine'ing
+    // Using relative references allows V3Combine'ing code across multiple instances of the same
-    // code across multiple instances of the same module.
+    // module.
-    //
+    string descopedSelfPointer(const AstScope* scopep) {
-    // Sets 'hierThisr' true if the object is local to this scope
-    // (and could be made into a function-local later in V3Localize),
-    // false if the object is in another scope.
-    string descopedName(bool& hierThisr, string& hierUnprot, const AstScope* scopep,
-                        const AstVar* varp) {
         UASSERT(scopep, "Var/Func not scoped");
-        hierThisr = (scopep == m_scopep);
 
         // It's possible to disable relative references. This is a concession
         // to older compilers (gcc < 4.5.x) that don't understand __restrict__
         // well and emit extra ld/st to guard against pointer aliasing
-        // when this-> and vlTOPp-> are mixed in the same function.
+        // when this-> and vlSyms-> are mixed in the same function.
-        //
-        // "vlTOPp" is declared "restrict" so better compilers understand
-        // that it won't alias with "this".
         bool relativeRefOk = v3Global.opt.relativeCFuncs();
         //
         // Static functions can't use this
         if (!m_allowThis) relativeRefOk = false;
         //
-        // Use absolute refs in top-scoped routines, keep them static.
-        // The DPI callback registration depends on representing top-level
-        // static routines as plain function pointers. That breaks if those
-        // become true OO routines.
-        //
-        // V3Combine wouldn't likely be able to combine top-level
-        // routines anyway, so there's no harm in keeping these static.
-        UASSERT_OBJ(m_modp, scopep, "Scope not under module");
-        if (m_modp->isTop()) relativeRefOk = false;
-        //
-        // Use absolute refs if this scope is the only instance of the module.
-        // Saves a bit of overhead on passing the 'this' pointer, and there's no
-        // need to be nice to V3Combine when we have only a single instance.
-        // The risk that this prevents combining identical logic from differently-
-        // named but identical modules seems low.
-        if (m_modSingleton) relativeRefOk = false;
-        //
         // Class methods need relative
         if (m_modp && VN_IS(m_modp, Class)) relativeRefOk = true;
 
-        if (varp && varp->isFuncLocal()) {
+        UINFO(8, "      Descope ref under " << m_scopep << endl);
-            hierThisr = true;
+        UINFO(8, "              ref to    " << scopep << endl);
-            return "";  // Relative to function, not in this
+        UINFO(8, "             aboveScope " << scopep->aboveScopep() << endl);
-        } else if (relativeRefOk && scopep == m_scopep) {
+
+        if (relativeRefOk && scopep == m_scopep) {
             m_needThis = true;
-            return "this->";
+            return "this";
         } else if (VN_IS(scopep->modp(), Class)) {
-            hierUnprot = v3Global.opt.modPrefix() + "_";  // Prefix before protected part
+            return "";
-            return scopep->modp()->name() + "::";
+        } else if (!m_modSingleton && relativeRefOk && scopep->aboveScopep() == m_scopep
-        } else if (relativeRefOk && scopep->aboveScopep() && scopep->aboveScopep() == m_scopep) {
+                   && VN_IS(scopep->modp(), Module)) {
-            // Reference to scope of instance directly under this module, can just "cell->"
+            // Reference to scope of instance directly under this module, can just "this->cell",
+            // which can potentially be V3Combined, but note this requires one extra pointer
+            // dereference which is slower, so we only use it if the source scope is not a
+            // singleton.
             string name = scopep->name();
             string::size_type pos;
             if ((pos = name.rfind('.')) != string::npos) name.erase(0, pos + 1);
             m_needThis = true;
-            return name + "->";
+            return "this->" + name;
         } else {
-            // Reference to something elsewhere, or relative references
+            // Reference to something elsewhere, or relative references are disabled. Use global
-            // are disabled. Use global variable
+            // variable
-            UINFO(8, "      Descope " << scopep << endl);
+            if (scopep->isTop()) {  // Top
-            UINFO(8, "           to " << scopep->name() << endl);
+                return "vlSymsp->TOPp";
-            UINFO(8, "        under " << m_scopep->name() << endl);
-            if (!scopep->aboveScopep()) {  // Top
-                // We could also return "vlSymsp->TOPp->" here, but GCC would
-                // suspect aliases.
-                return "vlTOPp->";
             } else {
-                return scopep->nameVlSym() + ".";
+                return "(&" + scopep->nameVlSym() + ")";
             }
         }
     }
 
+    // Construct the class prefix (as in, the part before the :: scope resolution operator) when
+    // referencing an object in 'scopep' from a CFunc in 'm_scopep'.
+    string descopedClassPrefix(const AstScope* scopep) {
+        UASSERT(scopep, "Var/Func not scoped");
+        if (VN_IS(scopep->modp(), Class) && scopep != m_scopep) {
+            return scopep->modp()->name();
+        } else {
+            return "";
+        }
+    }
+
     void makePublicFuncWrappers() {
         // We recorded all public functions in m_modFuncs.
         // If for any given name only one function exists, we can use that function directly.
@@ -164,11 +148,6 @@ private:
                 if (newfuncp->finalsp()) newfuncp->finalsp()->unlinkFrBackWithNext()->deleteTree();
                 newfuncp->name(name);
                 newfuncp->isStatic(false);
-                newfuncp->addInitsp(
-                    new AstCStmt(newfuncp->fileline(),
-                                 EmitCBaseVisitor::symClassVar() + " = this->__VlSymsp;\n"));
-                newfuncp->addInitsp(
-                    new AstCStmt(newfuncp->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
                 topFuncp->addNextHere(newfuncp);
                 // In the body, call each function if it matches the given scope
                 for (FuncMmap::iterator eachIt = it;
@@ -255,13 +234,15 @@ private:
         // Convert the hierch name
         UINFO(9, "  ref-in " << nodep << endl);
         UASSERT_OBJ(m_scopep, nodep, "Node not under scope");
-        bool hierThis;
+        const AstVar* const varp = nodep->varScopep()->varp();
-        string hierUnprot;
+        const AstScope* const scopep = nodep->varScopep()->scopep();
-        nodep->hiernameToProt(descopedName(hierThis /*ref*/, hierUnprot /*ref*/,
+        if (varp->isFuncLocal()) {
-                                           nodep->varScopep()->scopep(),
+            nodep->hierThis(true);
-                                           nodep->varScopep()->varp()));
+        } else {
-        nodep->hiernameToUnprot(hierUnprot);
+            nodep->hierThis(scopep == m_scopep);
-        nodep->hierThis(hierThis);
+            nodep->selfPointer(descopedSelfPointer(scopep));
+            nodep->classPrefix(descopedClassPrefix(scopep));
+        }
         nodep->varScopep(nullptr);
         UINFO(9, "  refout " << nodep << endl);
     }
@@ -270,12 +251,9 @@ private:
         iterateChildren(nodep);
         // Convert the hierch name
         UASSERT_OBJ(m_scopep, nodep, "Node not under scope");
-        UASSERT_OBJ(nodep->funcp()->scopep(), nodep, "CFunc not under scope");
+        const AstScope* const scopep = nodep->funcp()->scopep();
-        bool hierThis;
+        nodep->selfPointer(descopedSelfPointer(scopep));
-        string hierUnprot;
+        nodep->classPrefix(descopedClassPrefix(scopep));
-        nodep->hiernameToProt(
-            descopedName(hierThis /*ref*/, hierUnprot /*ref*/, nodep->funcp()->scopep(), nullptr));
-        nodep->hiernameToUnprot(hierUnprot);
         // Can't do this, as we may have more calls later
         // nodep->funcp()->scopep(nullptr);
     }

src/V3EmitCBase.h

@@ -43,6 +43,7 @@ public:
         if (v3Global.opt.decoration()) puts(str);
     }
     void putsQuoted(const string& str) { ofp()->putsQuoted(str); }
+    void ensureNewLine() { ofp()->ensureNewLine(); }
     bool optSystemC() { return v3Global.opt.systemC(); }
     static string protect(const string& name) { return VIdProtect::protectIf(name, true); }
     static string protectIf(const string& name, bool doIt) {
@@ -54,22 +55,30 @@ public:
     static string ifNoProtect(const string& in) { return v3Global.opt.protectIds() ? "" : in; }
     static string symClassName() { return v3Global.opt.prefix() + "_" + protect("_Syms"); }
     static string symClassVar() { return symClassName() + "* __restrict vlSymsp"; }
-    static string symTopAssign() {
+    static string symClassAssign() {
-        return v3Global.opt.prefix() + "* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;";
+        return symClassName() + "* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;\n";
     }
-    static string funcNameProtect(const AstCFunc* nodep, const AstNodeModule* modp) {
+    static string funcNameProtect(const AstCFunc* nodep) {
+        AstNodeModule* modp = VN_CAST(nodep->user4p(), NodeModule);
+        string name;
         if (nodep->isConstructor()) {
-            return prefixNameProtect(modp);
+            name += prefixNameProtect(modp);
         } else if (nodep->isDestructor()) {
-            return string("~") + prefixNameProtect(modp);
+            name += "~";
+            name += prefixNameProtect(modp);
         } else {
-            return nodep->nameProtect();
+            if (nodep->isLoose()) {
+                name += prefixNameProtect(modp);
+                name += "__";
+            }
+            name += nodep->nameProtect();
         }
+        return name;
     }
     static string prefixNameProtect(const AstNode* nodep) {  // C++ name with prefix
         const AstNodeModule* modp = VN_CAST_CONST(nodep, NodeModule);
         if (modp && modp->isTop()) {
-            return v3Global.opt.prefix();
+            return topClassName();
         } else {
             return v3Global.opt.modPrefix() + "_" + protect(nodep->name());
         }
@@ -86,7 +95,17 @@ public:
     }
     string cFuncArgs(const AstCFunc* nodep) {
         // Return argument list for given C function
-        string args = nodep->argTypes();
+        string args;
+        if (nodep->isLoose() && nodep->isStatic().falseUnknown()) {
+            if (nodep->isConst().trueKnown()) args += "const ";
+            AstNodeModule* modp = VN_CAST(nodep->user4p(), NodeModule);
+            args += prefixNameProtect(modp);
+            args += "* vlSelf";
+        }
+        if (!nodep->argTypes().empty()) {
+            if (!args.empty()) args += ", ";
+            args += nodep->argTypes();
+        }
         // Might be a user function with argument list.
         for (const AstNode* stmtp = nodep->argsp(); stmtp; stmtp = stmtp->nextp()) {
             if (const AstVar* portp = VN_CAST_CONST(stmtp, Var)) {
@@ -105,6 +124,31 @@ public:
         return args;
     }
 
+    void emitCFuncHeader(const AstCFunc* funcp, const AstNodeModule* modp, bool withScope) {
+        if (!funcp->isConstructor() && !funcp->isDestructor()) {
+            puts(funcp->rtnTypeVoid());
+            puts(" ");
+        }
+        if (withScope && funcp->isProperMethod()) puts(prefixNameProtect(modp) + "::");
+        puts(funcNameProtect(funcp));
+        puts("(" + cFuncArgs(funcp) + ")");
+        if (funcp->isConst().trueKnown() && funcp->isProperMethod()) puts(" const");
+    }
+
+    void emitCFuncDecl(const AstCFunc* funcp, const AstNodeModule* modp) {
+        ensureNewLine();
+        if (!funcp->ifdef().empty()) puts("#ifdef " + funcp->ifdef() + "\n");
+        if (funcp->isStatic().trueUnknown() && funcp->isProperMethod()) puts("static ");
+        if (funcp->isVirtual()) {
+            UASSERT_OBJ(funcp->isProperMethod(), funcp, "Virtual function is not a proper method");
+            puts("virtual ");
+        }
+        emitCFuncHeader(funcp, modp, /* withScope: */ false);
+        if (funcp->slow()) puts(" VL_ATTR_COLD");
+        puts(";\n");
+        if (!funcp->ifdef().empty()) puts("#endif  // " + funcp->ifdef() + "\n");
+    }
+
     // CONSTRUCTORS
     EmitCBaseVisitor() = default;
     virtual ~EmitCBaseVisitor() override = default;

src/V3EmitV.cpp

@@ -624,9 +624,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
         if (nodep->varScopep()) {
             putfs(nodep, nodep->varScopep()->prettyName());
         } else {
-            putfs(nodep, nodep->hiernameToUnprot());
+            if (nodep->selfPointer().empty()) {
-            puts(nodep->hiernameToProt());
+                putfs(nodep, nodep->varp()->prettyName());
-            puts(nodep->varp()->prettyName());
+            } else {
+                putfs(nodep, nodep->selfPointer() + "->");
+                puts(nodep->varp()->prettyName());
+            }
         }
     }
     virtual void visit(AstVarXRef* nodep) override {

src/V3File.cpp

@@ -966,7 +966,7 @@ public:
     VIdProtectImp() {
         passthru("this");
         passthru("TOPp");
-        passthru("vlTOPp");
+        passthru("vlSelf");
         passthru("vlSymsp");
     }
     ~VIdProtectImp() = default;
@@ -1016,8 +1016,7 @@ public:
         }
     }
     string protectWordsIf(const string& old, bool doIt) {
-        // Split at " " (for traces), "." (for scopes), "->" (for scopes), "::" (for superclass
+        // Split at " " (for traces), "." (for scopes), "->", "(", "&", ")" (for self pointers)
-        // reference)
         if (!(doIt && v3Global.opt.protectIds())) return old;
         string out;
         string::size_type start = 0;
@@ -1029,7 +1028,9 @@ public:
             trySep(old, start, " ", pos /*ref*/, separator /*ref*/);
             trySep(old, start, ".", pos /*ref*/, separator /*ref*/);
             trySep(old, start, "->", pos /*ref*/, separator /*ref*/);
-            trySep(old, start, "::", pos /*ref*/, separator /*ref*/);
+            trySep(old, start, "(", pos /*ref*/, separator /*ref*/);
+            trySep(old, start, "&", pos /*ref*/, separator /*ref*/);
+            trySep(old, start, ")", pos /*ref*/, separator /*ref*/);
             if (pos == string::npos) break;
             out += protectIf(old.substr(start, pos - start), true) + separator;
             start = pos + separator.length();

src/V3File.h

@@ -165,6 +165,9 @@ public:
     void blockDec() {
         if (!m_parenVec.empty()) m_parenVec.pop();
     }
+    void ensureNewLine() {
+        if (!m_nobreak) puts("\n");
+    }
     // STATIC METHODS
     static string indentSpaces(int num);
     // Add escaped characters to strings

src/V3Hasher.cpp

@@ -199,7 +199,7 @@ private:
                 iterateNull(nodep->varScopep());
             } else {
                 iterateNull(nodep->varp());
-                m_hash += nodep->hiernameToProt();
+                m_hash += nodep->selfPointer();
             }
         });
     }
@@ -229,6 +229,11 @@ private:
             m_hash += nodep->text();
         });
     }
+    virtual void visit(AstAddrOfCFunc* nodep) override {
+        m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
+            iterateNull(nodep->funcp());
+        });
+    }
 
     //------------------------------------------------------------
     // AstNodeStmt
@@ -364,7 +369,9 @@ private:
         });
     }
     virtual void visit(AstCFunc* nodep) override {
-        m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
+        m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {  //
+            m_hash += nodep->isLoose();
+        });
     }
     virtual void visit(AstVar* nodep) override {
         m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {

src/V3Localize.cpp

@@ -76,8 +76,7 @@ private:
         // cppcheck-suppress unreadVariable  // cppcheck 1.90 bug
         VarFlags flags(nodep->varp());
         if (flags.m_done) {
-            nodep->hiernameToProt("");  // Remove this->
+            nodep->selfPointer("");  // Remove 'this'
-            nodep->hiernameToUnprot("");  // Remove this->
             nodep->hierThis(true);
         }
     }

src/V3Order.cpp

@@ -1754,14 +1754,13 @@ AstActive* OrderVisitor::processMoveOneLogic(const OrderLogicVertex* lvertexp,
             if (!newFuncpr && domainp != m_deleteDomainp) {
                 const string name = cfuncName(modp, domainp, scopep, nodep);
                 newFuncpr = new AstCFunc(nodep->fileline(), name, scopep);
-                newFuncpr->argTypes(EmitCBaseVisitor::symClassVar());
+                newFuncpr->isStatic(false);
-                newFuncpr->symProlog(true);
+                newFuncpr->isLoose(true);
                 newStmtsr = 0;
                 if (domainp->hasInitial() || domainp->hasSettle()) newFuncpr->slow(true);
                 scopep->addActivep(newFuncpr);
                 // Create top call to it
                 AstCCall* const callp = new AstCCall(nodep->fileline(), newFuncpr);
-                callp->argTypes("vlSymsp");
                 // Where will we be adding the call?
                 AstActive* const newActivep = new AstActive(nodep->fileline(), name, domainp);
                 newActivep->addStmtsp(callp);

src/V3String.cpp

@@ -157,6 +157,23 @@ double VString::parseDouble(const string& str, bool* successp) {
     return d;
 }
 
+static bool isWordChar(char c) { return isalnum(c) || c == '_'; }
+
+string VString::replaceWord(const string& str, const string& from, const string& to) {
+    string result = str;
+    const size_t len = from.size();
+    UASSERT_STATIC(len > 0, "Cannot replace empty string");
+    for (size_t pos = 0; (pos = result.find(from, pos)) != string::npos; pos += len) {
+        // Only replace whole words
+        if (((pos > 0) && isWordChar(result[pos - 1])) ||  //
+            ((pos + len < result.size()) && isWordChar(result[pos + len]))) {
+            continue;
+        }
+        result.replace(pos, len, to);
+    }
+    return result;
+}
+
 //######################################################################
 // VHashSha256
 

src/V3String.h

@@ -100,6 +100,10 @@ public:
     static bool isWhitespace(const string& str);
     // Return double by parsing string
     static double parseDouble(const string& str, bool* successp);
+    // Replace all occurrences of the word 'from' in 'str' with 'to'. A word is considered
+    // to be a consecutive sequence of the characters [a-zA-Z0-9_]. Sub-words are not replaced.
+    // e.g.: replaceWords("one apple bad_apple", "apple", "banana") -> "one banana bad_apple"
+    static string replaceWord(const string& str, const string& from, const string& to);
 };
 
 //######################################################################

src/V3Task.cpp

@@ -854,10 +854,8 @@ private:
         {  // Call the user function
             // Add the variables referenced as VarRef's so that lifetime analysis
             // doesn't rip up the variables on us
-            string stmt;
-            stmt += "(*__Vcb)(";
             args += ");\n";
-            AstCStmt* newp = new AstCStmt(nodep->fileline(), stmt);
+            AstCStmt* newp = new AstCStmt(nodep->fileline(), "(*__Vcb)(");
             newp->addBodysp(argnodesp);
             VL_DANGLING(argnodesp);
             newp->addBodysp(new AstText(nodep->fileline(), args, true));
@@ -1131,7 +1129,7 @@ private:
         cfuncp->funcPublic(nodep->taskPublic());
         cfuncp->dpiExport(nodep->dpiExport());
         cfuncp->dpiImportWrapper(nodep->dpiImport());
-        cfuncp->isStatic(!(nodep->dpiImport() || nodep->taskPublic() || nodep->classMethod()));
+        cfuncp->isStatic(nodep->dpiExport());
         cfuncp->isVirtual(nodep->isVirtual());
         cfuncp->pure(nodep->pure());
         if (nodep->name() == "new") {
@@ -1145,21 +1143,12 @@ private:
         // cfuncp->dpiImport   // Not set in the wrapper - the called function has it set
         if (cfuncp->dpiExport()) cfuncp->cname(nodep->cname());
 
-        bool needSyms = !nodep->dpiImport();
+        if (!nodep->dpiImport() && !nodep->taskPublic()) {
-        if (needSyms) {
+            // Need symbol table
-            if (nodep->taskPublic()) {
+            cfuncp->argTypes(EmitCBaseVisitor::symClassVar());
-                // We need to get a pointer to all of our variables (may
+            if (cfuncp->name() == "new") {
-                // have eval'ed something else earlier)
+                const string stmt = VIdProtect::protect("_ctor_var_reset") + "(vlSymsp);\n";
-                cfuncp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symClassVar()
+                cfuncp->addInitsp(new AstCStmt(nodep->fileline(), stmt));
-                                                                      + " = this->__VlSymsp;\n"));
-            } else {
-                // Need symbol table
-                cfuncp->argTypes(EmitCBaseVisitor::symClassVar());
-                if (cfuncp->name() == "new") {
-                    cfuncp->addInitsp(
-                        new AstCStmt(nodep->fileline(),
-                                     VIdProtect::protect("_ctor_var_reset") + "(vlSymsp);\n"));
-                }
             }
         }
         if (nodep->dpiContext()) {
@@ -1169,11 +1158,6 @@ private:
             createInputVar(cfuncp, "__Vlineno", AstBasicDTypeKwd::INT);
         }
 
-        if (!nodep->dpiImport()) {
-            cfuncp->addInitsp(
-                new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
-        }
-
         if (nodep->dpiExport()) {
             AstScopeName* snp = nodep->scopeNamep();
             UASSERT_OBJ(snp, nodep, "Missing scoping context");

src/V3Trace.cpp

@@ -485,33 +485,43 @@ private:
         name += cvtToStr(funcNump++);
         FileLine* const flp = m_topScopep->fileline();
         AstCFunc* const funcp = new AstCFunc(flp, name, m_topScopep);
-        const string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* tracep");
-        funcp->argTypes(argTypes);
         funcp->funcType(type);
+        funcp->dontCombine(true);
+        const bool isTopFunc
+            = type == AstCFuncType::TRACE_FULL || type == AstCFuncType::TRACE_CHANGE;
+        if (isTopFunc) {
+            funcp->argTypes("void* voidSelf, " + v3Global.opt.traceClassBase() + "* tracep");
+            funcp->isStatic(true);
+            funcp->addInitsp(new AstCStmt(
+                flp, prefixNameProtect(m_topModp) + "* const __restrict vlSelf = static_cast<"
+                         + prefixNameProtect(m_topModp) + "*>(voidSelf);\n"));
+            funcp->addInitsp(new AstCStmt(flp, symClassAssign()));
+
+        } else {
+            funcp->argTypes(v3Global.opt.traceClassBase() + "* tracep");
+            funcp->isStatic(false);
+        }
+        funcp->isLoose(true);
         funcp->slow(type == AstCFuncType::TRACE_FULL || type == AstCFuncType::TRACE_FULL_SUB);
-        funcp->symProlog(true);
-        funcp->declPrivate(true);
         // Add it to top scope
         m_topScopep->addActivep(funcp);
         // Add call to new function
         if (callfromp) {
             AstCCall* callp = new AstCCall(funcp->fileline(), funcp);
-            callp->argTypes("userp, tracep");
+            callp->argTypes("tracep");
             callfromp->addStmtsp(callp);
         }
         // Register function
         if (regp) {
-            string registration = "tracep->add";
             if (type == AstCFuncType::TRACE_FULL) {
-                registration += "Full";
+                regp->addStmtsp(new AstText(flp, "tracep->addFullCb(", true));
             } else if (type == AstCFuncType::TRACE_CHANGE) {
-                registration += "Chg";
+                regp->addStmtsp(new AstText(flp, "tracep->addChgCb(", true));
             } else {
                 funcp->v3fatalSrc("Don't know how to register this type of function");
             }
-            registration += "Cb(&" + protect(name) + ", __VlSymsp);\n";
+            regp->addStmtsp(new AstAddrOfCFunc(flp, funcp));
-            AstCStmt* const stmtp = new AstCStmt(flp, registration);
+            regp->addStmtsp(new AstText(flp, ", vlSelf);\n", true));
-            regp->addStmtsp(stmtp);
         }
         // Add global activity check to TRACE_CHANGE functions
         if (type == AstCFuncType::TRACE_CHANGE) {
@@ -666,17 +676,22 @@ private:
     void createCleanupFunction(AstCFunc* regFuncp) {
         FileLine* const fl = m_topScopep->fileline();
         AstCFunc* const cleanupFuncp = new AstCFunc(fl, "traceCleanup", m_topScopep);
-        const string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* /*unused*/");
+        cleanupFuncp->argTypes("void* voidSelf, " + v3Global.opt.traceClassBase()
-        cleanupFuncp->argTypes(argTypes);
+                               + "* /*unused*/");
         cleanupFuncp->funcType(AstCFuncType::TRACE_CLEANUP);
         cleanupFuncp->slow(false);
-        cleanupFuncp->symProlog(true);
+        cleanupFuncp->isStatic(true);
-        cleanupFuncp->declPrivate(true);
+        cleanupFuncp->isLoose(true);
         m_topScopep->addActivep(cleanupFuncp);
+        cleanupFuncp->addInitsp(new AstCStmt(
+            fl, prefixNameProtect(m_topModp) + "* const __restrict vlSelf = static_cast<"
+                    + prefixNameProtect(m_topModp) + "*>(voidSelf);\n"));
+        cleanupFuncp->addInitsp(new AstCStmt(fl, symClassAssign()));
 
         // Register it
-        regFuncp->addStmtsp(new AstCStmt(
+        regFuncp->addStmtsp(new AstText(fl, "tracep->addCleanupCb(", true));
-            fl, string("tracep->addCleanupCb(&" + protect("traceCleanup") + ", __VlSymsp);\n")));
+        regFuncp->addStmtsp(new AstAddrOfCFunc(fl, cleanupFuncp));
+        regFuncp->addStmtsp(new AstText(fl, ", vlSelf);\n", true));
 
         // Clear global activity flag
         cleanupFuncp->addStmtsp(
@@ -726,7 +741,7 @@ private:
         regFuncp->funcType(AstCFuncType::TRACE_REGISTER);
         regFuncp->slow(true);
         regFuncp->isStatic(false);
-        regFuncp->declPrivate(true);
+        regFuncp->isLoose(true);
         m_topScopep->addActivep(regFuncp);
 
         const int parallelism = 1;  // Note: will bump this later, code below works for any value

src/V3TraceDecl.cpp

@@ -72,13 +72,13 @@ private:
     AstCFunc* newCFunc(AstCFuncType type, const string& name) {
         FileLine* const flp = m_topScopep->fileline();
         AstCFunc* const funcp = new AstCFunc(flp, name, m_topScopep);
-        string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* tracep");
+        string argTypes = v3Global.opt.traceClassBase() + "* tracep";
         if (m_interface) argTypes += ", int scopet, const char* scopep";
         funcp->argTypes(argTypes);
         funcp->funcType(type);
-        funcp->symProlog(true);
+        funcp->isStatic(false);
+        funcp->isLoose(true);
         funcp->slow(true);
-        funcp->declPrivate(true);
         m_topScopep->addActivep(funcp);
         UINFO(5, "  Newfunc " << funcp << endl);
         return funcp;
@@ -86,10 +86,10 @@ private:
     void callCFuncSub(AstCFunc* basep, AstCFunc* funcp, AstIntfRef* irp) {
         AstCCall* callp = new AstCCall(funcp->fileline(), funcp);
         if (irp) {
-            callp->argTypes("userp, tracep, VLT_TRACE_SCOPE_INTERFACE");
+            callp->argTypes("tracep, VLT_TRACE_SCOPE_INTERFACE");
             callp->addArgsp(irp->unlinkFrBack());
         } else {
-            callp->argTypes("userp, tracep");
+            callp->argTypes("tracep");
         }
         basep->addStmtsp(callp);
     }

test_regress/t/t_c_this.pl

@@ -0,0 +1,27 @@
+#!/usr/bin/env perl
+if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# Copyright 2021 by Wilson Snyder. 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-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+scenarios(vlt => 1);
+
+compile();
+
+if ($Self->{vlt_all}) {
+    # The word 'this' (but only the whole word 'this' should have been replaced
+    # in the contents.
+    my $file = "$Self->{obj_dir}/$Self->{VM_PREFIX}.cpp";
+    my $text = file_contents($file);
+    error("$file has 'this->clk'") if ($text =~ m/\bthis->clk\b/);
+    error("$file does not have 'xthis'") if ($text !~ m/\bxthis\b/);
+    error("$file does not have 'thisx'") if ($text !~ m/\bthisx\b/);
+    error("$file does not have 'xthisx'") if ($text !~ m/\bxthisx\b/);
+}
+
+ok(1);
+1;

test_regress/t/t_c_this.v

@@ -0,0 +1,15 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2021 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
+
+module t (clk);
+   input clk;
+   always @(posedge clk) begin
+     $c("const CData xthis = this->clk;");
+     $c("const CData thisx = xthis;");
+     $c("const CData xthisx = thisx;");
+     $c("this->clk = xthisx;");
+   end
+endmodule

test_regress/t/t_class_extends_this_protect_ids.pl

@@ -0,0 +1,33 @@
+#!/usr/bin/env perl
+if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# Copyright 2020 by Wilson Snyder. 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-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+scenarios(vlt_all => 1);
+
+# This test makes randomly named .cpp/.h files, which tend to collect, so remove them first
+foreach my $filename (glob ("$Self->{obj_dir}/*_PS*.cpp"
+                            ." $Self->{obj_dir}/*_PS*.h"
+                            ." $Self->{obj_dir}/*.d" )) {
+    print "rm $filename\n" if $Self->{verbose};
+    unlink $filename;
+}
+
+top_filename("t/t_class_extends_this.v");
+
+compile(
+    verilator_flags2 => ["--protect-ids",
+                         "--protect-key SECRET_KEY"]
+    );
+
+execute(
+    check_finished => 1,
+    );
+
+ok(1);
+1;

test_regress/t/t_cover_line.out

@@ -125,7 +125,7 @@
 	         end
 %000002	         else if (cyc==5) begin
 	`ifdef VERILATOR
-%000001	            $c("call_task();");
+%000001	            $c("this->call_task();");
 	`else
 	            call_task();
 	`endif

test_regress/t/t_cover_line.v

@@ -104,7 +104,7 @@ module t (/*AUTOARG*/
          end
          else if (cyc==5) begin
 `ifdef VERILATOR
-            $c("call_task();");
+            $c("this->call_task();");
 `else
             call_task();
 `endif

test_regress/t/t_debug_emitv.out

@@ -47,8 +47,6 @@ module Vt_debug_emitv;
     end
 
     ???? // CFUNC '_final_TOP'
-    $_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
-    );
     $display("stmt");
     always @(posedge clk)@(negedge clk) begin
         $display("posedge clk");
@@ -238,14 +236,10 @@ class Vt_debug_emitv___024unit__03a__03aCls;
 signed int [31:0]  member;
 
 ???? // CFUNC '__VnoInFunc_method'
-$_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
-);
 
 ???? // CFUNC 'new'
 $_CSTMT(_ctor_var_reset(vlSymsp);
 );
-$_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
-);
 $unit::Cls.member = 32'sh1;
 endclass
 /*class*/package Vt_debug_emitv___024unit__03a__03aCls__Vclpkg;

test_regress/t/t_dpi_var.v

@@ -88,7 +88,7 @@ module sub (/*AUTOARG*/
 
    initial begin
       // Test the naming
-      $c("mon_class_name(name());");
+      $c("mon_class_name(this->name());");
       mon_scope_name("%m");
       // Scheme A - pass pointer directly
       $c("mon_register_a(\"in\",&",in,",false);");

test_regress/t/t_extend.v

@@ -34,7 +34,7 @@ module t (/*AUTOARG*/
 `ifdef VERILATOR
 	 $c("VL_PRINTF(\"Calling $c, calling $c...\\n\");");
 	 $c("VL_PRINTF(\"Cyc=%d\\n\",",cyc,");");
-	 c_worked <= $c("my_function()");
+	 c_worked <= $c("this->my_function()");
 	 c_wider <= $c9("0x10");
 `else
 	 c_worked <= 1'b1;

test_regress/t/t_extend_class.v

@@ -43,7 +43,7 @@ module t_extend_class_v (/*AUTOARG*/
 
    always @* begin
       // When "in" changes, call my method
-      out = $c("m_myobjp->my_math(",in,")");
+      out = $c("this->m_myobjp->my_math(",in,")");
    end
 
  `systemc_header

test_regress/t/t_flag_csplit.pl

@@ -96,6 +96,7 @@ sub check_cpp {
                 && $func !~ /::trace$/
                 && $func !~ /::traceInit$/
                 && $func !~ /::traceFull$/
+                && $func !~ /::final$/
                 ) {
                 push @funcs, $func;
             }

test_regress/t/t_flag_csplit_eval.pl

@@ -15,7 +15,7 @@ sub check_evals {
         local $/; undef $/;
         my $wholefile = <$fh>;
 
-        if ($wholefile =~ /::_eval[0-9]+/) {
+        if ($wholefile =~ /___eval[0-9]+/) {
             ++$got;
         }
     }

test_regress/t/t_func_public.v

@@ -16,7 +16,7 @@ module t (clk);
 	 cyc <= cyc + 1;
 	 if (cyc==1) begin
 `ifdef verilator
-	    $c("publicTop();");
+	    $c("this->publicTop();");
 `endif
 	 end
 	 if (cyc==20) begin
@@ -84,32 +84,32 @@ module tpub (
 	 //
 `ifdef VERILATOR_PUBLIC_TASKS
 	 if (cyc==11) begin
-	    $c("publicNoArgs();");
+	    $c("this->publicNoArgs();");
-	    $c("publicSetBool(true);");
+	    $c("this->publicSetBool(true);");
-	    $c("publicSetLong(0x11bca);");
+	    $c("this->publicSetLong(0x11bca);");
-	    $c("publicSetQuad(0x66655554444ULL);");
+	    $c("this->publicSetQuad(0x66655554444ULL);");
-	    $c("publicSetFlop(0x321);");
+	    $c("this->publicSetFlop(0x321);");
 	    //Unsupported: $c("WData w[3] = {0x12, 0x5678_9123, 0x1245_2352}; publicSetWide(w);");
 	 end
 	 if (cyc==12) begin
-	    $c("got_bool = publicGetSetBool(true);");
+	    $c("this->got_bool = this->publicGetSetBool(true);");
-	    $c("got_long = publicGetSetLong(0x11bca);");
+	    $c("this->got_long = this->publicGetSetLong(0x11bca);");
-	    $c("got_quad = publicGetSetQuad(0xaaaabbbbccccULL);");
+	    $c("this->got_quad = this->publicGetSetQuad(0xaaaabbbbccccULL);");
 	 end
 	 if (cyc==13) begin
-	    $c("{ bool gb; publicGetBool(gb); got_bool=gb; }");
+	    $c("{ bool gb; this->publicGetBool(gb); this->got_bool=gb; }");
 	    if (1'b1 != got_bool) $stop;
-	    $c("publicGetLong(got_long);");
+	    $c("this->publicGetLong(this->got_long);");
 	    if (24'h11bca != got_long) $stop;
-	    $c("{ vluint64_t qq; publicGetQuad(qq); got_quad=qq; }");
+	    $c("{ vluint64_t qq; this->publicGetQuad(qq); this->got_quad=qq; }");
 	    if (60'haaaa_bbbb_cccc != got_quad) $stop;
-	    $c("{ WData gw[3]; publicGetWide(gw); VL_ASSIGN_W(72,got_wide,gw); }");
+	    $c("{ WData gw[3]; this->publicGetWide(gw); VL_ASSIGN_W(72,this->got_wide,gw); }");
 	    if (72'hac_abca_aaaa_bbbb_1234 != got_wide) $stop;
 	    //Below doesn't work, because we're calling it inside the loop that sets var_flop
 	    // if (12'h321 != var_flop) $stop;
 	 end
 	 if (cyc==14) begin
-	    if ($c32("publicInstNum()") != i) $stop;
+	    if ($c32("this->publicInstNum()") != i) $stop;
 	 end
 `endif
       end

test_regress/t/t_func_rand.v

@@ -20,7 +20,7 @@ module t (clk, Rand);
       input [7:0]    idx;
       begin
 `ifdef verilator
-	 QxRand32 = $c ("QxRandTbl(",tbl,",",idx,")");
+	 QxRand32 = $c("this->QxRandTbl(",tbl,",",idx,")");
 `else
 	 QxRand32 = 32'hfeed0fad;
 `endif

test_regress/t/t_inst_tree_inl0_pub1.pl

@@ -26,9 +26,7 @@ sub checkRelativeRefs {
     my $file = "$Self->{obj_dir}/V$Self->{name}_${mod}.cpp";
     my $text = file_contents($file);
 
-    # Remove "this->__VlSymsp" which is noise
+    if ($text =~ m/this->/ || $text =~ m/vlSelf->/) {
-    $text =~ s/this->__VlSymsp//g;
-    if ($text =~ m/this->/) {
         $found_relative = 1;
     }
 
@@ -45,12 +43,9 @@ if ($Self->{vlt_all}) {
     file_grep($Self->{stats}, qr/Optimizations, Combined CFuncs\s+(\d+)/i,
               ($Self->{vltmt} ? 84 : 52));
 
-    # Expect absolute refs in CFuncs for t (top module) and l1 (because it
+    # Everything should use relative references
-    # has only one instance)
+    checkRelativeRefs("t", 1);
-    checkRelativeRefs("t", 0);
+    checkRelativeRefs("l1", 1);
-    checkRelativeRefs("l1", 0);
-
-    # Others should get relative references
     checkRelativeRefs("l2", 1);
     checkRelativeRefs("l3", 1);
     checkRelativeRefs("l4", 1);

test_regress/t/t_inst_tree_inl0_pub1_norelcfuncs.pl

@@ -24,13 +24,18 @@ if ($Self->{vlt_all}) {
     file_grep($Self->{stats}, qr/Optimizations, Combined CFuncs\s+(\d+)/i,
               ($Self->{vltmt} ? 0 : 31));
 
-    # Should not find any 'this->' except some 'this->__VlSymsp'
+    # Should not find any 'this->' or 'vlSelf->' except some specific cases
     my @files = `ls $Self->{obj_dir}/*.cpp`;
     foreach my $file (@files) {
         chomp $file;
         my $text = file_contents($file);
-        $text =~ s/this->__VlSymsp//g;
+        $text =~ s/(vlSelf|this)->vlSymsp//g;
-        if ($text =~ m/this->/) {
+        $text =~ s/vlSelf->.* = VL_RAND_RESET.*;//g;
+        $text =~ s/vlSelf->__Vm_even_cycle//g;
+        $text =~ s/vlSelf->__Vm_even_cycle//g;
+        $text =~ s/vlSelf->__Vm_mt_(final|\d+)//g;
+        $text =~ s/vlSelf->__Vm_threadPoolp//g;
+        if ($text =~ m/this->/ || $text =~ m/vlSelf->/) {
             error("$file has unexpected this-> refs when --norelative-cfuncs");
         }
     }

test_regress/t/t_param_public.v

@@ -27,7 +27,7 @@ module a;
    parameter ONE /*verilator public*/ = 22;
    initial if (ONE != 1) $stop;
 `ifdef VERILATOR
-   initial if ($c32("ONE") != 1) $stop;
+   initial if ($c32("this->ONE") != 1) $stop;
 `endif
 endmodule
 
@@ -36,7 +36,7 @@ module b #(
 	   );
    initial if (TWO != 2) $stop;
 `ifdef VERILATOR
-   initial if ($c32("TWO") != 2) $stop;
+   initial if ($c32("this->TWO") != 2) $stop;
 `endif
 endmodule
 

test_regress/t/t_protect_ids_key.out

@@ -29,6 +29,7 @@
   <map from="PSABAY" to="_eval_initial"/>
   <map from="PSOLeN" to="_eval_initial_loop"/>
   <map from="PSBUJ6" to="_eval_settle"/>
+  <map from="PSAsei" to="_final"/>
   <map from="PSV5uq" to="_sequent__TOP__1"/>
   <map from="PS8sdG" to="_sequent__TOP__t__DOT__secret_inst__1"/>
   <map from="PScyq8" to="clk"/>
@@ -38,6 +39,6 @@
   <map from="PSBSVV" to="t/t_protect_ids.v"/>
   <map from="PSB07q" to="t__DOT__secret_inst2__DOT__secret_cyc"/>
   <map from="this" to="this"/>
+  <map from="vlSelf" to="vlSelf"/>
   <map from="vlSymsp" to="vlSymsp"/>
-  <map from="vlTOPp" to="vlTOPp"/>
 </verilator_id_map>

test_regress/t/t_unopt_converge_initial_run_bad.out

@@ -1,5 +1,5 @@
 -V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
--V{t#,#}+    Vt_unopt_converge_initial_run_bad::_change_request
+-V{t#,#}+    Vt_unopt_converge_initial_run_bad___change_request
 -V{t#,#}        CHANGE: t/t_unopt_converge_initial.v:19: x
 %Error: t/t_unopt_converge_initial.v:7: Verilated model didn't DC converge
 Aborting...

test_regress/t/t_unopt_converge_print_bad.out

@@ -1,5 +1,5 @@
 -V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
--V{t#,#}+    Vt_unopt_converge_print_bad::_change_request
+-V{t#,#}+    Vt_unopt_converge_print_bad___change_request
 -V{t#,#}        CHANGE: t/t_unopt_converge.v:19: x
 %Error: t/t_unopt_converge.v:7: Verilated model didn't converge
 Aborting...

test_regress/t/t_unopt_converge_run_bad.out

@@ -1,5 +1,5 @@
 -V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
--V{t#,#}+    Vt_unopt_converge_run_bad::_change_request
+-V{t#,#}+    Vt_unopt_converge_run_bad___change_request
 -V{t#,#}        CHANGE: t/t_unopt_converge.v:19: x
 %Error: t/t_unopt_converge.v:7: Verilated model didn't converge
 Aborting...

test_regress/t/t_verilated_debug.out

@@ -1,29 +1,30 @@
 -V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
--V{t#,#}+    Vt_verilated_debug::_ctor_var_reset
+-V{t#,#}+    Vt_verilated_debug___ctor_var_reset
 internalsDump:
   Version: Verilator ###
   Argv: obj_vlt/t_verilated_debug/Vt_verilated_debug
   scopesDump:
 
--V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval
+-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval_step
--V{t#,#}+    Vt_verilated_debug::_eval_debug_assertions
+-V{t#,#}+    Vt_verilated_debug___eval_debug_assertions
--V{t#,#}+    Vt_verilated_debug::_eval_initial
+-V{t#,#}+    Vt_verilated_debug___eval_initial
--V{t#,#}+    Vt_verilated_debug::_initial__TOP__1
+-V{t#,#}+    Vt_verilated_debug___initial__TOP__1
   Data: w96: 000000aa 000000bb 000000cc 
--V{t#,#}+    Vt_verilated_debug::_eval_settle
+-V{t#,#}+ Initial loop
--V{t#,#}+    Vt_verilated_debug::_eval
+-V{t#,#}+    Vt_verilated_debug___eval_settle
--V{t#,#}+    Vt_verilated_debug::_change_request
+-V{t#,#}+    Vt_verilated_debug___eval
--V{t#,#}+    Vt_verilated_debug::_change_request_1
+-V{t#,#}+    Vt_verilated_debug___change_request
+-V{t#,#}+    Vt_verilated_debug___change_request_1
 -V{t#,#}+ Clock loop
--V{t#,#}+    Vt_verilated_debug::_eval
+-V{t#,#}+    Vt_verilated_debug___eval
--V{t#,#}+    Vt_verilated_debug::_change_request
+-V{t#,#}+    Vt_verilated_debug___change_request
--V{t#,#}+    Vt_verilated_debug::_change_request_1
+-V{t#,#}+    Vt_verilated_debug___change_request_1
--V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval
+-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval_step
--V{t#,#}+    Vt_verilated_debug::_eval_debug_assertions
+-V{t#,#}+    Vt_verilated_debug___eval_debug_assertions
 -V{t#,#}+ Clock loop
--V{t#,#}+    Vt_verilated_debug::_eval
+-V{t#,#}+    Vt_verilated_debug___eval
--V{t#,#}+    Vt_verilated_debug::_sequent__TOP__2
+-V{t#,#}+    Vt_verilated_debug___sequent__TOP__2
 *-* All Finished *-*
--V{t#,#}+    Vt_verilated_debug::_change_request
+-V{t#,#}+    Vt_verilated_debug___change_request
--V{t#,#}+    Vt_verilated_debug::_change_request_1
+-V{t#,#}+    Vt_verilated_debug___change_request_1
--V{t#,#}+    Vt_verilated_debug::final
+-V{t#,#}+    Vt_verilated_debug___final