diff --git a/include/verilatedos.h b/include/verilatedos.h
index 7efd61e21..da40b1edd 100644
--- a/include/verilatedos.h
+++ b/include/verilatedos.h
@@ -160,6 +160,13 @@
 #else
 # define VL_MT_SAFE
 #endif
+// Comment tag that function is threadsafe, only if
+// other threads doesn't change tree topology
+#if defined(__clang__)
+# define VL_MT_STABLE __attribute__((annotate("MT_STABLE")))
+#else
+# define VL_MT_STABLE
+#endif
 // Comment tag that function is threadsafe, only
 // during normal operation (post-init)
 #if defined(__clang__)
diff --git a/nodist/clang_check_attributes b/nodist/clang_check_attributes
index 5c6aec2df..dba884b49 100755
--- a/nodist/clang_check_attributes
+++ b/nodist/clang_check_attributes
@@ -37,6 +37,7 @@ def fully_qualified_name(node):
 class VlAnnotations:
     mt_start: bool = False
     mt_safe: bool = False
+    stable_tree: bool = False
     mt_safe_postinit: bool = False
     mt_unsafe: bool = False
     mt_unsafe_one: bool = False
@@ -54,6 +55,9 @@ class VlAnnotations:
     def is_pure_context(self):
         return self.pure
 
+    def is_stabe_tree_context(self):
+        return self.stable_tree
+
     def is_mt_unsafe_call(self):
         return self.mt_unsafe or self.mt_unsafe_one
 
@@ -66,6 +70,9 @@ class VlAnnotations:
     def is_pure_call(self):
         return self.pure
 
+    def is_stabe_tree_call(self):
+        return self.stable_tree
+
     def __or__(self, other: "VlAnnotations"):
         result = VlAnnotations()
         for key, value in dataclasses.asdict(self).items():
@@ -94,6 +101,8 @@ class VlAnnotations:
                     result.mt_start = True
                 elif node.displayname == "MT_SAFE":
                     result.mt_safe = True
+                elif node.displayname == "MT_STABLE":
+                    result.stable_tree = True
                 elif node.displayname == "MT_SAFE_POSTINIT":
                     result.mt_safe_postinit = True
                 elif node.displayname == "MT_UNSAFE":
@@ -196,6 +205,7 @@ class DiagnosticKind(Enum):
     ANNOTATIONS_DEF_DECL_MISMATCH = enum.auto()
     NON_PURE_CALL_IN_PURE_CTX = enum.auto()
     NON_MT_SAFE_CALL_IN_MT_SAFE_CTX = enum.auto()
+    NON_STABLE_TREE_CALL_IN_STABLE_TREE_CTX = enum.auto()
 
     def __lt__(self, other):
         return self.value < other.value
@@ -377,6 +387,16 @@ class CallAnnotationsValidator:
                     FunctionInfo.from_node(refd, refd, annotations),
                     DiagnosticKind.NON_MT_SAFE_CALL_IN_MT_SAFE_CTX)
 
+        # stable tree context
+        if ctx.is_stabe_tree_context():
+            if not (annotations.is_stabe_tree_call()
+                    or annotations.is_pure_call()
+                    or self.check_mt_safe_call(node, refd, annotations)):
+                self.emit_diagnostic(
+                    FunctionInfo.from_node(refd, refd, annotations),
+                    DiagnosticKind.NON_STABLE_TREE_CALL_IN_STABLE_TREE_CTX)
+
+        # pure context
         if ctx.is_pure_context():
             if not annotations.is_pure_call():
                 self.emit_diagnostic(
@@ -394,6 +414,16 @@ class CallAnnotationsValidator:
                 self.emit_diagnostic(
                     FunctionInfo.from_node(refd, refd, annotations),
                     DiagnosticKind.NON_MT_SAFE_CALL_IN_MT_SAFE_CTX)
+
+        # stable tree context
+        if ctx.is_stabe_tree_context():
+            if not (annotations.is_pure_call()
+                    or annotations.is_mt_safe_call()
+                    or annotations.is_stabe_tree_call()):
+                self.emit_diagnostic(
+                    FunctionInfo.from_node(refd, refd, annotations),
+                    DiagnosticKind.NON_STABLE_TREE_CALL_IN_STABLE_TREE_CTX)
+
         # pure context
         if ctx.is_pure_context():
             if not annotations.is_pure_call():
@@ -414,6 +444,13 @@ class CallAnnotationsValidator:
                                   self.dispatch_node_inside_definition)
             self._constructor_context -= 1
 
+        # stable tree context
+        if ctx.is_stabe_tree_context():
+            self._constructor_context += 1
+            self.iterate_children(refd.get_children(),
+                                  self.dispatch_node_inside_definition)
+            self._constructor_context -= 1
+
         # pure context
         if ctx.is_pure_context():
             if not annotations.is_pure_call(
@@ -788,6 +825,8 @@ class TopDownSummaryPrinter():
                 name += "is mtsafe but calls non-mtsafe function(s)"
             elif func.reason == DiagnosticKind.NON_PURE_CALL_IN_PURE_CTX:
                 name += "is pure but calls non-pure function(s)"
+            elif func.reason == DiagnosticKind.NON_STABLE_TREE_CALL_IN_STABLE_TREE_CTX:
+                name += "calls stable_tree function(s) but isn't annotated as stable_tree"
             else:
                 name += "for unknown reason (please add description)"
 
diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp
index 8b8fcc7f3..49d1a0434 100644
--- a/src/V3Ast.cpp
+++ b/src/V3Ast.cpp
@@ -155,7 +155,7 @@ string AstNode::vcdName(const string& namein) {
     return prettyName(pretty);
 }
 
-string AstNode::prettyName(const string& namein) {
+string AstNode::prettyName(const string& namein) VL_PURE {
     // This function is somewhat hot, so we short-circuit some compares
     string pretty;
     pretty.reserve(namein.length());
@@ -1079,7 +1079,7 @@ bool AstNode::sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ig
 //======================================================================
 // Debugging
 
-void AstNode::checkTreeIter(const AstNode* prevBackp) const {
+void AstNode::checkTreeIter(const AstNode* prevBackp) const VL_MT_STABLE {
     // private: Check a tree and children
     UASSERT_OBJ(prevBackp == this->backp(), this, "Back node inconsistent");
     switch (this->type()) {
diff --git a/src/V3Ast.h b/src/V3Ast.h
index eb7d345f7..a325e5620 100644
--- a/src/V3Ast.h
+++ b/src/V3Ast.h
@@ -102,11 +102,11 @@ public:
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     constexpr operator en() const VL_MT_SAFE { return m_e; }
 };
-constexpr bool operator==(const VNType& lhs, const VNType& rhs) VL_MT_SAFE {
+constexpr bool operator==(const VNType& lhs, const VNType& rhs) VL_PURE {
     return lhs.m_e == rhs.m_e;
 }
-constexpr bool operator==(const VNType& lhs, VNType::en rhs) { return lhs.m_e == rhs; }
-constexpr bool operator==(VNType::en lhs, const VNType& rhs) { return lhs == rhs.m_e; }
+constexpr bool operator==(const VNType& lhs, VNType::en rhs) VL_PURE { return lhs.m_e == rhs; }
+constexpr bool operator==(VNType::en lhs, const VNType& rhs) VL_PURE { return lhs == rhs.m_e; }
 inline std::ostream& operator<<(std::ostream& os, const VNType& rhs) { return os << rhs.ascii(); }
 
 // ######################################################################
@@ -1545,7 +1545,7 @@ class AstNode VL_NOT_FINAL {
 private:
     AstNode* cloneTreeIter();
     AstNode* cloneTreeIterList();
-    void checkTreeIter(const AstNode* prevBackp) const VL_MT_SAFE;
+    void checkTreeIter(const AstNode* prevBackp) const VL_MT_STABLE;
     bool gateTreeIter() const;
     static bool sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext,
                              bool gateOnly);
@@ -1601,14 +1601,14 @@ public:
     // ACCESSORS
     VNType type() const VL_MT_SAFE { return m_type; }
     const char* typeName() const VL_MT_SAFE { return type().ascii(); }  // See also prettyTypeName
-    AstNode* nextp() const VL_MT_SAFE { return m_nextp; }
-    AstNode* backp() const VL_MT_SAFE { return m_backp; }
+    AstNode* nextp() const VL_MT_STABLE { return m_nextp; }
+    AstNode* backp() const VL_MT_STABLE { return m_backp; }
     AstNode* abovep() const;  // Parent node above, only when no nextp() as otherwise slow
-    AstNode* op1p() const VL_MT_SAFE { return m_op1p; }
-    AstNode* op2p() const VL_MT_SAFE { return m_op2p; }
-    AstNode* op3p() const VL_MT_SAFE { return m_op3p; }
-    AstNode* op4p() const VL_MT_SAFE { return m_op4p; }
-    AstNodeDType* dtypep() const VL_MT_SAFE { return m_dtypep; }
+    AstNode* op1p() const VL_MT_STABLE { return m_op1p; }
+    AstNode* op2p() const VL_MT_STABLE { return m_op2p; }
+    AstNode* op3p() const VL_MT_STABLE { return m_op3p; }
+    AstNode* op4p() const VL_MT_STABLE { return m_op4p; }
+    AstNodeDType* dtypep() const VL_MT_STABLE { return m_dtypep; }
     AstNode* clonep() const { return ((m_cloneCnt == s_cloneCntGbl) ? m_clonep : nullptr); }
     AstNode* firstAbovep() const {  // Returns nullptr when second or later in list
         return ((backp() && backp()->nextp() != this) ? backp() : nullptr);
@@ -1663,11 +1663,11 @@ public:
     virtual void tag(const string& text) {}
     virtual string tag() const { return ""; }
     virtual string verilogKwd() const { return ""; }
-    string nameProtect() const VL_MT_SAFE;  // Name with --protect-id applied
+    string nameProtect() const;  // Name with --protect-id applied
     string origNameProtect() const;  // origName with --protect-id applied
     string shortName() const;  // Name with __PVT__ removed for concatenating scopes
     static string dedotName(const string& namein);  // Name with dots removed
-    static string prettyName(const string& namein);  // Name for printing out to the user
+    static string prettyName(const string& namein) VL_PURE;  // Name for printing out to the user
     static string vpiName(const string& namein);  // Name for vpi access
     static string prettyNameQ(const string& namein) {  // Quoted pretty name (for errors)
         return std::string{"'"} + prettyName(namein) + "'";
@@ -1697,25 +1697,25 @@ public:
     void protect(bool flag) { m_flags.protect = flag; }
 
     // TODO stomp these width functions out, and call via dtypep() instead
-    inline int width() const VL_MT_SAFE;
+    inline int width() const VL_MT_STABLE;
     inline int widthMin() const;
     int widthMinV() const {
         return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width();
     }
     int widthWords() const { return VL_WORDS_I(width()); }
-    bool isQuad() const VL_MT_SAFE { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); }
-    bool isWide() const VL_MT_SAFE { return (width() > VL_QUADSIZE); }
-    inline bool isDouble() const;
-    inline bool isSigned() const;
-    inline bool isString() const;
+    bool isQuad() const VL_MT_STABLE { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); }
+    bool isWide() const VL_MT_STABLE { return (width() > VL_QUADSIZE); }
+    inline bool isDouble() const VL_MT_STABLE;
+    inline bool isSigned() const VL_MT_STABLE;
+    inline bool isString() const VL_MT_STABLE;
 
     // clang-format off
-    VNUser      user1u() const VL_MT_SAFE {
+    VNUser      user1u() const VL_MT_STABLE {
         // Slows things down measurably, so disabled by default
         //UASSERT_STATIC(VNUser1InUse::s_userBusy, "userp set w/o busy");
         return ((m_user1Cnt==VNUser1InUse::s_userCntGbl) ? m_user1u : VNUser{0});
     }
-    AstNode*    user1p() const VL_MT_SAFE { return user1u().toNodep(); }
+    AstNode*    user1p() const VL_MT_STABLE { return user1u().toNodep(); }
     void        user1u(const VNUser& user) { m_user1u=user; m_user1Cnt=VNUser1InUse::s_userCntGbl; }
     void        user1p(void* userp) { user1u(VNUser{userp}); }
     int         user1() const { return user1u().toInt(); }
@@ -1724,12 +1724,12 @@ public:
     int         user1SetOnce() { int v=user1(); if (!v) user1(1); return v; }  // Better for cache than user1Inc()
     static void user1ClearTree() { VNUser1InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    VNUser      user2u() const VL_MT_SAFE {
+    VNUser      user2u() const VL_MT_STABLE {
         // Slows things down measurably, so disabled by default
         //UASSERT_STATIC(VNUser2InUse::s_userBusy, "userp set w/o busy");
         return ((m_user2Cnt==VNUser2InUse::s_userCntGbl) ? m_user2u : VNUser{0});
     }
-    AstNode*    user2p() const VL_MT_SAFE { return user2u().toNodep(); }
+    AstNode*    user2p() const VL_MT_STABLE { return user2u().toNodep(); }
     void        user2u(const VNUser& user) { m_user2u=user; m_user2Cnt=VNUser2InUse::s_userCntGbl; }
     void        user2p(void* userp) { user2u(VNUser{userp}); }
     int         user2() const { return user2u().toInt(); }
@@ -1738,12 +1738,12 @@ public:
     int         user2SetOnce() { int v=user2(); if (!v) user2(1); return v; }  // Better for cache than user2Inc()
     static void user2ClearTree() { VNUser2InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    VNUser      user3u() const VL_MT_SAFE {
+    VNUser      user3u() const VL_MT_STABLE {
         // Slows things down measurably, so disabled by default
         //UASSERT_STATIC(VNUser3InUse::s_userBusy, "userp set w/o busy");
         return ((m_user3Cnt==VNUser3InUse::s_userCntGbl) ? m_user3u : VNUser{0});
     }
-    AstNode*    user3p() const VL_MT_SAFE { return user3u().toNodep(); }
+    AstNode*    user3p() const VL_MT_STABLE { return user3u().toNodep(); }
     void        user3u(const VNUser& user) { m_user3u=user; m_user3Cnt=VNUser3InUse::s_userCntGbl; }
     void        user3p(void* userp) { user3u(VNUser{userp}); }
     int         user3() const { return user3u().toInt(); }
@@ -1752,12 +1752,12 @@ public:
     int         user3SetOnce() { int v=user3(); if (!v) user3(1); return v; }  // Better for cache than user3Inc()
     static void user3ClearTree() { VNUser3InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    VNUser      user4u() const VL_MT_SAFE {
+    VNUser      user4u() const VL_MT_STABLE {
         // Slows things down measurably, so disabled by default
         //UASSERT_STATIC(VNUser4InUse::s_userBusy, "userp set w/o busy");
         return ((m_user4Cnt==VNUser4InUse::s_userCntGbl) ? m_user4u : VNUser{0});
     }
-    AstNode*    user4p() const VL_MT_SAFE { return user4u().toNodep(); }
+    AstNode*    user4p() const VL_MT_STABLE { return user4u().toNodep(); }
     void        user4u(const VNUser& user) { m_user4u=user; m_user4Cnt=VNUser4InUse::s_userCntGbl; }
     void        user4p(void* userp) { user4u(VNUser{userp}); }
     int         user4() const { return user4u().toInt(); }
@@ -1766,12 +1766,12 @@ public:
     int         user4SetOnce() { int v=user4(); if (!v) user4(1); return v; }  // Better for cache than user4Inc()
     static void user4ClearTree() { VNUser4InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    VNUser      user5u() const VL_MT_SAFE {
+    VNUser      user5u() const VL_MT_STABLE {
         // Slows things down measurably, so disabled by default
         //UASSERT_STATIC(VNUser5InUse::s_userBusy, "userp set w/o busy");
         return ((m_user5Cnt==VNUser5InUse::s_userCntGbl) ? m_user5u : VNUser{0});
     }
-    AstNode*    user5p() const VL_MT_SAFE { return user5u().toNodep(); }
+    AstNode*    user5p() const VL_MT_STABLE { return user5u().toNodep(); }
     void        user5u(const VNUser& user) { m_user5u=user; m_user5Cnt=VNUser5InUse::s_userCntGbl; }
     void        user5p(void* userp) { user5u(VNUser{userp}); }
     int         user5() const { return user5u().toInt(); }
@@ -1907,7 +1907,7 @@ public:
     // Does tree of this == node2p?, not allowing non-isGateOptimizable
     inline bool sameGateTree(const AstNode* node2p) const;
     void deleteTree();  // Always deletes the next link
-    void checkTree() const VL_MT_SAFE {
+    void checkTree() const VL_MT_STABLE {
         if (v3Global.opt.debugCheck()) checkTreeIter(backp());
     }
     void checkIter() const;
@@ -1992,7 +1992,7 @@ private:
 
     // For internal use only.
     template <typename TargetType, typename DeclType>
-    constexpr static bool uselessCast() {
+    constexpr static bool uselessCast() VL_PURE {
         using NonRef = typename std::remove_reference<DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
@@ -2001,7 +2001,7 @@ private:
 
     // For internal use only.
     template <typename TargetType, typename DeclType>
-    constexpr static bool impossibleCast() {
+    constexpr static bool impossibleCast() VL_PURE {
         using NonRef = typename std::remove_reference<DeclType>::type;
         using NonPtr = typename std::remove_pointer<NonRef>::type;
         using NonCV = typename std::remove_cv<NonPtr>::type;
@@ -2035,7 +2035,7 @@ public:
 
     // For use via the VN_AS macro only
     template <typename T, typename E>
-    static T* privateAs(AstNode* nodep) VL_MT_SAFE {
+    static T* privateAs(AstNode* nodep) VL_PURE {
         static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
         UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@@ -2044,7 +2044,7 @@ public:
         return reinterpret_cast<T*>(nodep);
     }
     template <typename T, typename E>
-    static const T* privateAs(const AstNode* nodep) VL_MT_SAFE {
+    static const T* privateAs(const AstNode* nodep) VL_PURE {
         static_assert(!uselessCast<T, E>(), "Unnecessary VN_AS, node known to have target type.");
         static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
         UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
diff --git a/src/V3AstInlines.h b/src/V3AstInlines.h
index 79023761b..31bb603c9 100644
--- a/src/V3AstInlines.h
+++ b/src/V3AstInlines.h
@@ -25,7 +25,7 @@
 //######################################################################
 // Inline METHODS
 
-int AstNode::width() const { return dtypep() ? dtypep()->width() : 0; }
+int AstNode::width() const VL_MT_STABLE { return dtypep() ? dtypep()->width() : 0; }
 int AstNode::widthMin() const { return dtypep() ? dtypep()->widthMin() : 0; }
 bool AstNode::width1() const {  // V3Const uses to know it can optimize
     return dtypep() && dtypep()->width() == 1;
@@ -33,13 +33,13 @@ bool AstNode::width1() const {  // V3Const uses to know it can optimize
 int AstNode::widthInstrs() const {
     return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1));
 }
-bool AstNode::isDouble() const VL_MT_SAFE {
+bool AstNode::isDouble() const VL_MT_STABLE {
     return dtypep() && VN_IS(dtypep(), BasicDType) && VN_AS(dtypep(), BasicDType)->isDouble();
 }
-bool AstNode::isString() const VL_MT_SAFE {
+bool AstNode::isString() const VL_MT_STABLE {
     return dtypep() && dtypep()->basicp() && dtypep()->basicp()->isString();
 }
-bool AstNode::isSigned() const { return dtypep() && dtypep()->isSigned(); }
+bool AstNode::isSigned() const VL_MT_STABLE { return dtypep() && dtypep()->isSigned(); }
 
 bool AstNode::isZero() const {
     return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqZero());
@@ -61,12 +61,12 @@ bool AstNode::sameGateTree(const AstNode* node2p) const {
     return sameTreeIter(this, node2p, true, true);
 }
 
-int AstNodeArrayDType::left() const VL_MT_SAFE { return rangep()->leftConst(); }
-int AstNodeArrayDType::right() const VL_MT_SAFE { return rangep()->rightConst(); }
-int AstNodeArrayDType::hi() const VL_MT_SAFE { return rangep()->hiConst(); }
-int AstNodeArrayDType::lo() const VL_MT_SAFE { return rangep()->loConst(); }
-int AstNodeArrayDType::elementsConst() const VL_MT_SAFE { return rangep()->elementsConst(); }
-VNumRange AstNodeArrayDType::declRange() const VL_MT_SAFE { return VNumRange{left(), right()}; }
+int AstNodeArrayDType::left() const VL_MT_STABLE { return rangep()->leftConst(); }
+int AstNodeArrayDType::right() const VL_MT_STABLE { return rangep()->rightConst(); }
+int AstNodeArrayDType::hi() const VL_MT_STABLE { return rangep()->hiConst(); }
+int AstNodeArrayDType::lo() const VL_MT_STABLE { return rangep()->loConst(); }
+int AstNodeArrayDType::elementsConst() const VL_MT_STABLE { return rangep()->elementsConst(); }
+VNumRange AstNodeArrayDType::declRange() const VL_MT_STABLE { return VNumRange{left(), right()}; }
 
 AstRange::AstRange(FileLine* fl, int left, int right)
     : ASTGEN_SUPER_Range(fl) {
@@ -78,16 +78,16 @@ AstRange::AstRange(FileLine* fl, const VNumRange& range)
     leftp(new AstConst{fl, static_cast<uint32_t>(range.left())});
     rightp(new AstConst{fl, static_cast<uint32_t>(range.right())});
 }
-int AstRange::leftConst() const {
+int AstRange::leftConst() const VL_MT_STABLE {
     AstConst* const constp = VN_CAST(leftp(), Const);
     return (constp ? constp->toSInt() : 0);
 }
-int AstRange::rightConst() const {
+int AstRange::rightConst() const VL_MT_STABLE {
     AstConst* const constp = VN_CAST(rightp(), Const);
     return (constp ? constp->toSInt() : 0);
 }
 
-int AstQueueDType::boundConst() const VL_MT_SAFE {
+int AstQueueDType::boundConst() const VL_MT_STABLE {
     AstConst* const constp = VN_CAST(boundp(), Const);
     return (constp ? constp->toSInt() : 0);
 }
diff --git a/src/V3AstNodeDType.h b/src/V3AstNodeDType.h
index fd652f595..26f1a740e 100644
--- a/src/V3AstNodeDType.h
+++ b/src/V3AstNodeDType.h
@@ -63,9 +63,9 @@ public:
     // Integral or packed, allowed inside an unpacked union/struct
     virtual bool isIntegralOrPacked() const { return !isCompound(); }
     // (Slow) recurse down to find basic data type
-    virtual AstBasicDType* basicp() const = 0;
+    virtual AstBasicDType* basicp() const VL_MT_STABLE = 0;
     // recurses over typedefs/const/enum to next non-typeref type
-    virtual AstNodeDType* skipRefp() const = 0;
+    virtual AstNodeDType* skipRefp() const VL_MT_STABLE = 0;
     // recurses over typedefs to next non-typeref-or-const type
     virtual AstNodeDType* skipRefToConstp() const = 0;
     // recurses over typedefs/const to next non-typeref-or-enum/struct type
@@ -86,7 +86,7 @@ public:
     // Assignable equivalence.  Call skipRefp() on this and samep before calling
     virtual bool similarDType(const AstNodeDType* samep) const = 0;
     // Iff has a non-null subDTypep(), as generic node function
-    virtual AstNodeDType* subDTypep() const { return nullptr; }
+    virtual AstNodeDType* subDTypep() const VL_MT_SAFE { return nullptr; }
     virtual bool isFourstate() const;
     // Ideally an IEEE $typename
     virtual string prettyDTypeName() const { return prettyTypeName(); }
@@ -126,12 +126,13 @@ public:
     const char* charIQWN() const {
         return (isString() ? "N" : isWide() ? "W" : isQuad() ? "Q" : "I");
     }
-    string cType(const string& name, bool forFunc, bool isRef) const VL_MT_SAFE;
-    bool isLiteralType() const VL_MT_SAFE;  // Represents a C++ LiteralType? (can be constexpr)
+    string cType(const string& name, bool forFunc, bool isRef) const VL_MT_STABLE;
+    // Represents a C++ LiteralType? (can be constexpr)
+    bool isLiteralType() const VL_MT_STABLE;
 
 private:
     class CTypeRecursed;
-    CTypeRecursed cTypeRecurse(bool compound) const VL_MT_SAFE;
+    CTypeRecursed cTypeRecurse(bool compound) const VL_MT_STABLE;
 };
 class AstNodeArrayDType VL_NOT_FINAL : public AstNodeDType {
     // Array data type, ie "some_dtype var_name [2:0]"
@@ -170,29 +171,29 @@ public:
                 && subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp()));
     }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
         return m_refDTypep ? m_refDTypep : childDTypep();
     }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE {
+    AstBasicDType* basicp() const override VL_MT_STABLE {
         return subDTypep()->basicp();
     }  // (Slow) recurse down to find basic data type
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
     int widthTotalBytes() const override {
         return elementsConst() * subDTypep()->widthTotalBytes();
     }
-    inline int left() const;
-    inline int right() const;
-    inline int hi() const;
-    inline int lo() const;
-    inline int elementsConst() const;
-    inline VNumRange declRange() const;
+    inline int left() const VL_MT_STABLE;
+    inline int right() const VL_MT_STABLE;
+    inline int hi() const VL_MT_STABLE;
+    inline int lo() const VL_MT_STABLE;
+    inline int elementsConst() const VL_MT_STABLE;
+    inline VNumRange declRange() const VL_MT_STABLE;
 };
 class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
     // A struct or union; common handling
@@ -231,7 +232,7 @@ public:
                     : VN_AS(findBitRangeDType(VNumRange{width() - 1, 0}, width(), numeric()),
                             BasicDType));
     }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
@@ -248,7 +249,7 @@ public:
     // packed() but as don't support unpacked, presently all structs
     static bool packedUnsup() { return true; }
     void isFourstate(bool flag) { m_isFourstate = flag; }
-    bool isFourstate() const override { return m_isFourstate; }
+    bool isFourstate() const override VL_MT_SAFE { return m_isFourstate; }
     void clearCache() { m_members.clear(); }
     void repairMemberCache();
     AstMemberDType* findMember(const string& name) const {
@@ -336,7 +337,7 @@ public:
     void dumpSmall(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
     AstNodeDType* getChild2DTypep() const override { return keyChildDTypep(); }
-    AstNodeDType* subDTypep() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
         return m_refDTypep ? m_refDTypep : childDTypep();
     }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
@@ -345,13 +346,13 @@ public:
     AstNodeDType* virtRefDType2p() const override { return m_keyDTypep; }
     void virtRefDType2p(AstNodeDType* nodep) override { keyDTypep(nodep); }
     //
-    AstNodeDType* keyDTypep() const VL_MT_SAFE {
+    AstNodeDType* keyDTypep() const VL_MT_STABLE {
         return m_keyDTypep ? m_keyDTypep : keyChildDTypep();
     }
     void keyDTypep(AstNodeDType* nodep) { m_keyDTypep = nodep; }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@@ -423,8 +424,8 @@ public:
         }
     }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return (AstBasicDType*)this; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return (AstBasicDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
@@ -491,13 +492,13 @@ public:
     }
     ASTGEN_MEMBERS_AstBracketArrayDType;
     bool similarDType(const AstNodeDType* samep) const override { V3ERROR_NA_RETURN(false); }
-    AstNodeDType* subDTypep() const override { return childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE { return childDTypep(); }
     // METHODS
     // Will be removed in V3Width, which relies on this
     // being a child not a dtype pointed node
     bool maybePointedTo() const override { return false; }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { V3ERROR_NA_RETURN(0); }
@@ -531,15 +532,15 @@ public:
     void dump(std::ostream& str = std::cout) const override;
     void dumpSmall(std::ostream& str) const override;
     string name() const override;
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return 0; }
     int widthTotalBytes() const override { return 0; }
     AstNodeDType* virtRefDTypep() const override { return nullptr; }
     void virtRefDTypep(AstNodeDType* nodep) override {}
-    AstNodeDType* subDTypep() const override { return nullptr; }
+    AstNodeDType* subDTypep() const override VL_MT_SAFE { return nullptr; }
     AstNodeModule* classOrPackagep() const { return m_classOrPackagep; }
     void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
     AstClass* classp() const { return m_classp; }
@@ -578,13 +579,15 @@ public:
         return skipRefp()->similarDType(samep->skipRefp());
     }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return m_refDTypep ? m_refDTypep : childDTypep();
+    }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return subDTypep()->skipRefp(); }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return subDTypep()->skipRefp(); }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
     int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@@ -625,13 +628,15 @@ public:
         return type() == samep->type() && same(samep);
     }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return dtypep() ? dtypep() : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return dtypep() ? dtypep() : childDTypep();
+    }
     void* containerp() const { return m_containerp; }
     // METHODS
     // op1 = Range of variable
     AstNodeDType* dtypeSkipRefp() const { return dtypep()->skipRefp(); }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return dtypep()->widthAlignBytes(); }
@@ -679,15 +684,15 @@ public:
     string prettyDTypeName() const override;
     void dumpSmall(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
         return m_refDTypep ? m_refDTypep : childDTypep();
     }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@@ -706,13 +711,13 @@ public:
     bool hasDType() const override { return true; }
     bool maybePointedTo() const override { return true; }
     bool undead() const override { return true; }
-    AstNodeDType* subDTypep() const override { return nullptr; }
+    AstNodeDType* subDTypep() const override VL_MT_SAFE { return nullptr; }
     AstNodeDType* virtRefDTypep() const override { return nullptr; }
     void virtRefDTypep(AstNodeDType* nodep) override {}
     bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
     // cppcheck-suppress csyleCast
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
@@ -756,7 +761,9 @@ public:
     }
     bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return m_refDTypep ? m_refDTypep : childDTypep();
+    }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
@@ -765,8 +772,8 @@ public:
     void dump(std::ostream& str = std::cout) const override;
     void dumpSmall(std::ostream& str) const override;
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return subDTypep()->skipRefp(); }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return subDTypep()->skipRefp(); }
     AstNodeDType* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
     // cppcheck-suppress csyleCast
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
@@ -818,8 +825,8 @@ public:
     void dump(std::ostream& str = std::cout) const override;
     void dumpSmall(std::ostream& str) const override;
     void cloneRelink() override;
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
@@ -883,7 +890,9 @@ public:
         if (m_refDTypep && m_refDTypep->clonep()) m_refDTypep = m_refDTypep->clonep();
     }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return m_refDTypep ? m_refDTypep : childDTypep();
+    }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
@@ -891,10 +900,10 @@ public:
     //
     // (Slow) recurse down to find basic data type (Note don't need virtual -
     // AstVar isn't a NodeDType)
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
     // op1 = Range of variable (Note don't need virtual - AstVar isn't a NodeDType)
     AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return subDTypep()->skipRefp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return subDTypep()->skipRefp(); }
     AstNodeDType* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
     AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
     // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
@@ -931,9 +940,11 @@ public:
     ASTGEN_MEMBERS_AstParamTypeDType;
     void dump(std::ostream& str = std::cout) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return dtypep() ? dtypep() : childDTypep(); }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return subDTypep()->skipRefp(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return dtypep() ? dtypep() : childDTypep();
+    }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return subDTypep()->skipRefp(); }
     AstNodeDType* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
     AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
     bool similarDType(const AstNodeDType* samep) const override {
@@ -967,8 +978,8 @@ public:
     AstNodeDType* dtypep() const { return nullptr; }
     // METHODS
     bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return nullptr; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return nullptr; }
     // cppcheck-suppress csyleCast
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
@@ -1022,17 +1033,17 @@ public:
     void dumpSmall(std::ostream& str) const override;
     string prettyDTypeName() const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
         return m_refDTypep ? m_refDTypep : childDTypep();
     }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
-    inline int boundConst() const;
+    inline int boundConst() const VL_MT_STABLE;
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
     // cppcheck-suppress csyleCast
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
@@ -1086,11 +1097,11 @@ public:
     string prettyDTypeName() const override {
         return subDTypep() ? prettyName(subDTypep()->name()) : prettyName();
     }
-    AstBasicDType* basicp() const override VL_MT_SAFE {
+    AstBasicDType* basicp() const override VL_MT_STABLE {
         return subDTypep() ? subDTypep()->basicp() : nullptr;
     }
-    AstNodeDType* subDTypep() const override;
-    AstNodeDType* skipRefp() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE;
+    AstNodeDType* skipRefp() const override VL_MT_STABLE {
         // Skip past both the Ref and the Typedef
         if (subDTypep()) {
             return subDTypep()->skipRefp();
@@ -1119,9 +1130,9 @@ public:
     int widthTotalBytes() const override { return dtypeSkipRefp()->widthTotalBytes(); }
     void name(const string& flag) override { m_name = flag; }
     AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); }
-    AstTypedef* typedefp() const { return m_typedefp; }
+    AstTypedef* typedefp() const VL_MT_SAFE { return m_typedefp; }
     void typedefp(AstTypedef* nodep) { m_typedefp = nodep; }
-    AstNodeDType* refDTypep() const { return m_refDTypep; }
+    AstNodeDType* refDTypep() const VL_MT_SAFE { return m_refDTypep; }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return refDTypep(); }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
@@ -1163,13 +1174,15 @@ public:
     void dumpSmall(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
     // op1 = Range of variable
-    AstNodeDType* subDTypep() const override { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return m_refDTypep ? m_refDTypep : childDTypep();
+    }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); }
@@ -1201,13 +1214,15 @@ public:
     bool similarDType(const AstNodeDType* samep) const override;
     void dumpSmall(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
+        return m_refDTypep ? m_refDTypep : childDTypep();
+    }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@@ -1226,13 +1241,13 @@ public:
     bool hasDType() const override { return true; }
     bool maybePointedTo() const override { return true; }
     bool undead() const override { return true; }
-    AstNodeDType* subDTypep() const override { return nullptr; }
+    AstNodeDType* subDTypep() const override VL_MT_SAFE { return nullptr; }
     AstNodeDType* virtRefDTypep() const override { return nullptr; }
     void virtRefDTypep(AstNodeDType* nodep) override {}
     bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
-    AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
     // cppcheck-suppress csyleCast
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     // cppcheck-suppress csyleCast
@@ -1266,15 +1281,15 @@ public:
     bool similarDType(const AstNodeDType* samep) const override;
     void dumpSmall(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const override VL_MT_SAFE {
+    AstNodeDType* subDTypep() const override VL_MT_STABLE {
         return m_refDTypep ? m_refDTypep : childDTypep();
     }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
     void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
     // METHODS
-    AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); }
-    AstNodeDType* skipRefp() const override VL_MT_SAFE { return (AstNodeDType*)this; }
+    AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
+    AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
     AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
     int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); }
diff --git a/src/V3AstNodeExpr.h b/src/V3AstNodeExpr.h
index eb0820eb4..de4de290c 100644
--- a/src/V3AstNodeExpr.h
+++ b/src/V3AstNodeExpr.h
@@ -644,7 +644,7 @@ public:
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { V3ERROR_NA_RETURN(true); }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); }
+    AstNodeDType* subDTypep() const VL_MT_STABLE { return dtypep() ? dtypep() : childDTypep(); }
 };
 class AstCastParse final : public AstNodeExpr {
     // Cast to appropriate type, where we haven't determined yet what the data type is
@@ -1574,7 +1574,7 @@ public:
     bool cleanOut() const override { V3ERROR_NA_RETURN(""); }
     int instrCount() const override { return widthInstrs(); }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); }
+    AstNodeDType* subDTypep() const VL_MT_STABLE { return dtypep() ? dtypep() : childDTypep(); }
 };
 class AstRand final : public AstNodeExpr {
     // $random/$random(seed) or $urandom/$urandom(seed)
@@ -1972,7 +1972,7 @@ public:
     bool same(const AstNode* /*samep*/) const override { return true; }
     bool cleanOut() const override { return true; }
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); }
+    AstNodeDType* subDTypep() const VL_MT_STABLE { return dtypep() ? dtypep() : childDTypep(); }
 };
 class AstTimePrecision final : public AstNodeExpr {
     // Verilog $timeprecision
diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h
index 7ad7594ee..607f3f52d 100644
--- a/src/V3AstNodeOther.h
+++ b/src/V3AstNodeOther.h
@@ -1544,7 +1544,9 @@ public:
     ASTGEN_MEMBERS_AstTypedef;
     void dump(std::ostream& str) const override;
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); }
+    virtual AstNodeDType* subDTypep() const VL_MT_STABLE {
+        return dtypep() ? dtypep() : childDTypep();
+    }
     // METHODS
     string name() const override { return m_name; }
     bool maybePointedTo() const override { return true; }
@@ -1793,11 +1795,11 @@ public:
     string vlPropDecl(const string& propName) const;  // Return VerilatorVarProps declaration
     void combineType(VVarType type);
     AstNodeDType* getChildDTypep() const override { return childDTypep(); }
-    AstNodeDType* dtypeSkipRefp() const VL_MT_SAFE { return subDTypep()->skipRefp(); }
+    AstNodeDType* dtypeSkipRefp() const VL_MT_STABLE { return subDTypep()->skipRefp(); }
     // (Slow) recurse down to find basic data type (Note don't need virtual -
     // AstVar isn't a NodeDType)
-    AstBasicDType* basicp() const VL_MT_SAFE { return subDTypep()->basicp(); }
-    virtual AstNodeDType* subDTypep() const VL_MT_SAFE {
+    AstBasicDType* basicp() const VL_MT_STABLE { return subDTypep()->basicp(); }
+    virtual AstNodeDType* subDTypep() const VL_MT_STABLE {
         return dtypep() ? dtypep() : childDTypep();
     }
     void ansi(bool flag) { m_ansi = flag; }
@@ -2334,19 +2336,19 @@ public:
     inline AstRange(FileLine* fl, int left, int right);
     inline AstRange(FileLine* fl, const VNumRange& range);
     ASTGEN_MEMBERS_AstRange;
-    inline int leftConst() const VL_MT_SAFE;
-    inline int rightConst() const VL_MT_SAFE;
-    int hiConst() const VL_MT_SAFE {
+    inline int leftConst() const VL_MT_STABLE;
+    inline int rightConst() const VL_MT_STABLE;
+    int hiConst() const VL_MT_STABLE {
         const int l = leftConst();
         const int r = rightConst();
         return l > r ? l : r;
     }
-    int loConst() const VL_MT_SAFE {
+    int loConst() const VL_MT_STABLE {
         const int l = leftConst();
         const int r = rightConst();
         return l > r ? r : l;
     }
-    int elementsConst() const VL_MT_SAFE { return hiConst() - loConst() + 1; }
+    int elementsConst() const VL_MT_STABLE { return hiConst() - loConst() + 1; }
     bool littleEndian() const { return leftConst() < rightConst(); }
     void dump(std::ostream& str) const override;
     virtual string emitC() { V3ERROR_NA_RETURN(""); }
diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp
index 5e59f023e..3d3135014 100644
--- a/src/V3AstNodes.cpp
+++ b/src/V3AstNodes.cpp
@@ -704,12 +704,12 @@ public:
     }
 };
 
-string AstNodeDType::cType(const string& name, bool /*forFunc*/, bool isRef) const VL_MT_SAFE {
+string AstNodeDType::cType(const string& name, bool /*forFunc*/, bool isRef) const VL_MT_STABLE {
     const CTypeRecursed info = cTypeRecurse(false);
     return info.render(name, isRef);
 }
 
-AstNodeDType::CTypeRecursed AstNodeDType::cTypeRecurse(bool compound) const {
+AstNodeDType::CTypeRecursed AstNodeDType::cTypeRecurse(bool compound) const VL_MT_STABLE {
     // Legacy compound argument currently just passed through and unused
     CTypeRecursed info;
 
@@ -846,7 +846,7 @@ int AstNodeDType::widthPow2() const {
     return 1;
 }
 
-bool AstNodeDType::isLiteralType() const VL_MT_SAFE {
+bool AstNodeDType::isLiteralType() const VL_MT_STABLE {
     if (const auto* const dtypep = VN_CAST(skipRefp(), BasicDType)) {
         return dtypep->keyword().isLiteralType();
     } else if (const auto* const dtypep = VN_CAST(skipRefp(), UnpackArrayDType)) {
@@ -1804,7 +1804,7 @@ void AstRefDType::cloneRelink() {
         m_classOrPackagep = m_classOrPackagep->clonep();
     }
 }
-AstNodeDType* AstRefDType::subDTypep() const {
+AstNodeDType* AstRefDType::subDTypep() const VL_MT_STABLE {
     if (typedefp()) return typedefp()->subDTypep();
     return refDTypep();  // Maybe nullptr
 }
diff --git a/src/V3EmitCBase.h b/src/V3EmitCBase.h
index 39ff0e70e..ebb7ed3f4 100644
--- a/src/V3EmitCBase.h
+++ b/src/V3EmitCBase.h
@@ -40,7 +40,7 @@ public:
     EmitCParentModule();
     VL_UNCOPYABLE(EmitCParentModule);
 
-    static const AstNodeModule* get(const AstNode* nodep) {
+    static const AstNodeModule* get(const AstNode* nodep) VL_MT_STABLE {
         return VN_AS(nodep->user4p(), NodeModule);
     }
 };
@@ -70,7 +70,9 @@ public:
     static string protectWordsIf(const string& name, bool doIt) {
         return VIdProtect::protectWordsIf(name, doIt);
     }
-    static string ifNoProtect(const string& in) { return v3Global.opt.protectIds() ? "" : in; }
+    static string ifNoProtect(const string& in) VL_MT_SAFE {
+        return v3Global.opt.protectIds() ? "" : in;
+    }
     static string voidSelfAssign(const AstNodeModule* modp) {
         const string className = prefixNameProtect(modp);
         return className + "* const __restrict vlSelf VL_ATTR_UNUSED = static_cast<" + className
@@ -85,7 +87,7 @@ public:
     static string prefixNameProtect(const AstNode* nodep) {  // C++ name with prefix
         return v3Global.opt.modPrefix() + "_" + protect(nodep->name());
     }
-    static string topClassName() {  // Return name of top wrapper module
+    static string topClassName() VL_MT_SAFE {  // Return name of top wrapper module
         return v3Global.opt.prefix();
     }
 
diff --git a/src/V3Error.h b/src/V3Error.h
index cf0ab5fa6..bb6a3d63c 100644
--- a/src/V3Error.h
+++ b/src/V3Error.h
@@ -648,7 +648,7 @@ inline void v3errorEndFatal(std::ostringstream& sstr)
 // Helper macros for VL_DEFINE_DEBUG_FUNCTIONS
 // Takes an optional "name" (as __VA_ARGS__)
 #define VL_DEFINE_DEBUG(...) \
-    VL_ATTR_UNUSED static int debug##__VA_ARGS__() { \
+    VL_ATTR_UNUSED static int debug##__VA_ARGS__() VL_MT_SAFE { \
         static int level = -1; \
         if (VL_UNLIKELY(level < 0)) { \
             std::string tag{VL_STRINGIFY(__VA_ARGS__)}; \
diff --git a/src/V3File.cpp b/src/V3File.cpp
index 0921f7956..6ae1507e0 100644
--- a/src/V3File.cpp
+++ b/src/V3File.cpp
@@ -853,7 +853,8 @@ void V3OutFormatter::putcNoTracking(char chr) {
     putcOutput(chr);
 }
 
-string V3OutFormatter::quoteNameControls(const string& namein, V3OutFormatter::Language lang) {
+string V3OutFormatter::quoteNameControls(const string& namein,
+                                         V3OutFormatter::Language lang) VL_PURE {
     // Encode control chars into output-appropriate escapes
     // Reverse is V3Parse::deQuote
     string out;
diff --git a/src/V3File.h b/src/V3File.h
index fcee430f8..2c1d34850 100644
--- a/src/V3File.h
+++ b/src/V3File.h
@@ -39,7 +39,7 @@ public:
         addSrcDepend(filename);
         return new_ifstream_nodepend(filename);
     }
-    static std::ifstream* new_ifstream_nodepend(const string& filename) {
+    static std::ifstream* new_ifstream_nodepend(const string& filename) VL_MT_SAFE {
         return new std::ifstream{filename.c_str()};
     }
     static std::ofstream* new_ofstream(const string& filename, bool append = false) {
@@ -171,7 +171,7 @@ public:
     // STATIC METHODS
     static string indentSpaces(int num);
     // Add escaped characters to strings
-    static string quoteNameControls(const string& namein, Language lang = LA_C);
+    static string quoteNameControls(const string& namein, Language lang = LA_C) VL_PURE;
     static bool tokenMatch(const char* cp, const char* cmp);
     static bool tokenNotStart(const char* cp);  // Import/export meaning no endfunction
     static bool tokenStart(const char* cp);
diff --git a/src/V3FileLine.cpp b/src/V3FileLine.cpp
index 80c2d1a85..8f7362b38 100644
--- a/src/V3FileLine.cpp
+++ b/src/V3FileLine.cpp
@@ -39,7 +39,7 @@ VL_DEFINE_DEBUG_FUNCTIONS;
 //######################################################################
 // FileLineSingleton class functions
 
-string FileLineSingleton::filenameLetters(fileNameIdx_t fileno) {
+string FileLineSingleton::filenameLetters(fileNameIdx_t fileno) VL_PURE {
     constexpr int size
         = 1 + (64 / 4);  // Each letter retires more than 4 bits of a > 64 bit number
     char out[size];
diff --git a/src/V3FileLine.h b/src/V3FileLine.h
index 42c72f25b..96a52526c 100644
--- a/src/V3FileLine.h
+++ b/src/V3FileLine.h
@@ -64,7 +64,7 @@ class FileLineSingleton final {
     ~FileLineSingleton() = default;
 
     fileNameIdx_t nameToNumber(const string& filename);
-    string numberToName(fileNameIdx_t filenameno) const { return m_names[filenameno]; }
+    string numberToName(fileNameIdx_t filenameno) const VL_MT_SAFE { return m_names[filenameno]; }
     V3LangCode numberToLang(fileNameIdx_t filenameno) const { return m_languages[filenameno]; }
     void numberToLang(fileNameIdx_t filenameno, const V3LangCode& l) {
         m_languages[filenameno] = l;
@@ -75,7 +75,7 @@ class FileLineSingleton final {
         m_languages.clear();
     }
     void fileNameNumMapDumpXml(std::ostream& os);
-    static string filenameLetters(fileNameIdx_t fileno);
+    static string filenameLetters(fileNameIdx_t fileno) VL_PURE;
 
     // Add given bitset to the interned bitsets, return interned index
     msgEnSetIdx_t addMsgEnBitSet(const MsgEnBitSet& bitSet);
@@ -159,7 +159,7 @@ protected:
 
 private:
     // CONSTRUCTORS
-    static FileLineSingleton& singleton() {
+    static FileLineSingleton& singleton() VL_MT_SAFE {
         static FileLineSingleton s;
         return s;
     }
@@ -242,7 +242,7 @@ public:
     string prettySource() const VL_MT_SAFE;  // Source, w/stripped unprintables and newlines
     FileLine* parent() const VL_MT_SAFE { return m_parent; }
     V3LangCode language() const { return singleton().numberToLang(filenameno()); }
-    string ascii() const;
+    string ascii() const VL_MT_SAFE;
     string asciiLineCol() const;
     int filenameno() const VL_MT_SAFE { return m_filenameno; }
     string filename() const VL_MT_SAFE { return singleton().numberToName(filenameno()); }
@@ -270,7 +270,7 @@ public:
     }
     void warnOff(V3ErrorCode code, bool flag) { warnOn(code, !flag); }
     bool warnOff(const string& msg, bool flag);  // Returns 1 if ok
-    bool warnIsOff(V3ErrorCode code) const;
+    bool warnIsOff(V3ErrorCode code) const VL_MT_SAFE;
     void warnLintOff(bool flag);
     void warnStyleOff(bool flag);
     void warnUnusedOff(bool flag);
@@ -362,7 +362,7 @@ public:
 private:
     string warnContext() const;
     string warnContextParent() const VL_REQUIRES(V3Error::s().m_mutex);
-    const MsgEnBitSet& msgEn() const VL_MT_SAFE { return singleton().msgEn(m_msgEnIdx); }
+    const MsgEnBitSet& msgEn() const { return singleton().msgEn(m_msgEnIdx); }
 };
 std::ostream& operator<<(std::ostream& os, FileLine* fileline);
 
diff --git a/src/V3Global.h b/src/V3Global.h
index 228440e3a..0537f534c 100644
--- a/src/V3Global.h
+++ b/src/V3Global.h
@@ -143,7 +143,7 @@ public:
     void widthMinUsage(const VWidthMinUsage& flag) { m_widthMinUsage = flag; }
     bool constRemoveXs() const { return m_constRemoveXs; }
     void constRemoveXs(bool flag) { m_constRemoveXs = flag; }
-    string debugFilename(const string& nameComment, int newNumber = 0);
+    string debugFilename(const string& nameComment, int newNumber = 0) VL_MT_SAFE;
     static string digitsFilename(int number);
     bool needTraceDumper() const { return m_needTraceDumper; }
     void needTraceDumper(bool flag) { m_needTraceDumper = flag; }
diff --git a/src/V3Hash.cpp b/src/V3Hash.cpp
index 5fd2d2751..bff44cdf1 100644
--- a/src/V3Hash.cpp
+++ b/src/V3Hash.cpp
@@ -24,7 +24,7 @@
 V3Hash::V3Hash(const std::string& val)
     : m_value{static_cast<uint32_t>(std::hash<std::string>{}(val))} {}
 
-std::ostream& operator<<(std::ostream& os, const V3Hash& rhs) {
+std::ostream& operator<<(std::ostream& os, const V3Hash& rhs) VL_MT_SAFE {
     return os << 'h' << std::hex << std::setw(8) << std::setfill('0') << rhs.value();
 }
 
diff --git a/src/V3Hash.h b/src/V3Hash.h
index 7cdfb8749..7e75045ef 100644
--- a/src/V3Hash.h
+++ b/src/V3Hash.h
@@ -69,7 +69,7 @@ public:
     }
 };
 
-std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);
+std::ostream& operator<<(std::ostream& os, const V3Hash& rhs) VL_MT_SAFE;
 
 template <>
 struct std::hash<V3Hash> {
diff --git a/src/V3Number.cpp b/src/V3Number.cpp
index b99717d60..a74d7a64d 100644
--- a/src/V3Number.cpp
+++ b/src/V3Number.cpp
@@ -598,17 +598,17 @@ bool V3Number::displayedFmtLegal(char format, bool isScan) {
     }
 }
 
-string V3Number::displayPad(size_t fmtsize, char pad, bool left, const string& in) {
+string V3Number::displayPad(size_t fmtsize, char pad, bool left, const string& in) VL_PURE {
     string padding;
     if (in.length() < fmtsize) padding = string(fmtsize - in.length(), pad);
     return left ? (in + padding) : (padding + in);
 }
 
-string V3Number::displayed(AstNode* nodep, const string& vformat) const {
+string V3Number::displayed(AstNode* nodep, const string& vformat) const VL_MT_SAFE {
     return displayed(nodep->fileline(), vformat);
 }
 
-string V3Number::displayed(FileLine* fl, const string& vformat) const {
+string V3Number::displayed(FileLine* fl, const string& vformat) const VL_MT_SAFE {
     auto pos = vformat.cbegin();
     UASSERT(pos != vformat.cend() && pos[0] == '%',
             "$display-like function with non format argument " << *this);
@@ -913,7 +913,7 @@ uint32_t V3Number::toUInt() const VL_MT_SAFE {
     return m_data.num()[0].m_value;
 }
 
-double V3Number::toDouble() const {
+double V3Number::toDouble() const VL_MT_SAFE {
     if (VL_UNCOVERABLE(!isDouble() || width() != 64)) {
         v3fatalSrc("Real operation on wrong sized/non-real number");
     }
@@ -926,7 +926,7 @@ double V3Number::toDouble() const {
     return u.d;
 }
 
-int32_t V3Number::toSInt() const {
+int32_t V3Number::toSInt() const VL_MT_SAFE {
     if (isSigned()) {
         const uint32_t v = toUInt();
         const uint32_t signExtend = (-(v & (1UL << (width() - 1))));
@@ -996,14 +996,14 @@ uint8_t V3Number::dataByte(int byte) const {
     return (edataWord(byte / (VL_EDATASIZE / 8)) >> ((byte * 8) % VL_EDATASIZE)) & 0xff;
 }
 
-bool V3Number::isAllZ() const {
+bool V3Number::isAllZ() const VL_MT_SAFE {
     if (isDouble() || isString()) return false;
     for (int i = 0; i < width(); i++) {
         if (!bitIsZ(i)) return false;
     }
     return true;
 }
-bool V3Number::isAllX() const {
+bool V3Number::isAllX() const VL_MT_SAFE {
     if (isDouble() || isString()) return false;
     uint32_t mask = hiWordMask();
     for (int i = words() - 1; i >= 0; --i) {
@@ -1057,7 +1057,7 @@ bool V3Number::isFourState() const {
     }
     return false;
 }
-bool V3Number::isAnyX() const {
+bool V3Number::isAnyX() const VL_MT_SAFE {
     if (isDouble() || isString()) return false;
     for (int bit = 0; bit < width(); bit++) {
         if (bitIsX(bit)) return true;
@@ -1065,7 +1065,7 @@ bool V3Number::isAnyX() const {
     return false;
 }
 bool V3Number::isAnyXZ() const { return isAnyX() || isAnyZ(); }
-bool V3Number::isAnyZ() const {
+bool V3Number::isAnyZ() const VL_MT_SAFE {
     if (isDouble() || isString()) return false;
     for (int bit = 0; bit < width(); bit++) {
         if (bitIsZ(bit)) return true;
@@ -1082,7 +1082,7 @@ bool V3Number::isLtXZ(const V3Number& rhs) const {
     }
     return false;
 }
-int V3Number::countX(int lsb, int nbits) const {
+int V3Number::countX(int lsb, int nbits) const VL_MT_SAFE {
     int count = 0;
     for (int bitn = 0; bitn < nbits; ++bitn) {
         if (lsb + bitn >= width()) return count;
@@ -1090,7 +1090,7 @@ int V3Number::countX(int lsb, int nbits) const {
     }
     return count;
 }
-int V3Number::countZ(int lsb, int nbits) const {
+int V3Number::countZ(int lsb, int nbits) const VL_MT_SAFE {
     int count = 0;
     for (int bitn = 0; bitn < nbits; ++bitn) {
         if (lsb + bitn >= width()) return count;
diff --git a/src/V3Number.h b/src/V3Number.h
index 25b59706a..2afc9354f 100644
--- a/src/V3Number.h
+++ b/src/V3Number.h
@@ -63,7 +63,7 @@ public:
         DOUBLE = 2,
         STRING = 3,
     };
-    friend std::ostream& operator<<(std::ostream& os, const V3NumberDataType& rhs) {
+    friend std::ostream& operator<<(std::ostream& os, const V3NumberDataType& rhs) VL_MT_SAFE {
         switch (rhs) {
         case V3NumberDataType::UNINITIALIZED: return os << "UNINITIALIZED";
         case V3NumberDataType::LOGIC: return os << "LOGIC";
@@ -210,7 +210,7 @@ public:
         UASSERT(isString(), "`str` member accessed when data type is " << m_type);
         return m_string;
     }
-    const std::string& str() const VL_MT_SAFE {
+    const std::string& str() const {
         UASSERT(isString(), "`str` member accessed when data type is " << m_type);
         return m_string;
     }
@@ -383,7 +383,7 @@ public:
     }
 
 private:
-    char bitIs(int bit) const VL_MT_SAFE {
+    char bitIs(int bit) const {
         if (bit >= m_data.width() || bit < 0) {
             // We never sign extend
             return '0';
@@ -559,7 +559,7 @@ private:
             m_data.m_sized = false;
         }
     }
-    static string displayPad(size_t fmtsize, char pad, bool left, const string& in);
+    static string displayPad(size_t fmtsize, char pad, bool left, const string& in) VL_PURE;
     string displayed(FileLine* fl, const string& vformat) const VL_MT_SAFE;
     string displayed(const string& vformat) const VL_MT_SAFE {
         return displayed(m_fileline, vformat);
@@ -583,8 +583,8 @@ public:
     V3Number& setMask(int nbits);  // IE if nbits=1, then 0b1, if 2->0b11, if 3->0b111 etc
 
     // ACCESSORS
-    string ascii(bool prefixed = true, bool cleanVerilog = false) const VL_MT_SAFE;
-    string displayed(AstNode* nodep, const string& vformat) const;
+    string ascii(bool prefixed = true, bool cleanVerilog = false) const;
+    string displayed(AstNode* nodep, const string& vformat) const VL_MT_SAFE;
     static bool displayedFmtLegal(char format, bool isScan);  // Is this a valid format letter?
     int width() const VL_MT_SAFE { return m_data.width(); }
     int widthMin() const;  // Minimum width that can represent this number (~== log2(num)+1)
@@ -612,10 +612,10 @@ public:
         return m_data.type() == V3NumberDataType::LOGIC
                || m_data.type() == V3NumberDataType::DOUBLE;
     }
-    bool isNegative() const VL_MT_SAFE { return !isString() && bitIs1(width() - 1); }
+    bool isNegative() const { return !isString() && bitIs1(width() - 1); }
     bool is1Step() const VL_MT_SAFE { return m_data.m_is1Step; }
     bool isNull() const VL_MT_SAFE { return m_data.m_isNull; }
-    bool isFourState() const VL_MT_SAFE;
+    bool isFourState() const;
     bool hasZ() const {
         if (isString()) return false;
         for (int i = 0; i < words(); i++) {
@@ -626,7 +626,7 @@ public:
     }
     bool isAllZ() const VL_MT_SAFE;
     bool isAllX() const VL_MT_SAFE;
-    bool isEqZero() const VL_MT_SAFE;
+    bool isEqZero() const;
     bool isNeqZero() const;
     bool isBitsZero(int msb, int lsb) const;
     bool isEqOne() const;
@@ -637,13 +637,13 @@ public:
     bool isAnyXZ() const;
     bool isAnyZ() const VL_MT_SAFE;
     bool isMsbXZ() const { return bitIsXZ(m_data.width() - 1); }
-    uint32_t toUInt() const;
+    uint32_t toUInt() const VL_MT_SAFE;
     int32_t toSInt() const VL_MT_SAFE;
-    uint64_t toUQuad() const;
+    uint64_t toUQuad() const VL_MT_SAFE;
     int64_t toSQuad() const VL_MT_SAFE;
     string toString() const VL_MT_SAFE;
-    string toDecimalS() const VL_MT_SAFE;  // return ASCII signed decimal number
-    string toDecimalU() const VL_MT_SAFE;  // return ASCII unsigned decimal number
+    string toDecimalS() const;  // return ASCII signed decimal number
+    string toDecimalU() const;  // return ASCII unsigned decimal number
     double toDouble() const VL_MT_SAFE;
     V3Hash toHash() const;
     uint32_t edataWord(int eword) const;
@@ -777,7 +777,7 @@ public:
     V3Number& opLtN(const V3Number& lhs, const V3Number& rhs);
     V3Number& opLteN(const V3Number& lhs, const V3Number& rhs);
 };
-inline std::ostream& operator<<(std::ostream& os, const V3Number& rhs) {
+inline std::ostream& operator<<(std::ostream& os, const V3Number& rhs) VL_MT_SAFE {
     return os << rhs.ascii();
 }
 
diff --git a/src/V3Options.cpp b/src/V3Options.cpp
index 076fff117..96996d58c 100644
--- a/src/V3Options.cpp
+++ b/src/V3Options.cpp
@@ -874,7 +874,7 @@ void V3Options::notify() {
 //######################################################################
 // V3 Options accessors
 
-string V3Options::version() {
+string V3Options::version() VL_PURE {
     string ver = DTVERSION;
     ver += " rev " + cvtToStr(DTVERSION_rev);
     return ver;
@@ -1938,7 +1938,7 @@ unsigned V3Options::dumpLevel(const string& tag) const VL_MT_SAFE {
     return iter != m_dumpLevel.end() ? iter->second : 0;
 }
 
-unsigned V3Options::dumpSrcLevel(const string& srcfile_path) const VL_MT_SAFE {
+unsigned V3Options::dumpSrcLevel(const string& srcfile_path) const {
     // For simplicity, calling functions can just use __FILE__ for srcfile.
     // That means we need to strip the filenames: ../Foo.cpp -> Foo
     return dumpLevel(V3Os::filenameNonDirExt(srcfile_path));
diff --git a/src/V3Options.h b/src/V3Options.h
index 12b261003..26a41f712 100644
--- a/src/V3Options.h
+++ b/src/V3Options.h
@@ -407,7 +407,7 @@ public:
     unsigned debugLevel(const string& tag) const VL_MT_SAFE;
     unsigned debugSrcLevel(const string& srcfile_path) const VL_MT_SAFE;
     unsigned dumpLevel(const string& tag) const VL_MT_SAFE;
-    unsigned dumpSrcLevel(const string& srcfile_path) const VL_MT_SAFE;
+    unsigned dumpSrcLevel(const string& srcfile_path) const;
 
     // METHODS
     void addCppFile(const string& filename);
@@ -650,7 +650,7 @@ public:
     }
 
     // METHODS (from main)
-    static string version();
+    static string version() VL_PURE;
     static string argString(int argc, char** argv);  ///< Return list of arguments as simple string
     string allArgsString() const VL_MT_SAFE;  ///< Return all passed arguments as simple string
     // Return options for child hierarchical blocks when forTop==false, otherwise returns args for
diff --git a/src/V3Os.cpp b/src/V3Os.cpp
index a18dd6c2f..7a4722839 100644
--- a/src/V3Os.cpp
+++ b/src/V3Os.cpp
@@ -142,7 +142,7 @@ string V3Os::filenameDir(const string& filename) {
     }
 }
 
-string V3Os::filenameNonDir(const string& filename) {
+string V3Os::filenameNonDir(const string& filename) VL_PURE {
     string::size_type pos;
     if ((pos = filename.rfind('/')) != string::npos) {
         return filename.substr(pos + 1);
@@ -151,7 +151,7 @@ string V3Os::filenameNonDir(const string& filename) {
     }
 }
 
-string V3Os::filenameNonExt(const string& filename) {
+string V3Os::filenameNonExt(const string& filename) VL_PURE {
     string base = filenameNonDir(filename);
     string::size_type pos;
     if ((pos = base.find('.')) != string::npos) base.erase(pos);
diff --git a/src/V3Os.h b/src/V3Os.h
index 6b73aa3b5..4300417fd 100644
--- a/src/V3Os.h
+++ b/src/V3Os.h
@@ -37,10 +37,11 @@ public:
     // METHODS (generic filename utilities)
     static string filenameFromDirBase(const string& dir, const string& basename);
     /// Return non-directory part of filename
-    static string filenameNonDir(const string& filename);
+    static string filenameNonDir(const string& filename) VL_PURE;
     /// Return non-extensioned (no .) part of filename
-    static string filenameNonExt(const string& filename);
-    static string filenameNonDirExt(const string& filename) {  ///< Return basename of filename
+    static string filenameNonExt(const string& filename) VL_PURE;
+    ///< Return basename of filename
+    static string filenameNonDirExt(const string& filename) VL_PURE {
         return filenameNonExt(filenameNonDir(filename));
     }
     static string filenameDir(const string& filename);  ///< Return directory part of filename
diff --git a/src/V3String.cpp b/src/V3String.cpp
index f0aa6ecc8..b97a84b26 100644
--- a/src/V3String.cpp
+++ b/src/V3String.cpp
@@ -36,7 +36,7 @@ std::map<string, string> VName::s_dehashMap;
 // Wildcard
 
 // Double procedures, inlined, unrolls loop much better
-bool VString::wildmatchi(const char* s, const char* p) {
+bool VString::wildmatchi(const char* s, const char* p) VL_PURE {
     for (; *p; s++, p++) {
         if (*p != '*') {
             if (((*s) != (*p)) && *p != '?') return false;
@@ -52,7 +52,7 @@ bool VString::wildmatchi(const char* s, const char* p) {
     return (*s == '\0');
 }
 
-bool VString::wildmatch(const char* s, const char* p) {
+bool VString::wildmatch(const char* s, const char* p) VL_PURE {
     for (; *p; s++, p++) {
         if (*p != '*') {
             if (((*s) != (*p)) && *p != '?') return false;
@@ -68,7 +68,7 @@ bool VString::wildmatch(const char* s, const char* p) {
     return (*s == '\0');
 }
 
-bool VString::wildmatch(const string& s, const string& p) {
+bool VString::wildmatch(const string& s, const string& p) VL_PURE {
     return wildmatch(s.c_str(), p.c_str());
 }
 
@@ -130,7 +130,7 @@ string VString::escapeStringForPath(const string& str) {
     return result;
 }
 
-string VString::spaceUnprintable(const string& str) {
+string VString::spaceUnprintable(const string& str) VL_PURE {
     string out;
     for (const char c : str) {
         if (std::isprint(c)) {
@@ -216,10 +216,12 @@ static const uint32_t sha256K[]
        0xc67178f2};
 
 VL_ATTR_ALWINLINE
-static uint32_t shaRotr32(uint32_t lhs, uint32_t rhs) { return lhs >> rhs | lhs << (32 - rhs); }
+static uint32_t shaRotr32(uint32_t lhs, uint32_t rhs) VL_PURE {
+    return lhs >> rhs | lhs << (32 - rhs);
+}
 
 VL_ATTR_ALWINLINE
-static void sha256Block(uint32_t* h, const uint32_t* chunk) {
+static void sha256Block(uint32_t* h, const uint32_t* chunk) VL_PURE {
     uint32_t ah[8];
     const uint32_t* p = chunk;
 
diff --git a/src/V3String.h b/src/V3String.h
index bbd3ba948..d56589c5e 100644
--- a/src/V3String.h
+++ b/src/V3String.h
@@ -34,13 +34,14 @@
 // Global string-related functions
 
 template <class T>
-std::string cvtToStr(const T& t) {
+std::string cvtToStr(const T& t) VL_PURE {
     std::ostringstream os;
     os << t;
     return os.str();
 }
 template <class T>
-typename std::enable_if<std::is_pointer<T>::value, std::string>::type cvtToHex(const T tp) {
+typename std::enable_if<std::is_pointer<T>::value, std::string>::type
+cvtToHex(const T tp) VL_PURE {
     std::ostringstream os;
     os << static_cast<const void*>(tp);
     return os.str();
@@ -78,14 +79,14 @@ inline string ucfirst(const string& text) {
 // VString - String manipulation
 
 class VString final {
-    static bool wildmatchi(const char* s, const char* p);
+    static bool wildmatchi(const char* s, const char* p) VL_PURE;
 
 public:
     // METHODS (generic string utilities)
     // Return true if p with ? or *'s matches s
-    static bool wildmatch(const char* s, const char* p);
+    static bool wildmatch(const char* s, const char* p) VL_PURE;
     // Return true if p with ? or *'s matches s
-    static bool wildmatch(const string& s, const string& p);
+    static bool wildmatch(const string& s, const string& p) VL_PURE;
     // Return {a}{dot}{b}, omitting dot if a or b are empty
     static string dot(const string& a, const string& dot, const string& b);
     // Convert string to lowercase (tolower)
@@ -107,7 +108,7 @@ public:
     static string quoteStringLiteralForShell(const string& str);
     // Replace any unprintable with space
     // This includes removing tabs, so column tracking is correct
-    static string spaceUnprintable(const string& str);
+    static string spaceUnprintable(const string& str) VL_PURE;
     // Remove any whitespace
     static string removeWhitespace(const string& str);
     // Return true if only whitespace or ""
diff --git a/src/astgen b/src/astgen
index 95d609df7..9c30529f7 100755
--- a/src/astgen
+++ b/src/astgen
@@ -865,7 +865,7 @@ def write_type_enum(prefix, nodeList):
         fh.write("        _BOUNDS_END\n")
         fh.write("    };\n")
 
-        fh.write("    const char* ascii() const {\n")
+        fh.write("    const char* ascii() const VL_MT_SAFE {\n")
         fh.write("        static const char* const names[_ENUM_END + 1] = {\n")
         for node in sorted(filter(lambda _: _.isLeaf, nodeList),
                            key=lambda _: _.typeId):
@@ -931,7 +931,7 @@ def write_ast_macros(filename):
             static Ast{t}* cloneTreeNull(Ast{t}* nodep, bool cloneNextLink) {{
                 return nodep ? nodep->cloneTree(cloneNextLink) : nullptr;
             }}
-            Ast{t}* clonep() const VL_MT_SAFE {{ return static_cast<Ast{t}*>(AstNode::clonep()); }}
+            Ast{t}* clonep() const {{ return static_cast<Ast{t}*>(AstNode::clonep()); }}
             Ast{t}* addNext(Ast{t}* nodep) {{ return static_cast<Ast{t}*>(AstNode::addNext(this, nodep)); }}
             ''',
                       t=node.name)
@@ -952,7 +952,7 @@ def write_ast_macros(filename):
                             "op{n}p()").format(n=n, kind=kind)
                 if monad == "List":
                     emitBlock('''\
-                    Ast{kind}* {name}() const VL_MT_SAFE {{ return {retrieve}; }}
+                    Ast{kind}* {name}() const VL_MT_STABLE {{ return {retrieve}; }}
                     void add{Name}(Ast{kind}* nodep) {{ addNOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
                     ''',
                               kind=kind,
@@ -962,7 +962,7 @@ def write_ast_macros(filename):
                               retrieve=retrieve)
                 elif monad == "Optional":
                     emitBlock('''\
-                    Ast{kind}* {name}() const VL_MT_SAFE {{ return {retrieve}; }}
+                    Ast{kind}* {name}() const VL_MT_STABLE {{ return {retrieve}; }}
                     void {name}(Ast{kind}* nodep) {{ setNOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
                     ''',
                               kind=kind,
@@ -971,7 +971,7 @@ def write_ast_macros(filename):
                               retrieve=retrieve)
                 else:
                     emitBlock('''\
-                    Ast{kind}* {name}() const VL_MT_SAFE {{ return {retrieve}; }}
+                    Ast{kind}* {name}() const VL_MT_STABLE {{ return {retrieve}; }}
                     void {name}(Ast{kind}* nodep) {{ setOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
                     ''',
                               kind=kind,
diff --git a/test_regress/t/t_a5_attributes_src.pl b/test_regress/t/t_a5_attributes_src.pl
index 92a4ca5d6..01c750bdf 100755
--- a/test_regress/t/t_a5_attributes_src.pl
+++ b/test_regress/t/t_a5_attributes_src.pl
@@ -36,7 +36,7 @@ sub check {
             tee => 1,
             cmd => ["python3", "$root/nodist/clang_check_attributes --verilator-root=$root --cxxflags='$clang_args' $precompile_args $srcfiles_str"]);
 
-        file_grep($Self->{run_log_filename}, "Number of functions reported unsafe: 27");
+        file_grep($Self->{run_log_filename}, "Number of functions reported unsafe: 0");
     }
 
     run_clang_check();