Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

Add VL_MT_SAFE attribute to several functions. (#3729)

Browse Source
This commit is contained in:
Kamil Rakoczy 2023-03-17 00:48:56 +01:00 committed by GitHub
parent b2ced6ff1d
commit bbf53bd5af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 279 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/verilatedos.h
View File

@ -160,6 +160,13 @@
#else #else
# define VL_MT_SAFE # define VL_MT_SAFE
#endif #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 // Comment tag that function is threadsafe, only
// during normal operation (post-init) // during normal operation (post-init)
#if defined(__clang__) #if defined(__clang__)

39
nodist/clang_check_attributes
View File

@ -37,6 +37,7 @@ def fully_qualified_name(node):
class VlAnnotations: class VlAnnotations:
mt_start: bool = False mt_start: bool = False
mt_safe: bool = False mt_safe: bool = False
stable_tree: bool = False
mt_safe_postinit: bool = False mt_safe_postinit: bool = False
mt_unsafe: bool = False mt_unsafe: bool = False
mt_unsafe_one: bool = False mt_unsafe_one: bool = False
@ -54,6 +55,9 @@ class VlAnnotations:
def is_pure_context(self): def is_pure_context(self):
return self.pure return self.pure
def is_stabe_tree_context(self):
return self.stable_tree
def is_mt_unsafe_call(self): def is_mt_unsafe_call(self):
return self.mt_unsafe or self.mt_unsafe_one return self.mt_unsafe or self.mt_unsafe_one
@ -66,6 +70,9 @@ class VlAnnotations:
def is_pure_call(self): def is_pure_call(self):
return self.pure return self.pure
def is_stabe_tree_call(self):
return self.stable_tree
def __or__(self, other: "VlAnnotations"): def __or__(self, other: "VlAnnotations"):
result = VlAnnotations() result = VlAnnotations()
for key, value in dataclasses.asdict(self).items(): for key, value in dataclasses.asdict(self).items():
@ -94,6 +101,8 @@ class VlAnnotations:
result.mt_start = True result.mt_start = True
elif node.displayname == "MT_SAFE": elif node.displayname == "MT_SAFE":
result.mt_safe = True result.mt_safe = True
elif node.displayname == "MT_STABLE":
result.stable_tree = True
elif node.displayname == "MT_SAFE_POSTINIT": elif node.displayname == "MT_SAFE_POSTINIT":
result.mt_safe_postinit = True result.mt_safe_postinit = True
elif node.displayname == "MT_UNSAFE": elif node.displayname == "MT_UNSAFE":
@ -196,6 +205,7 @@ class DiagnosticKind(Enum):
ANNOTATIONS_DEF_DECL_MISMATCH = enum.auto() ANNOTATIONS_DEF_DECL_MISMATCH = enum.auto()
NON_PURE_CALL_IN_PURE_CTX = enum.auto() NON_PURE_CALL_IN_PURE_CTX = enum.auto()
NON_MT_SAFE_CALL_IN_MT_SAFE_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): def __lt__(self, other):
return self.value < other.value return self.value < other.value
@ -377,6 +387,16 @@ class CallAnnotationsValidator:
FunctionInfo.from_node(refd, refd, annotations), FunctionInfo.from_node(refd, refd, annotations),
DiagnosticKind.NON_MT_SAFE_CALL_IN_MT_SAFE_CTX) 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 ctx.is_pure_context():
if not annotations.is_pure_call(): if not annotations.is_pure_call():
self.emit_diagnostic( self.emit_diagnostic(
@ -394,6 +414,16 @@ class CallAnnotationsValidator:
self.emit_diagnostic( self.emit_diagnostic(
FunctionInfo.from_node(refd, refd, annotations), FunctionInfo.from_node(refd, refd, annotations),
DiagnosticKind.NON_MT_SAFE_CALL_IN_MT_SAFE_CTX) 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 # pure context
if ctx.is_pure_context(): if ctx.is_pure_context():
if not annotations.is_pure_call(): if not annotations.is_pure_call():
@ -414,6 +444,13 @@ class CallAnnotationsValidator:
self.dispatch_node_inside_definition) self.dispatch_node_inside_definition)
self._constructor_context -= 1 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 # pure context
if ctx.is_pure_context(): if ctx.is_pure_context():
if not annotations.is_pure_call( if not annotations.is_pure_call(
@ -788,6 +825,8 @@ class TopDownSummaryPrinter():
name += "is mtsafe but calls non-mtsafe function(s)" name += "is mtsafe but calls non-mtsafe function(s)"
elif func.reason == DiagnosticKind.NON_PURE_CALL_IN_PURE_CTX: elif func.reason == DiagnosticKind.NON_PURE_CALL_IN_PURE_CTX:
name += "is pure but calls non-pure function(s)" 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: else:
name += "for unknown reason (please add description)" name += "for unknown reason (please add description)"

4
src/V3Ast.cpp
View File

@ -155,7 +155,7 @@ string AstNode::vcdName(const string& namein) {
return prettyName(pretty); 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 // This function is somewhat hot, so we short-circuit some compares
string pretty; string pretty;
pretty.reserve(namein.length()); pretty.reserve(namein.length());
@ -1079,7 +1079,7 @@ bool AstNode::sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ig
//====================================================================== //======================================================================
// Debugging // Debugging
void AstNode::checkTreeIter(const AstNode* prevBackp) const { void AstNode::checkTreeIter(const AstNode* prevBackp) const VL_MT_STABLE {
// private: Check a tree and children // private: Check a tree and children
UASSERT_OBJ(prevBackp == this->backp(), this, "Back node inconsistent"); UASSERT_OBJ(prevBackp == this->backp(), this, "Back node inconsistent");
switch (this->type()) { switch (this->type()) {

68
src/V3Ast.h
View File

@ -102,11 +102,11 @@ public:
: m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning : m_e(static_cast<en>(_e)) {} // Need () or GCC 4.8 false warning
constexpr operator en() const VL_MT_SAFE { return m_e; } 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; return lhs.m_e == rhs.m_e;
} }
constexpr bool operator==(const VNType& lhs, VNType::en rhs) { return lhs.m_e == rhs; } 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) { return lhs == rhs.m_e; } 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(); } inline std::ostream& operator<<(std::ostream& os, const VNType& rhs) { return os << rhs.ascii(); }
// ###################################################################### // ######################################################################
@ -1545,7 +1545,7 @@ class AstNode VL_NOT_FINAL {
private: private:
AstNode* cloneTreeIter(); AstNode* cloneTreeIter();
AstNode* cloneTreeIterList(); AstNode* cloneTreeIterList();
void checkTreeIter(const AstNode* prevBackp) const VL_MT_SAFE; void checkTreeIter(const AstNode* prevBackp) const VL_MT_STABLE;
bool gateTreeIter() const; bool gateTreeIter() const;
static bool sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext, static bool sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext,
bool gateOnly); bool gateOnly);
@ -1601,14 +1601,14 @@ public:
// ACCESSORS // ACCESSORS
VNType type() const VL_MT_SAFE { return m_type; } VNType type() const VL_MT_SAFE { return m_type; }
const char* typeName() const VL_MT_SAFE { return type().ascii(); } // See also prettyTypeName const char* typeName() const VL_MT_SAFE { return type().ascii(); } // See also prettyTypeName
AstNode* nextp() const VL_MT_SAFE { return m_nextp; } AstNode* nextp() const VL_MT_STABLE { return m_nextp; }
AstNode* backp() const VL_MT_SAFE { return m_backp; } AstNode* backp() const VL_MT_STABLE { return m_backp; }
AstNode* abovep() const; // Parent node above, only when no nextp() as otherwise slow AstNode* abovep() const; // Parent node above, only when no nextp() as otherwise slow
AstNode* op1p() const VL_MT_SAFE { return m_op1p; } AstNode* op1p() const VL_MT_STABLE { return m_op1p; }
AstNode* op2p() const VL_MT_SAFE { return m_op2p; } AstNode* op2p() const VL_MT_STABLE { return m_op2p; }
AstNode* op3p() const VL_MT_SAFE { return m_op3p; } AstNode* op3p() const VL_MT_STABLE { return m_op3p; }
AstNode* op4p() const VL_MT_SAFE { return m_op4p; } AstNode* op4p() const VL_MT_STABLE { return m_op4p; }
AstNodeDType* dtypep() const VL_MT_SAFE { return m_dtypep; } AstNodeDType* dtypep() const VL_MT_STABLE { return m_dtypep; }
AstNode* clonep() const { return ((m_cloneCnt == s_cloneCntGbl) ? m_clonep : nullptr); } AstNode* clonep() const { return ((m_cloneCnt == s_cloneCntGbl) ? m_clonep : nullptr); }
AstNode* firstAbovep() const { // Returns nullptr when second or later in list AstNode* firstAbovep() const { // Returns nullptr when second or later in list
return ((backp() && backp()->nextp() != this) ? backp() : nullptr); return ((backp() && backp()->nextp() != this) ? backp() : nullptr);
@ -1663,11 +1663,11 @@ public:
virtual void tag(const string& text) {} virtual void tag(const string& text) {}
virtual string tag() const { return ""; } virtual string tag() const { return ""; }
virtual string verilogKwd() 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 origNameProtect() const; // origName with --protect-id applied
string shortName() const; // Name with __PVT__ removed for concatenating scopes string shortName() const; // Name with __PVT__ removed for concatenating scopes
static string dedotName(const string& namein); // Name with dots removed 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 vpiName(const string& namein); // Name for vpi access
static string prettyNameQ(const string& namein) { // Quoted pretty name (for errors) static string prettyNameQ(const string& namein) { // Quoted pretty name (for errors)
return std::string{"'"} + prettyName(namein) + "'"; return std::string{"'"} + prettyName(namein) + "'";
@ -1697,25 +1697,25 @@ public:
void protect(bool flag) { m_flags.protect = flag; } void protect(bool flag) { m_flags.protect = flag; }
// TODO stomp these width functions out, and call via dtypep() instead // 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; inline int widthMin() const;
int widthMinV() const { int widthMinV() const {
return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width(); return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width();
} }
int widthWords() const { return VL_WORDS_I(width()); } int widthWords() const { return VL_WORDS_I(width()); }
bool isQuad() const VL_MT_SAFE { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); } bool isQuad() const VL_MT_STABLE { return (width() > VL_IDATASIZE && width() <= VL_QUADSIZE); }
bool isWide() const VL_MT_SAFE { return (width() > VL_QUADSIZE); } bool isWide() const VL_MT_STABLE { return (width() > VL_QUADSIZE); }
inline bool isDouble() const; inline bool isDouble() const VL_MT_STABLE;
inline bool isSigned() const; inline bool isSigned() const VL_MT_STABLE;
inline bool isString() const; inline bool isString() const VL_MT_STABLE;
// clang-format off // clang-format off
VNUser user1u() const VL_MT_SAFE { VNUser user1u() const VL_MT_STABLE {
// Slows things down measurably, so disabled by default // Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser1InUse::s_userBusy, "userp set w/o busy"); //UASSERT_STATIC(VNUser1InUse::s_userBusy, "userp set w/o busy");
return ((m_user1Cnt==VNUser1InUse::s_userCntGbl) ? m_user1u : VNUser{0}); 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 user1u(const VNUser& user) { m_user1u=user; m_user1Cnt=VNUser1InUse::s_userCntGbl; }
void user1p(void* userp) { user1u(VNUser{userp}); } void user1p(void* userp) { user1u(VNUser{userp}); }
int user1() const { return user1u().toInt(); } 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() 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 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 // Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser2InUse::s_userBusy, "userp set w/o busy"); //UASSERT_STATIC(VNUser2InUse::s_userBusy, "userp set w/o busy");
return ((m_user2Cnt==VNUser2InUse::s_userCntGbl) ? m_user2u : VNUser{0}); 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 user2u(const VNUser& user) { m_user2u=user; m_user2Cnt=VNUser2InUse::s_userCntGbl; }
void user2p(void* userp) { user2u(VNUser{userp}); } void user2p(void* userp) { user2u(VNUser{userp}); }
int user2() const { return user2u().toInt(); } 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() 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 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 // Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser3InUse::s_userBusy, "userp set w/o busy"); //UASSERT_STATIC(VNUser3InUse::s_userBusy, "userp set w/o busy");
return ((m_user3Cnt==VNUser3InUse::s_userCntGbl) ? m_user3u : VNUser{0}); 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 user3u(const VNUser& user) { m_user3u=user; m_user3Cnt=VNUser3InUse::s_userCntGbl; }
void user3p(void* userp) { user3u(VNUser{userp}); } void user3p(void* userp) { user3u(VNUser{userp}); }
int user3() const { return user3u().toInt(); } 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() 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 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 // Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser4InUse::s_userBusy, "userp set w/o busy"); //UASSERT_STATIC(VNUser4InUse::s_userBusy, "userp set w/o busy");
return ((m_user4Cnt==VNUser4InUse::s_userCntGbl) ? m_user4u : VNUser{0}); 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 user4u(const VNUser& user) { m_user4u=user; m_user4Cnt=VNUser4InUse::s_userCntGbl; }
void user4p(void* userp) { user4u(VNUser{userp}); } void user4p(void* userp) { user4u(VNUser{userp}); }
int user4() const { return user4u().toInt(); } 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() 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 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 // Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser5InUse::s_userBusy, "userp set w/o busy"); //UASSERT_STATIC(VNUser5InUse::s_userBusy, "userp set w/o busy");
return ((m_user5Cnt==VNUser5InUse::s_userCntGbl) ? m_user5u : VNUser{0}); 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 user5u(const VNUser& user) { m_user5u=user; m_user5Cnt=VNUser5InUse::s_userCntGbl; }
void user5p(void* userp) { user5u(VNUser{userp}); } void user5p(void* userp) { user5u(VNUser{userp}); }
int user5() const { return user5u().toInt(); } int user5() const { return user5u().toInt(); }
@ -1907,7 +1907,7 @@ public:
// Does tree of this == node2p?, not allowing non-isGateOptimizable // Does tree of this == node2p?, not allowing non-isGateOptimizable
inline bool sameGateTree(const AstNode* node2p) const; inline bool sameGateTree(const AstNode* node2p) const;
void deleteTree(); // Always deletes the next link 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()); if (v3Global.opt.debugCheck()) checkTreeIter(backp());
} }
void checkIter() const; void checkIter() const;
@ -1992,7 +1992,7 @@ private:
// For internal use only. // For internal use only.
template <typename TargetType, typename DeclType> template <typename TargetType, typename DeclType>
constexpr static bool uselessCast() { constexpr static bool uselessCast() VL_PURE {
using NonRef = typename std::remove_reference<DeclType>::type; using NonRef = typename std::remove_reference<DeclType>::type;
using NonPtr = typename std::remove_pointer<NonRef>::type; using NonPtr = typename std::remove_pointer<NonRef>::type;
using NonCV = typename std::remove_cv<NonPtr>::type; using NonCV = typename std::remove_cv<NonPtr>::type;
@ -2001,7 +2001,7 @@ private:
// For internal use only. // For internal use only.
template <typename TargetType, typename DeclType> template <typename TargetType, typename DeclType>
constexpr static bool impossibleCast() { constexpr static bool impossibleCast() VL_PURE {
using NonRef = typename std::remove_reference<DeclType>::type; using NonRef = typename std::remove_reference<DeclType>::type;
using NonPtr = typename std::remove_pointer<NonRef>::type; using NonPtr = typename std::remove_pointer<NonRef>::type;
using NonCV = typename std::remove_cv<NonPtr>::type; using NonCV = typename std::remove_cv<NonPtr>::type;
@ -2035,7 +2035,7 @@ public:
// For use via the VN_AS macro only // For use via the VN_AS macro only
template <typename T, typename E> 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(!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."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep, UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,
@ -2044,7 +2044,7 @@ public:
return reinterpret_cast<T*>(nodep); return reinterpret_cast<T*>(nodep);
} }
template <typename T, typename E> 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(!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."); static_assert(!impossibleCast<T, E>(), "Unnecessary VN_AS, node cannot be this type.");
UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep, UASSERT_OBJ(!nodep || privateTypeTest<T>(nodep), nodep,

26
src/V3AstInlines.h
View File

@ -25,7 +25,7 @@
//###################################################################### //######################################################################
// Inline METHODS // 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; } int AstNode::widthMin() const { return dtypep() ? dtypep()->widthMin() : 0; }
bool AstNode::width1() const { // V3Const uses to know it can optimize bool AstNode::width1() const { // V3Const uses to know it can optimize
return dtypep() && dtypep()->width() == 1; return dtypep() && dtypep()->width() == 1;
@ -33,13 +33,13 @@ bool AstNode::width1() const { // V3Const uses to know it can optimize
int AstNode::widthInstrs() const { int AstNode::widthInstrs() const {
return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1)); 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(); 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(); 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 { bool AstNode::isZero() const {
return (VN_IS(this, Const) && VN_AS(this, Const)->num().isEqZero()); 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); return sameTreeIter(this, node2p, true, true);
} }
int AstNodeArrayDType::left() const VL_MT_SAFE { return rangep()->leftConst(); } int AstNodeArrayDType::left() const VL_MT_STABLE { return rangep()->leftConst(); }
int AstNodeArrayDType::right() const VL_MT_SAFE { return rangep()->rightConst(); } int AstNodeArrayDType::right() const VL_MT_STABLE { return rangep()->rightConst(); }
int AstNodeArrayDType::hi() const VL_MT_SAFE { return rangep()->hiConst(); } int AstNodeArrayDType::hi() const VL_MT_STABLE { return rangep()->hiConst(); }
int AstNodeArrayDType::lo() const VL_MT_SAFE { return rangep()->loConst(); } int AstNodeArrayDType::lo() const VL_MT_STABLE { return rangep()->loConst(); }
int AstNodeArrayDType::elementsConst() const VL_MT_SAFE { return rangep()->elementsConst(); } int AstNodeArrayDType::elementsConst() const VL_MT_STABLE { return rangep()->elementsConst(); }
VNumRange AstNodeArrayDType::declRange() const VL_MT_SAFE { return VNumRange{left(), right()}; } VNumRange AstNodeArrayDType::declRange() const VL_MT_STABLE { return VNumRange{left(), right()}; }
AstRange::AstRange(FileLine* fl, int left, int right) AstRange::AstRange(FileLine* fl, int left, int right)
: ASTGEN_SUPER_Range(fl) { : 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())}); leftp(new AstConst{fl, static_cast<uint32_t>(range.left())});
rightp(new AstConst{fl, static_cast<uint32_t>(range.right())}); 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); AstConst* const constp = VN_CAST(leftp(), Const);
return (constp ? constp->toSInt() : 0); return (constp ? constp->toSInt() : 0);
} }
int AstRange::rightConst() const { int AstRange::rightConst() const VL_MT_STABLE {
AstConst* const constp = VN_CAST(rightp(), Const); AstConst* const constp = VN_CAST(rightp(), Const);
return (constp ? constp->toSInt() : 0); 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); AstConst* const constp = VN_CAST(boundp(), Const);
return (constp ? constp->toSInt() : 0); return (constp ? constp->toSInt() : 0);
} }

165
src/V3AstNodeDType.h
View File

@ -63,9 +63,9 @@ public:
// Integral or packed, allowed inside an unpacked union/struct // Integral or packed, allowed inside an unpacked union/struct
virtual bool isIntegralOrPacked() const { return !isCompound(); } virtual bool isIntegralOrPacked() const { return !isCompound(); }
// (Slow) recurse down to find basic data type // (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 // 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 // recurses over typedefs to next non-typeref-or-const type
virtual AstNodeDType* skipRefToConstp() const = 0; virtual AstNodeDType* skipRefToConstp() const = 0;
// recurses over typedefs/const to next non-typeref-or-enum/struct type // 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 // Assignable equivalence. Call skipRefp() on this and samep before calling
virtual bool similarDType(const AstNodeDType* samep) const = 0; virtual bool similarDType(const AstNodeDType* samep) const = 0;
// Iff has a non-null subDTypep(), as generic node function // 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; virtual bool isFourstate() const;
// Ideally an IEEE $typename // Ideally an IEEE $typename
virtual string prettyDTypeName() const { return prettyTypeName(); } virtual string prettyDTypeName() const { return prettyTypeName(); }
@ -126,12 +126,13 @@ public:
const char* charIQWN() const { const char* charIQWN() const {
return (isString() ? "N" : isWide() ? "W" : isQuad() ? "Q" : "I"); return (isString() ? "N" : isWide() ? "W" : isQuad() ? "Q" : "I");
} }
string cType(const string& name, bool forFunc, bool isRef) const VL_MT_SAFE; string cType(const string& name, bool forFunc, bool isRef) const VL_MT_STABLE;
bool isLiteralType() const VL_MT_SAFE; // Represents a C++ LiteralType? (can be constexpr) // Represents a C++ LiteralType? (can be constexpr)
bool isLiteralType() const VL_MT_STABLE;
private: private:
class CTypeRecursed; 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 { class AstNodeArrayDType VL_NOT_FINAL : public AstNodeDType {
// Array data type, ie "some_dtype var_name [2:0]" // Array data type, ie "some_dtype var_name [2:0]"
@ -170,29 +171,29 @@ public:
&& subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); && subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp()));
} }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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(); return m_refDTypep ? m_refDTypep : childDTypep();
} }
void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { AstBasicDType* basicp() const override VL_MT_STABLE {
return subDTypep()->basicp(); return subDTypep()->basicp();
} // (Slow) recurse down to find basic data type } // (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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
int widthTotalBytes() const override { int widthTotalBytes() const override {
return elementsConst() * subDTypep()->widthTotalBytes(); return elementsConst() * subDTypep()->widthTotalBytes();
} }
inline int left() const; inline int left() const VL_MT_STABLE;
inline int right() const; inline int right() const VL_MT_STABLE;
inline int hi() const; inline int hi() const VL_MT_STABLE;
inline int lo() const; inline int lo() const VL_MT_STABLE;
inline int elementsConst() const; inline int elementsConst() const VL_MT_STABLE;
inline VNumRange declRange() const; inline VNumRange declRange() const VL_MT_STABLE;
}; };
class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType { class AstNodeUOrStructDType VL_NOT_FINAL : public AstNodeDType {
// A struct or union; common handling // A struct or union; common handling
@ -231,7 +232,7 @@ public:
: VN_AS(findBitRangeDType(VNumRange{width() - 1, 0}, width(), numeric()), : VN_AS(findBitRangeDType(VNumRange{width() - 1, 0}, width(), numeric()),
BasicDType)); 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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() 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) // (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 // packed() but as don't support unpacked, presently all structs
static bool packedUnsup() { return true; } static bool packedUnsup() { return true; }
void isFourstate(bool flag) { m_isFourstate = flag; } 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 clearCache() { m_members.clear(); }
void repairMemberCache(); void repairMemberCache();
AstMemberDType* findMember(const string& name) const { AstMemberDType* findMember(const string& name) const {
@ -336,7 +337,7 @@ public:
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* getChildDTypep() const override { return childDTypep(); }
AstNodeDType* getChild2DTypep() const override { return keyChildDTypep(); } 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(); return m_refDTypep ? m_refDTypep : childDTypep();
} }
void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
@ -345,13 +346,13 @@ public:
AstNodeDType* virtRefDType2p() const override { return m_keyDTypep; } AstNodeDType* virtRefDType2p() const override { return m_keyDTypep; }
void virtRefDType2p(AstNodeDType* nodep) override { keyDTypep(nodep); } 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(); return m_keyDTypep ? m_keyDTypep : keyChildDTypep();
} }
void keyDTypep(AstNodeDType* nodep) { m_keyDTypep = nodep; } void keyDTypep(AstNodeDType* nodep) { m_keyDTypep = nodep; }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@ -423,8 +424,8 @@ public:
} }
} }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return (AstBasicDType*)this; } AstBasicDType* basicp() const override VL_MT_STABLE { return (AstBasicDType*)this; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() 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) // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
@ -491,13 +492,13 @@ public:
} }
ASTGEN_MEMBERS_AstBracketArrayDType; ASTGEN_MEMBERS_AstBracketArrayDType;
bool similarDType(const AstNodeDType* samep) const override { V3ERROR_NA_RETURN(false); } 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 // METHODS
// Will be removed in V3Width, which relies on this // Will be removed in V3Width, which relies on this
// being a child not a dtype pointed node // being a child not a dtype pointed node
bool maybePointedTo() const override { return false; } bool maybePointedTo() const override { return false; }
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { V3ERROR_NA_RETURN(0); } int widthAlignBytes() const override { V3ERROR_NA_RETURN(0); }
@ -531,15 +532,15 @@ public:
void dump(std::ostream& str = std::cout) const override; void dump(std::ostream& str = std::cout) const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
string name() const override; string name() const override;
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return 0; } int widthAlignBytes() const override { return 0; }
int widthTotalBytes() const override { return 0; } int widthTotalBytes() const override { return 0; }
AstNodeDType* virtRefDTypep() const override { return nullptr; } AstNodeDType* virtRefDTypep() const override { return nullptr; }
void virtRefDTypep(AstNodeDType* nodep) override {} 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; } AstNodeModule* classOrPackagep() const { return m_classOrPackagep; }
void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; } void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
AstClass* classp() const { return m_classp; } AstClass* classp() const { return m_classp; }
@ -578,13 +579,15 @@ public:
return skipRefp()->similarDType(samep->skipRefp()); return skipRefp()->similarDType(samep->skipRefp());
} }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
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 (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@ -625,13 +628,15 @@ public:
return type() == samep->type() && same(samep); return type() == samep->type() && same(samep);
} }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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; } void* containerp() const { return m_containerp; }
// METHODS // METHODS
// op1 = Range of variable // op1 = Range of variable
AstNodeDType* dtypeSkipRefp() const { return dtypep()->skipRefp(); } AstNodeDType* dtypeSkipRefp() const { return dtypep()->skipRefp(); }
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return dtypep()->widthAlignBytes(); } int widthAlignBytes() const override { return dtypep()->widthAlignBytes(); }
@ -679,15 +684,15 @@ public:
string prettyDTypeName() const override; string prettyDTypeName() const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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(); return m_refDTypep ? m_refDTypep : childDTypep();
} }
void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@ -706,13 +711,13 @@ public:
bool hasDType() const override { return true; } bool hasDType() const override { return true; }
bool maybePointedTo() const override { return true; } bool maybePointedTo() const override { return true; }
bool undead() 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; } AstNodeDType* virtRefDTypep() const override { return nullptr; }
void virtRefDTypep(AstNodeDType* nodep) override {} void virtRefDTypep(AstNodeDType* nodep) override {}
bool similarDType(const AstNodeDType* samep) const override { return this == samep; } 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 // 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 // cppcheck-suppress csyleCast
AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
@ -756,7 +761,9 @@ public:
} }
bool similarDType(const AstNodeDType* samep) const override { return this == samep; } bool similarDType(const AstNodeDType* samep) const override { return this == samep; }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
@ -765,8 +772,8 @@ public:
void dump(std::ostream& str = std::cout) const override; void dump(std::ostream& str = std::cout) const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
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* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
@ -818,8 +825,8 @@ public:
void dump(std::ostream& str = std::cout) const override; void dump(std::ostream& str = std::cout) const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
void cloneRelink() override; void cloneRelink() override;
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
bool similarDType(const AstNodeDType* samep) const override { return this == samep; } 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(); if (m_refDTypep && m_refDTypep->clonep()) m_refDTypep = m_refDTypep->clonep();
} }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } 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 - // (Slow) recurse down to find basic data type (Note don't need virtual -
// AstVar isn't a NodeDType) // 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) // op1 = Range of variable (Note don't need virtual - AstVar isn't a NodeDType)
AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); } 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* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
// (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this) // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
@ -931,9 +940,11 @@ public:
ASTGEN_MEMBERS_AstParamTypeDType; ASTGEN_MEMBERS_AstParamTypeDType;
void dump(std::ostream& str = std::cout) const override; void dump(std::ostream& str = std::cout) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* getChildDTypep() const override { return childDTypep(); }
AstNodeDType* subDTypep() const override { return dtypep() ? dtypep() : childDTypep(); } AstNodeDType* subDTypep() const override VL_MT_STABLE {
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } return dtypep() ? dtypep() : childDTypep();
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(); } AstNodeDType* skipRefToConstp() const override { return subDTypep()->skipRefToConstp(); }
AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); }
bool similarDType(const AstNodeDType* samep) const override { bool similarDType(const AstNodeDType* samep) const override {
@ -967,8 +978,8 @@ public:
AstNodeDType* dtypep() const { return nullptr; } AstNodeDType* dtypep() const { return nullptr; }
// METHODS // METHODS
bool similarDType(const AstNodeDType* samep) const override { return this == samep; } 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; }
AstNodeDType* skipRefp() const override VL_MT_SAFE { return nullptr; } AstNodeDType* skipRefp() const override VL_MT_STABLE { return nullptr; }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
@ -1022,17 +1033,17 @@ public:
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
string prettyDTypeName() const override; string prettyDTypeName() const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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(); return m_refDTypep ? m_refDTypep : childDTypep();
} }
void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } 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; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return nullptr; } AstBasicDType* basicp() const override VL_MT_STABLE { return nullptr; }
// cppcheck-suppress csyleCast // 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 // cppcheck-suppress csyleCast
AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
@ -1086,11 +1097,11 @@ public:
string prettyDTypeName() const override { string prettyDTypeName() const override {
return subDTypep() ? prettyName(subDTypep()->name()) : prettyName(); 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; return subDTypep() ? subDTypep()->basicp() : nullptr;
} }
AstNodeDType* subDTypep() const override; AstNodeDType* subDTypep() const override VL_MT_STABLE;
AstNodeDType* skipRefp() const override VL_MT_SAFE { AstNodeDType* skipRefp() const override VL_MT_STABLE {
// Skip past both the Ref and the Typedef // Skip past both the Ref and the Typedef
if (subDTypep()) { if (subDTypep()) {
return subDTypep()->skipRefp(); return subDTypep()->skipRefp();
@ -1119,9 +1130,9 @@ public:
int widthTotalBytes() const override { return dtypeSkipRefp()->widthTotalBytes(); } int widthTotalBytes() const override { return dtypeSkipRefp()->widthTotalBytes(); }
void name(const string& flag) override { m_name = flag; } void name(const string& flag) override { m_name = flag; }
AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); } 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; } 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return refDTypep(); } AstNodeDType* virtRefDTypep() const override { return refDTypep(); }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
@ -1163,13 +1174,15 @@ public:
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* getChildDTypep() const override { return childDTypep(); }
// op1 = Range of variable // 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefp() const override VL_MT_STABLE { return (AstNodeDType*)this; }
AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); } int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); }
@ -1201,13 +1214,15 @@ public:
bool similarDType(const AstNodeDType* samep) const override; bool similarDType(const AstNodeDType* samep) const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); }
@ -1226,13 +1241,13 @@ public:
bool hasDType() const override { return true; } bool hasDType() const override { return true; }
bool maybePointedTo() const override { return true; } bool maybePointedTo() const override { return true; }
bool undead() 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; } AstNodeDType* virtRefDTypep() const override { return nullptr; }
void virtRefDTypep(AstNodeDType* nodep) override {} void virtRefDTypep(AstNodeDType* nodep) override {}
bool similarDType(const AstNodeDType* samep) const override { return this == samep; } 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 // 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 // cppcheck-suppress csyleCast
AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; }
// cppcheck-suppress csyleCast // cppcheck-suppress csyleCast
@ -1266,15 +1281,15 @@ public:
bool similarDType(const AstNodeDType* samep) const override; bool similarDType(const AstNodeDType* samep) const override;
void dumpSmall(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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(); return m_refDTypep ? m_refDTypep : childDTypep();
} }
void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } AstNodeDType* virtRefDTypep() const override { return m_refDTypep; }
void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); }
// METHODS // METHODS
AstBasicDType* basicp() const override VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const override VL_MT_STABLE { return subDTypep()->basicp(); }
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* skipRefToConstp() const override { return (AstNodeDType*)this; }
AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; }
int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); } int widthAlignBytes() const override { return sizeof(std::map<std::string, std::string>); }

6
src/V3AstNodeExpr.h
View File

@ -644,7 +644,7 @@ public:
string emitC() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); }
bool cleanOut() const override { V3ERROR_NA_RETURN(true); } bool cleanOut() const override { V3ERROR_NA_RETURN(true); }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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 { class AstCastParse final : public AstNodeExpr {
// Cast to appropriate type, where we haven't determined yet what the data type is // 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(""); } bool cleanOut() const override { V3ERROR_NA_RETURN(""); }
int instrCount() const override { return widthInstrs(); } int instrCount() const override { return widthInstrs(); }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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 { class AstRand final : public AstNodeExpr {
// $random/$random(seed) or $urandom/$urandom(seed) // $random/$random(seed) or $urandom/$urandom(seed)
@ -1972,7 +1972,7 @@ public:
bool same(const AstNode* /*samep*/) const override { return true; } bool same(const AstNode* /*samep*/) const override { return true; }
bool cleanOut() const override { return true; } bool cleanOut() const override { return true; }
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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 { class AstTimePrecision final : public AstNodeExpr {
// Verilog $timeprecision // Verilog $timeprecision

20
src/V3AstNodeOther.h
View File

@ -1544,7 +1544,9 @@ public:
ASTGEN_MEMBERS_AstTypedef; ASTGEN_MEMBERS_AstTypedef;
void dump(std::ostream& str) const override; void dump(std::ostream& str) const override;
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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 // METHODS
string name() const override { return m_name; } string name() const override { return m_name; }
bool maybePointedTo() const override { return true; } bool maybePointedTo() const override { return true; }
@ -1793,11 +1795,11 @@ public:
string vlPropDecl(const string& propName) const; // Return VerilatorVarProps declaration string vlPropDecl(const string& propName) const; // Return VerilatorVarProps declaration
void combineType(VVarType type); void combineType(VVarType type);
AstNodeDType* getChildDTypep() const override { return childDTypep(); } 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 - // (Slow) recurse down to find basic data type (Note don't need virtual -
// AstVar isn't a NodeDType) // AstVar isn't a NodeDType)
AstBasicDType* basicp() const VL_MT_SAFE { return subDTypep()->basicp(); } AstBasicDType* basicp() const VL_MT_STABLE { return subDTypep()->basicp(); }
virtual AstNodeDType* subDTypep() const VL_MT_SAFE { virtual AstNodeDType* subDTypep() const VL_MT_STABLE {
return dtypep() ? dtypep() : childDTypep(); return dtypep() ? dtypep() : childDTypep();
} }
void ansi(bool flag) { m_ansi = flag; } void ansi(bool flag) { m_ansi = flag; }
@ -2334,19 +2336,19 @@ public:
inline AstRange(FileLine* fl, int left, int right); inline AstRange(FileLine* fl, int left, int right);
inline AstRange(FileLine* fl, const VNumRange& range); inline AstRange(FileLine* fl, const VNumRange& range);
ASTGEN_MEMBERS_AstRange; ASTGEN_MEMBERS_AstRange;
inline int leftConst() const VL_MT_SAFE; inline int leftConst() const VL_MT_STABLE;
inline int rightConst() const VL_MT_SAFE; inline int rightConst() const VL_MT_STABLE;
int hiConst() const VL_MT_SAFE { int hiConst() const VL_MT_STABLE {
const int l = leftConst(); const int l = leftConst();
const int r = rightConst(); const int r = rightConst();
return l > r ? l : r; return l > r ? l : r;
} }
int loConst() const VL_MT_SAFE { int loConst() const VL_MT_STABLE {
const int l = leftConst(); const int l = leftConst();
const int r = rightConst(); const int r = rightConst();
return l > r ? r : l; 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(); } bool littleEndian() const { return leftConst() < rightConst(); }
void dump(std::ostream& str) const override; void dump(std::ostream& str) const override;
virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitC() { V3ERROR_NA_RETURN(""); }

8
src/V3AstNodes.cpp
View File

@ -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); const CTypeRecursed info = cTypeRecurse(false);
return info.render(name, isRef); 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 // Legacy compound argument currently just passed through and unused
CTypeRecursed info; CTypeRecursed info;
@ -846,7 +846,7 @@ int AstNodeDType::widthPow2() const {
return 1; 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)) { if (const auto* const dtypep = VN_CAST(skipRefp(), BasicDType)) {
return dtypep->keyword().isLiteralType(); return dtypep->keyword().isLiteralType();
} else if (const auto* const dtypep = VN_CAST(skipRefp(), UnpackArrayDType)) { } else if (const auto* const dtypep = VN_CAST(skipRefp(), UnpackArrayDType)) {
@ -1804,7 +1804,7 @@ void AstRefDType::cloneRelink() {
m_classOrPackagep = m_classOrPackagep->clonep(); m_classOrPackagep = m_classOrPackagep->clonep();
} }
} }
AstNodeDType* AstRefDType::subDTypep() const { AstNodeDType* AstRefDType::subDTypep() const VL_MT_STABLE {
if (typedefp()) return typedefp()->subDTypep(); if (typedefp()) return typedefp()->subDTypep();
return refDTypep(); // Maybe nullptr return refDTypep(); // Maybe nullptr
} }

8
src/V3EmitCBase.h
View File

@ -40,7 +40,7 @@ public:
EmitCParentModule(); EmitCParentModule();
VL_UNCOPYABLE(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); return VN_AS(nodep->user4p(), NodeModule);
} }
}; };
@ -70,7 +70,9 @@ public:
static string protectWordsIf(const string& name, bool doIt) { static string protectWordsIf(const string& name, bool doIt) {
return VIdProtect::protectWordsIf(name, 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) { static string voidSelfAssign(const AstNodeModule* modp) {
const string className = prefixNameProtect(modp); const string className = prefixNameProtect(modp);
return className + "* const __restrict vlSelf VL_ATTR_UNUSED = static_cast<" + className 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 static string prefixNameProtect(const AstNode* nodep) { // C++ name with prefix
return v3Global.opt.modPrefix() + "_" + protect(nodep->name()); 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(); return v3Global.opt.prefix();
} }

2
src/V3Error.h
View File

@ -648,7 +648,7 @@ inline void v3errorEndFatal(std::ostringstream& sstr)
// Helper macros for VL_DEFINE_DEBUG_FUNCTIONS // Helper macros for VL_DEFINE_DEBUG_FUNCTIONS
// Takes an optional "name" (as __VA_ARGS__) // Takes an optional "name" (as __VA_ARGS__)
#define VL_DEFINE_DEBUG(...) \ #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; \ static int level = -1; \
if (VL_UNLIKELY(level < 0)) { \ if (VL_UNLIKELY(level < 0)) { \
std::string tag{VL_STRINGIFY(__VA_ARGS__)}; \ std::string tag{VL_STRINGIFY(__VA_ARGS__)}; \

3
src/V3File.cpp
View File

@ -853,7 +853,8 @@ void V3OutFormatter::putcNoTracking(char chr) {
putcOutput(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 // Encode control chars into output-appropriate escapes
// Reverse is V3Parse::deQuote // Reverse is V3Parse::deQuote
string out; string out;

4
src/V3File.h
View File

@ -39,7 +39,7 @@ public:
addSrcDepend(filename); addSrcDepend(filename);
return new_ifstream_nodepend(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()}; return new std::ifstream{filename.c_str()};
} }
static std::ofstream* new_ofstream(const string& filename, bool append = false) { static std::ofstream* new_ofstream(const string& filename, bool append = false) {
@ -171,7 +171,7 @@ public:
// STATIC METHODS // STATIC METHODS
static string indentSpaces(int num); static string indentSpaces(int num);
// Add escaped characters to strings // 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 tokenMatch(const char* cp, const char* cmp);
static bool tokenNotStart(const char* cp); // Import/export meaning no endfunction static bool tokenNotStart(const char* cp); // Import/export meaning no endfunction
static bool tokenStart(const char* cp); static bool tokenStart(const char* cp);

2
src/V3FileLine.cpp
View File

@ -39,7 +39,7 @@ VL_DEFINE_DEBUG_FUNCTIONS;
//###################################################################### //######################################################################
// FileLineSingleton class functions // FileLineSingleton class functions
string FileLineSingleton::filenameLetters(fileNameIdx_t fileno) { string FileLineSingleton::filenameLetters(fileNameIdx_t fileno) VL_PURE {
constexpr int size constexpr int size
= 1 + (64 / 4); // Each letter retires more than 4 bits of a > 64 bit number = 1 + (64 / 4); // Each letter retires more than 4 bits of a > 64 bit number
char out[size]; char out[size];

12
src/V3FileLine.h
View File

@ -64,7 +64,7 @@ class FileLineSingleton final {
~FileLineSingleton() = default; ~FileLineSingleton() = default;
fileNameIdx_t nameToNumber(const string& filename); 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]; } V3LangCode numberToLang(fileNameIdx_t filenameno) const { return m_languages[filenameno]; }
void numberToLang(fileNameIdx_t filenameno, const V3LangCode& l) { void numberToLang(fileNameIdx_t filenameno, const V3LangCode& l) {
m_languages[filenameno] = l; m_languages[filenameno] = l;
@ -75,7 +75,7 @@ class FileLineSingleton final {
m_languages.clear(); m_languages.clear();
} }
void fileNameNumMapDumpXml(std::ostream& os); 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 // Add given bitset to the interned bitsets, return interned index
msgEnSetIdx_t addMsgEnBitSet(const MsgEnBitSet& bitSet); msgEnSetIdx_t addMsgEnBitSet(const MsgEnBitSet& bitSet);
@ -159,7 +159,7 @@ protected:
private: private:
// CONSTRUCTORS // CONSTRUCTORS
static FileLineSingleton& singleton() { static FileLineSingleton& singleton() VL_MT_SAFE {
static FileLineSingleton s; static FileLineSingleton s;
return s; return s;
} }
@ -242,7 +242,7 @@ public:
string prettySource() const VL_MT_SAFE; // Source, w/stripped unprintables and newlines string prettySource() const VL_MT_SAFE; // Source, w/stripped unprintables and newlines
FileLine* parent() const VL_MT_SAFE { return m_parent; } FileLine* parent() const VL_MT_SAFE { return m_parent; }
V3LangCode language() const { return singleton().numberToLang(filenameno()); } V3LangCode language() const { return singleton().numberToLang(filenameno()); }
string ascii() const; string ascii() const VL_MT_SAFE;
string asciiLineCol() const; string asciiLineCol() const;
int filenameno() const VL_MT_SAFE { return m_filenameno; } int filenameno() const VL_MT_SAFE { return m_filenameno; }
string filename() const VL_MT_SAFE { return singleton().numberToName(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); } void warnOff(V3ErrorCode code, bool flag) { warnOn(code, !flag); }
bool warnOff(const string& msg, bool flag); // Returns 1 if ok 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 warnLintOff(bool flag);
void warnStyleOff(bool flag); void warnStyleOff(bool flag);
void warnUnusedOff(bool flag); void warnUnusedOff(bool flag);
@ -362,7 +362,7 @@ public:
private: private:
string warnContext() const; string warnContext() const;
string warnContextParent() const VL_REQUIRES(V3Error::s().m_mutex); 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); std::ostream& operator<<(std::ostream& os, FileLine* fileline);

2
src/V3Global.h
View File

@ -143,7 +143,7 @@ public:
void widthMinUsage(const VWidthMinUsage& flag) { m_widthMinUsage = flag; } void widthMinUsage(const VWidthMinUsage& flag) { m_widthMinUsage = flag; }
bool constRemoveXs() const { return m_constRemoveXs; } bool constRemoveXs() const { return m_constRemoveXs; }
void constRemoveXs(bool flag) { m_constRemoveXs = flag; } 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); static string digitsFilename(int number);
bool needTraceDumper() const { return m_needTraceDumper; } bool needTraceDumper() const { return m_needTraceDumper; }
void needTraceDumper(bool flag) { m_needTraceDumper = flag; } void needTraceDumper(bool flag) { m_needTraceDumper = flag; }

2
src/V3Hash.cpp
View File

@ -24,7 +24,7 @@
V3Hash::V3Hash(const std::string& val) V3Hash::V3Hash(const std::string& val)
: m_value{static_cast<uint32_t>(std::hash<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(); return os << 'h' << std::hex << std::setw(8) << std::setfill('0') << rhs.value();
} }

2
src/V3Hash.h
View File

@ -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 <> template <>
struct std::hash<V3Hash> { struct std::hash<V3Hash> {

22
src/V3Number.cpp
View File

@ -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; string padding;
if (in.length() < fmtsize) padding = string(fmtsize - in.length(), pad); if (in.length() < fmtsize) padding = string(fmtsize - in.length(), pad);
return left ? (in + padding) : (padding + in); 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); 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(); auto pos = vformat.cbegin();
UASSERT(pos != vformat.cend() && pos[0] == '%', UASSERT(pos != vformat.cend() && pos[0] == '%',
"$display-like function with non format argument " << *this); "$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; return m_data.num()[0].m_value;
} }
double V3Number::toDouble() const { double V3Number::toDouble() const VL_MT_SAFE {
if (VL_UNCOVERABLE(!isDouble() || width() != 64)) { if (VL_UNCOVERABLE(!isDouble() || width() != 64)) {
v3fatalSrc("Real operation on wrong sized/non-real number"); v3fatalSrc("Real operation on wrong sized/non-real number");
} }
@ -926,7 +926,7 @@ double V3Number::toDouble() const {
return u.d; return u.d;
} }
int32_t V3Number::toSInt() const { int32_t V3Number::toSInt() const VL_MT_SAFE {
if (isSigned()) { if (isSigned()) {
const uint32_t v = toUInt(); const uint32_t v = toUInt();
const uint32_t signExtend = (-(v & (1UL << (width() - 1)))); 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; 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; if (isDouble() || isString()) return false;
for (int i = 0; i < width(); i++) { for (int i = 0; i < width(); i++) {
if (!bitIsZ(i)) return false; if (!bitIsZ(i)) return false;
} }
return true; return true;
} }
bool V3Number::isAllX() const { bool V3Number::isAllX() const VL_MT_SAFE {
if (isDouble() || isString()) return false; if (isDouble() || isString()) return false;
uint32_t mask = hiWordMask(); uint32_t mask = hiWordMask();
for (int i = words() - 1; i >= 0; --i) { for (int i = words() - 1; i >= 0; --i) {
@ -1057,7 +1057,7 @@ bool V3Number::isFourState() const {
} }
return false; return false;
} }
bool V3Number::isAnyX() const { bool V3Number::isAnyX() const VL_MT_SAFE {
if (isDouble() || isString()) return false; if (isDouble() || isString()) return false;
for (int bit = 0; bit < width(); bit++) { for (int bit = 0; bit < width(); bit++) {
if (bitIsX(bit)) return true; if (bitIsX(bit)) return true;
@ -1065,7 +1065,7 @@ bool V3Number::isAnyX() const {
return false; return false;
} }
bool V3Number::isAnyXZ() const { return isAnyX() || isAnyZ(); } bool V3Number::isAnyXZ() const { return isAnyX() || isAnyZ(); }
bool V3Number::isAnyZ() const { bool V3Number::isAnyZ() const VL_MT_SAFE {
if (isDouble() || isString()) return false; if (isDouble() || isString()) return false;
for (int bit = 0; bit < width(); bit++) { for (int bit = 0; bit < width(); bit++) {
if (bitIsZ(bit)) return true; if (bitIsZ(bit)) return true;
@ -1082,7 +1082,7 @@ bool V3Number::isLtXZ(const V3Number& rhs) const {
} }
return false; return false;
} }
int V3Number::countX(int lsb, int nbits) const { int V3Number::countX(int lsb, int nbits) const VL_MT_SAFE {
int count = 0; int count = 0;
for (int bitn = 0; bitn < nbits; ++bitn) { for (int bitn = 0; bitn < nbits; ++bitn) {
if (lsb + bitn >= width()) return count; if (lsb + bitn >= width()) return count;
@ -1090,7 +1090,7 @@ int V3Number::countX(int lsb, int nbits) const {
} }
return count; return count;
} }
int V3Number::countZ(int lsb, int nbits) const { int V3Number::countZ(int lsb, int nbits) const VL_MT_SAFE {
int count = 0; int count = 0;
for (int bitn = 0; bitn < nbits; ++bitn) { for (int bitn = 0; bitn < nbits; ++bitn) {
if (lsb + bitn >= width()) return count; if (lsb + bitn >= width()) return count;

28
src/V3Number.h
View File

@ -63,7 +63,7 @@ public:
DOUBLE = 2, DOUBLE = 2,
STRING = 3, 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) { switch (rhs) {
case V3NumberDataType::UNINITIALIZED: return os << "UNINITIALIZED"; case V3NumberDataType::UNINITIALIZED: return os << "UNINITIALIZED";
case V3NumberDataType::LOGIC: return os << "LOGIC"; case V3NumberDataType::LOGIC: return os << "LOGIC";
@ -210,7 +210,7 @@ public:
UASSERT(isString(), "`str` member accessed when data type is " << m_type); UASSERT(isString(), "`str` member accessed when data type is " << m_type);
return m_string; 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); UASSERT(isString(), "`str` member accessed when data type is " << m_type);
return m_string; return m_string;
} }
@ -383,7 +383,7 @@ public:
} }
private: private:
char bitIs(int bit) const VL_MT_SAFE { char bitIs(int bit) const {
if (bit >= m_data.width() || bit < 0) { if (bit >= m_data.width() || bit < 0) {
// We never sign extend // We never sign extend
return '0'; return '0';
@ -559,7 +559,7 @@ private:
m_data.m_sized = false; 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(FileLine* fl, const string& vformat) const VL_MT_SAFE;
string displayed(const string& vformat) const VL_MT_SAFE { string displayed(const string& vformat) const VL_MT_SAFE {
return displayed(m_fileline, vformat); 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 V3Number& setMask(int nbits); // IE if nbits=1, then 0b1, if 2->0b11, if 3->0b111 etc
// ACCESSORS // ACCESSORS
string ascii(bool prefixed = true, bool cleanVerilog = false) const VL_MT_SAFE; string ascii(bool prefixed = true, bool cleanVerilog = false) const;
string displayed(AstNode* nodep, const string& vformat) 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? static bool displayedFmtLegal(char format, bool isScan); // Is this a valid format letter?
int width() const VL_MT_SAFE { return m_data.width(); } int width() const VL_MT_SAFE { return m_data.width(); }
int widthMin() const; // Minimum width that can represent this number (~== log2(num)+1) int widthMin() const; // Minimum width that can represent this number (~== log2(num)+1)
@ -612,10 +612,10 @@ public:
return m_data.type() == V3NumberDataType::LOGIC return m_data.type() == V3NumberDataType::LOGIC
|| m_data.type() == V3NumberDataType::DOUBLE; || 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 is1Step() const VL_MT_SAFE { return m_data.m_is1Step; }
bool isNull() const VL_MT_SAFE { return m_data.m_isNull; } bool isNull() const VL_MT_SAFE { return m_data.m_isNull; }
bool isFourState() const VL_MT_SAFE; bool isFourState() const;
bool hasZ() const { bool hasZ() const {
if (isString()) return false; if (isString()) return false;
for (int i = 0; i < words(); i++) { for (int i = 0; i < words(); i++) {
@ -626,7 +626,7 @@ public:
} }
bool isAllZ() const VL_MT_SAFE; bool isAllZ() const VL_MT_SAFE;
bool isAllX() const VL_MT_SAFE; bool isAllX() const VL_MT_SAFE;
bool isEqZero() const VL_MT_SAFE; bool isEqZero() const;
bool isNeqZero() const; bool isNeqZero() const;
bool isBitsZero(int msb, int lsb) const; bool isBitsZero(int msb, int lsb) const;
bool isEqOne() const; bool isEqOne() const;
@ -637,13 +637,13 @@ public:
bool isAnyXZ() const; bool isAnyXZ() const;
bool isAnyZ() const VL_MT_SAFE; bool isAnyZ() const VL_MT_SAFE;
bool isMsbXZ() const { return bitIsXZ(m_data.width() - 1); } 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; 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; int64_t toSQuad() const VL_MT_SAFE;
string toString() const VL_MT_SAFE; string toString() const VL_MT_SAFE;
string toDecimalS() const VL_MT_SAFE; // return ASCII signed decimal number string toDecimalS() const; // return ASCII signed decimal number
string toDecimalU() const VL_MT_SAFE; // return ASCII unsigned decimal number string toDecimalU() const; // return ASCII unsigned decimal number
double toDouble() const VL_MT_SAFE; double toDouble() const VL_MT_SAFE;
V3Hash toHash() const; V3Hash toHash() const;
uint32_t edataWord(int eword) const; uint32_t edataWord(int eword) const;
@ -777,7 +777,7 @@ public:
V3Number& opLtN(const V3Number& lhs, const V3Number& rhs); V3Number& opLtN(const V3Number& lhs, const V3Number& rhs);
V3Number& opLteN(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(); return os << rhs.ascii();
} }

4
src/V3Options.cpp
View File

@ -874,7 +874,7 @@ void V3Options::notify() {
//###################################################################### //######################################################################
// V3 Options accessors // V3 Options accessors
string V3Options::version() { string V3Options::version() VL_PURE {
string ver = DTVERSION; string ver = DTVERSION;
ver += " rev " + cvtToStr(DTVERSION_rev); ver += " rev " + cvtToStr(DTVERSION_rev);
return ver; return ver;
@ -1938,7 +1938,7 @@ unsigned V3Options::dumpLevel(const string& tag) const VL_MT_SAFE {
return iter != m_dumpLevel.end() ? iter->second : 0; 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. // For simplicity, calling functions can just use __FILE__ for srcfile.
// That means we need to strip the filenames: ../Foo.cpp -> Foo // That means we need to strip the filenames: ../Foo.cpp -> Foo
return dumpLevel(V3Os::filenameNonDirExt(srcfile_path)); return dumpLevel(V3Os::filenameNonDirExt(srcfile_path));

4
src/V3Options.h
View File

@ -407,7 +407,7 @@ public:
unsigned debugLevel(const string& tag) const VL_MT_SAFE; unsigned debugLevel(const string& tag) const VL_MT_SAFE;
unsigned debugSrcLevel(const string& srcfile_path) const VL_MT_SAFE; unsigned debugSrcLevel(const string& srcfile_path) const VL_MT_SAFE;
unsigned dumpLevel(const string& tag) 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 // METHODS
void addCppFile(const string& filename); void addCppFile(const string& filename);
@ -650,7 +650,7 @@ public:
} }
// METHODS (from main) // 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 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 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 // Return options for child hierarchical blocks when forTop==false, otherwise returns args for

4
src/V3Os.cpp
View File

@ -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; string::size_type pos;
if ((pos = filename.rfind('/')) != string::npos) { if ((pos = filename.rfind('/')) != string::npos) {
return filename.substr(pos + 1); 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 base = filenameNonDir(filename);
string::size_type pos; string::size_type pos;
if ((pos = base.find('.')) != string::npos) base.erase(pos); if ((pos = base.find('.')) != string::npos) base.erase(pos);

7
src/V3Os.h
View File

@ -37,10 +37,11 @@ public:
// METHODS (generic filename utilities) // METHODS (generic filename utilities)
static string filenameFromDirBase(const string& dir, const string& basename); static string filenameFromDirBase(const string& dir, const string& basename);
/// Return non-directory part of filename /// 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 /// Return non-extensioned (no .) part of filename
static string filenameNonExt(const string& filename); static string filenameNonExt(const string& filename) VL_PURE;
static string filenameNonDirExt(const string& filename) { ///< Return basename of filename ///< Return basename of filename
static string filenameNonDirExt(const string& filename) VL_PURE {
return filenameNonExt(filenameNonDir(filename)); return filenameNonExt(filenameNonDir(filename));
} }
static string filenameDir(const string& filename); ///< Return directory part of filename static string filenameDir(const string& filename); ///< Return directory part of filename

14
src/V3String.cpp
View File

@ -36,7 +36,7 @@ std::map<string, string> VName::s_dehashMap;
// Wildcard // Wildcard
// Double procedures, inlined, unrolls loop much better // 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++) { for (; *p; s++, p++) {
if (*p != '*') { if (*p != '*') {
if (((*s) != (*p)) && *p != '?') return false; if (((*s) != (*p)) && *p != '?') return false;
@ -52,7 +52,7 @@ bool VString::wildmatchi(const char* s, const char* p) {
return (*s == '\0'); 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++) { for (; *p; s++, p++) {
if (*p != '*') { if (*p != '*') {
if (((*s) != (*p)) && *p != '?') return false; if (((*s) != (*p)) && *p != '?') return false;
@ -68,7 +68,7 @@ bool VString::wildmatch(const char* s, const char* p) {
return (*s == '\0'); 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()); return wildmatch(s.c_str(), p.c_str());
} }
@ -130,7 +130,7 @@ string VString::escapeStringForPath(const string& str) {
return result; return result;
} }
string VString::spaceUnprintable(const string& str) { string VString::spaceUnprintable(const string& str) VL_PURE {
string out; string out;
for (const char c : str) { for (const char c : str) {
if (std::isprint(c)) { if (std::isprint(c)) {
@ -216,10 +216,12 @@ static const uint32_t sha256K[]
0xc67178f2}; 0xc67178f2};
VL_ATTR_ALWINLINE 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 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]; uint32_t ah[8];
const uint32_t* p = chunk; const uint32_t* p = chunk;

13
src/V3String.h
View File

@ -34,13 +34,14 @@
// Global string-related functions // Global string-related functions
template <class T> template <class T>
std::string cvtToStr(const T& t) { std::string cvtToStr(const T& t) VL_PURE {
std::ostringstream os; std::ostringstream os;
os << t; os << t;
return os.str(); return os.str();
} }
template <class T> 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; std::ostringstream os;
os << static_cast<const void*>(tp); os << static_cast<const void*>(tp);
return os.str(); return os.str();
@ -78,14 +79,14 @@ inline string ucfirst(const string& text) {
// VString - String manipulation // VString - String manipulation
class VString final { class VString final {
static bool wildmatchi(const char* s, const char* p); static bool wildmatchi(const char* s, const char* p) VL_PURE;
public: public:
// METHODS (generic string utilities) // METHODS (generic string utilities)
// Return true if p with ? or *'s matches s // 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 // 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 // Return {a}{dot}{b}, omitting dot if a or b are empty
static string dot(const string& a, const string& dot, const string& b); static string dot(const string& a, const string& dot, const string& b);
// Convert string to lowercase (tolower) // Convert string to lowercase (tolower)
@ -107,7 +108,7 @@ public:
static string quoteStringLiteralForShell(const string& str); static string quoteStringLiteralForShell(const string& str);
// Replace any unprintable with space // Replace any unprintable with space
// This includes removing tabs, so column tracking is correct // 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 // Remove any whitespace
static string removeWhitespace(const string& str); static string removeWhitespace(const string& str);
// Return true if only whitespace or "" // Return true if only whitespace or ""

10
src/astgen
View File

@ -865,7 +865,7 @@ def write_type_enum(prefix, nodeList):
fh.write(" _BOUNDS_END\n") fh.write(" _BOUNDS_END\n")
fh.write(" };\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") fh.write(" static const char* const names[_ENUM_END + 1] = {\n")
for node in sorted(filter(lambda _: _.isLeaf, nodeList), for node in sorted(filter(lambda _: _.isLeaf, nodeList),
key=lambda _: _.typeId): key=lambda _: _.typeId):
@ -931,7 +931,7 @@ def write_ast_macros(filename):
static Ast{t}* cloneTreeNull(Ast{t}* nodep, bool cloneNextLink) {{ static Ast{t}* cloneTreeNull(Ast{t}* nodep, bool cloneNextLink) {{
return nodep ? nodep->cloneTree(cloneNextLink) : nullptr; 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)); }} Ast{t}* addNext(Ast{t}* nodep) {{ return static_cast<Ast{t}*>(AstNode::addNext(this, nodep)); }}
''', ''',
t=node.name) t=node.name)
@ -952,7 +952,7 @@ def write_ast_macros(filename):
"op{n}p()").format(n=n, kind=kind) "op{n}p()").format(n=n, kind=kind)
if monad == "List": if monad == "List":
emitBlock('''\ 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)); }} void add{Name}(Ast{kind}* nodep) {{ addNOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
''', ''',
kind=kind, kind=kind,
@ -962,7 +962,7 @@ def write_ast_macros(filename):
retrieve=retrieve) retrieve=retrieve)
elif monad == "Optional": elif monad == "Optional":
emitBlock('''\ 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)); }} void {name}(Ast{kind}* nodep) {{ setNOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
''', ''',
kind=kind, kind=kind,
@ -971,7 +971,7 @@ def write_ast_macros(filename):
retrieve=retrieve) retrieve=retrieve)
else: else:
emitBlock('''\ 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)); }} void {name}(Ast{kind}* nodep) {{ setOp{n}p(reinterpret_cast<AstNode*>(nodep)); }}
''', ''',
kind=kind, kind=kind,

2
test_regress/t/t_a5_attributes_src.pl
View File

@ -36,7 +36,7 @@ sub check {
tee => 1, tee => 1,
cmd => ["python3", "$root/nodist/clang_check_attributes --verilator-root=$root --cxxflags='$clang_args' $precompile_args $srcfiles_str"]); 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(); run_clang_check();