github/verilator
1
0
Fork 1
mirror of https://github.com/verilator/verilator.git synced 2025-04-05 04:02:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Delete AstNode user5 (#4638)

Browse Source 
This saves about 5% memory. V3AstUserAllocator is appropriate for most use
cases, performance is marginally up as we are mostly D-cache bound on
large designs.
This commit is contained in:
Geza Lore 2023-10-29 01:12:27 +01:00 committed by GitHub
parent 7ba6647c4f
commit 3c144ada53
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 226 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
docs/internals.rst
View File

@ -1222,9 +1222,9 @@ There are three ways data is passed between visitor functions.
2. User attributes. Each ``AstNode`` (**Note.** The AST node, not the 2. User attributes. Each ``AstNode`` (**Note.** The AST node, not the
visitor) has five user attributes, which may be accessed as an visitor) has five user attributes, which may be accessed as an
integer using the ``user1()`` through ``user5()`` methods, or as a integer using the ``user1()`` through ``user4()`` methods, or as a
pointer (of type ``AstNUser``) using the ``user1p()`` through pointer (of type ``AstNUser``) using the ``user1p()`` through
``user5p()`` methods (a common technique lifted from graph traversal ``user4p()`` methods (a common technique lifted from graph traversal
packages). packages).
A visitor first clears the one it wants to use by calling A visitor first clears the one it wants to use by calling
@ -1653,7 +1653,7 @@ Source file and line
file is ``a``, the 26th is ``z``, the 27th is ``aa``, and so on. file is ``a``, the 26th is ``z``, the 27th is ``aa``, and so on.
User pointers User pointers
Shows the value of the node's user1p...user5p, if non-NULL. Shows the value of the node's user1p...user4p, if non-NULL.
Data type Data type
Many nodes have an explicit data type. "@dt=0x..." indicates the Many nodes have an explicit data type. "@dt=0x..." indicates the

3
src/V3Ast.cpp
View File

@ -41,13 +41,11 @@ uint32_t VNUser1InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent
uint32_t VNUser2InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent uint32_t VNUser2InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent
uint32_t VNUser3InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent uint32_t VNUser3InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent
uint32_t VNUser4InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent uint32_t VNUser4InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent
uint32_t VNUser5InUse::s_userCntGbl = 0; // Hot cache line, leave adjacent
bool VNUser1InUse::s_userBusy = false; bool VNUser1InUse::s_userBusy = false;
bool VNUser2InUse::s_userBusy = false; bool VNUser2InUse::s_userBusy = false;
bool VNUser3InUse::s_userBusy = false; bool VNUser3InUse::s_userBusy = false;
bool VNUser4InUse::s_userBusy = false; bool VNUser4InUse::s_userBusy = false;
bool VNUser5InUse::s_userBusy = false;
int AstNodeDType::s_uniqueNum = 0; int AstNodeDType::s_uniqueNum = 0;
@ -1235,7 +1233,6 @@ void AstNode::dumpPtrs(std::ostream& os) const {
if (user2p()) os << " user2p=" << cvtToHex(user2p()); if (user2p()) os << " user2p=" << cvtToHex(user2p());
if (user3p()) os << " user3p=" << cvtToHex(user3p()); if (user3p()) os << " user3p=" << cvtToHex(user3p());
if (user4p()) os << " user4p=" << cvtToHex(user4p()); if (user4p()) os << " user4p=" << cvtToHex(user4p());
if (user5p()) os << " user5p=" << cvtToHex(user5p());
if (m_iterpp) { if (m_iterpp) {
os << " iterpp=" << cvtToHex(m_iterpp); os << " iterpp=" << cvtToHex(m_iterpp);
// This may cause address sanitizer failures as iterpp can be stale // This may cause address sanitizer failures as iterpp can be stale

27
src/V3Ast.h
View File

@ -1611,17 +1611,6 @@ public:
static void clear() { clearcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void clear() { clearcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
static void check() { checkcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); } static void check() { checkcnt(4, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
}; };
class VNUser5InUse final : VNUserInUseBase {
protected:
friend class AstNode;
static uint32_t s_userCntGbl; // Count of which usage of userp() this is
static bool s_userBusy; // Count is in use
public:
VNUser5InUse() { allocate(5, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
~VNUser5InUse() { free (5, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
static void clear() { clearcnt(5, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
static void check() { checkcnt(5, s_userCntGbl/*ref*/, s_userBusy/*ref*/); }
};
// clang-format on // clang-format on
//###################################################################### //######################################################################
@ -1825,8 +1814,6 @@ class AstNode VL_NOT_FINAL {
uint32_t m_user3Cnt = 0; // Mark of when userp was set uint32_t m_user3Cnt = 0; // Mark of when userp was set
uint32_t m_user4Cnt = 0; // Mark of when userp was set uint32_t m_user4Cnt = 0; // Mark of when userp was set
VNUser m_user4u{0}; // Contains any information the user iteration routine wants VNUser m_user4u{0}; // Contains any information the user iteration routine wants
VNUser m_user5u{0}; // Contains any information the user iteration routine wants
uint32_t m_user5Cnt = 0; // Mark of when userp was set
// METHODS // METHODS
void op1p(AstNode* nodep) { void op1p(AstNode* nodep) {
@ -2074,20 +2061,6 @@ public:
int user4Inc(int val = 1) { int v = user4(); user4(v + val); return v; } int user4Inc(int val = 1) { int v = user4(); user4(v + val); return v; }
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_STABLE {
// Slows things down measurably, so disabled by default
//UASSERT_STATIC(VNUser5InUse::s_userBusy, "user5p used without AstUserInUse");
return ((m_user5Cnt == VNUser5InUse::s_userCntGbl) ? m_user5u : VNUser{0});
}
AstNode* user5p() const VL_MT_STABLE { return user5u().toNodep(); }
void user5u(const VNUser& user) { m_user5u = user; m_user5Cnt = VNUser5InUse::s_userCntGbl; }
void user5p(void* userp) { user5u(VNUser{userp}); }
void user5(int val) { user5u(VNUser{val}); }
int user5() const { return user5u().toInt(); }
int user5Inc(int val = 1) { int v = user5(); user5(v + val); return v; }
int user5SetOnce() { int v = user5(); if (!v) user5(1); return v; } // Better for cache than user5Inc()
static void user5ClearTree() { VNUser5InUse::clear(); } // Clear userp()'s across the entire tree
// clang-format on // clang-format on
#ifdef VL_DEBUG #ifdef VL_DEBUG

1
src/V3AstNodes.cpp
View File

@ -1379,7 +1379,6 @@ void AstNode::dump(std::ostream& str) const {
if (user2p()) str << " u2=" << nodeAddr(user2p()); if (user2p()) str << " u2=" << nodeAddr(user2p());
if (user3p()) str << " u3=" << nodeAddr(user3p()); if (user3p()) str << " u3=" << nodeAddr(user3p());
if (user4p()) str << " u4=" << nodeAddr(user4p()); if (user4p()) str << " u4=" << nodeAddr(user4p());
if (user5p()) str << " u5=" << nodeAddr(user5p());
if (hasDType()) { if (hasDType()) {
// Final @ so less likely to by accident read it as a nodep // Final @ so less likely to by accident read it as a nodep
if (dtypep() == this) { if (dtypep() == this) {

19
src/V3AstUserAllocator.h
View File

@ -29,7 +29,7 @@
template <class T_Node, class T_Data, int T_UserN> template <class T_Node, class T_Data, int T_UserN>
class AstUserAllocatorBase VL_NOT_FINAL { class AstUserAllocatorBase VL_NOT_FINAL {
static_assert(1 <= T_UserN && T_UserN <= 5, "Wrong user pointer number"); static_assert(1 <= T_UserN && T_UserN <= 4, "Wrong user pointer number");
static_assert(std::is_base_of<AstNode, T_Node>::value, "T_Node must be an AstNode type"); static_assert(std::is_base_of<AstNode, T_Node>::value, "T_Node must be an AstNode type");
private: private:
@ -45,11 +45,8 @@ private:
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) { } else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
const VNUser user = nodep->user3u(); const VNUser user = nodep->user3u();
return user.to<T_Data*>(); return user.to<T_Data*>();
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
const VNUser user = nodep->user4u();
return user.to<T_Data*>();
} else { } else {
const VNUser user = nodep->user5u(); const VNUser user = nodep->user4u();
return user.to<T_Data*>(); return user.to<T_Data*>();
} }
} }
@ -61,10 +58,8 @@ private:
nodep->user2u(VNUser{userp}); nodep->user2u(VNUser{userp});
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) { } else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
nodep->user3u(VNUser{userp}); nodep->user3u(VNUser{userp});
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
nodep->user4u(VNUser{userp});
} else { } else {
nodep->user5u(VNUser{userp}); nodep->user4u(VNUser{userp});
} }
} }
@ -76,10 +71,8 @@ protected:
VNUser2InUse::check(); VNUser2InUse::check();
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) { } else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
VNUser3InUse::check(); VNUser3InUse::check();
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
VNUser4InUse::check();
} else { } else {
VNUser5InUse::check(); VNUser4InUse::check();
} }
} }
@ -107,6 +100,8 @@ public:
// Get a pointer to the user data if exists, otherwise nullptr // Get a pointer to the user data if exists, otherwise nullptr
T_Data* tryGet(const T_Node* nodep) { return getUserp(nodep); } T_Data* tryGet(const T_Node* nodep) { return getUserp(nodep); }
void clear() { m_allocated.clear(); }
}; };
// User pointer allocator classes. T_Node is the type of node the allocator should be applied to // User pointer allocator classes. T_Node is the type of node the allocator should be applied to
@ -120,7 +115,5 @@ template <class T_Node, class T_Data>
class AstUser3Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 3> {}; class AstUser3Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 3> {};
template <class T_Node, class T_Data> template <class T_Node, class T_Data>
class AstUser4Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 4> {}; class AstUser4Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 4> {};
template <class T_Node, class T_Data>
class AstUser5Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 5> {};
#endif // Guard #endif // Guard

60
src/V3Delayed.cpp
View File

@ -52,6 +52,7 @@
#include "V3Delayed.h" #include "V3Delayed.h"
#include "V3AstUserAllocator.h"
#include "V3Stats.h" #include "V3Stats.h"
#include <deque> #include <deque>
@ -65,27 +66,33 @@ class DelayedVisitor final : public VNVisitor {
private: private:
// NODE STATE // NODE STATE
// Cleared each module: // Cleared each module:
// AstVarScope::user1p() -> AstVarScope*. Points to temp var created. // AstVarScope::user1p() -> aux
// AstVarScope::user2p() -> AstActive*. Points to activity block of signal
// (valid when AstVarScope::user1p is valid)
// AstVarScope::user3p() -> AstAlwaysPost*. Post block for this variable used for
// AssignDlys in suspendable processes
// AstVarScope::user4p() -> AstAlwaysPost*. Post block for this variable
// AstVarScope::user5p() -> AstVarRef*. Last blocking or non-blocking reference
// AstVar::user2() -> bool. Set true if already made warning // AstVar::user2() -> bool. Set true if already made warning
// AstVarRef::user1() -> bool. Set true if was blocking reference
// AstVarRef::user2() -> bool. Set true if already processed // AstVarRef::user2() -> bool. Set true if already processed
// AstVarRef::user5() -> bool. Set true if was blocking reference // AstAlwaysPost::user1() -> AstIf*. Last IF (__Vdlyvset__) created under this AlwaysPost
// AstAlwaysPost::user2() -> ActActive*. Points to activity block of signal // AstAlwaysPost::user2() -> ActActive*. Points to activity block of signal
// (valid when AstAlwaysPost::user4p is valid) // (valid when AstAlwaysPost::user4p is valid)
// AstAlwaysPost::user4() -> AstIf*. Last IF (__Vdlyvset__) created under this AlwaysPost
// Cleared each scope/active: // Cleared each scope/active:
// AstAssignDly::user3() -> AstVarScope*. __Vdlyvset__ created for this assign // AstAssignDly::user3() -> AstVarScope*. __Vdlyvset__ created for this assign
// AstAlwaysPost::user3() -> AstVarScope*. __Vdlyvset__ last referenced in IF // AstAlwaysPost::user3() -> AstVarScope*. __Vdlyvset__ last referenced in IF
const VNUser1InUse m_inuser1; const VNUser1InUse m_inuser1;
const VNUser2InUse m_inuser2; const VNUser2InUse m_inuser2;
const VNUser3InUse m_inuser3; const VNUser3InUse m_inuser3;
const VNUser4InUse m_inuser4;
const VNUser5InUse m_inuser5; struct AuxAstVarScope final {
// Points to temp (shadow) variable created.
AstVarScope* delayVscp = nullptr;
// Points to activity block of signal (valid when AstVarScope::user1p is valid)
AstActive* activep = nullptr;
// Post block for this variable used for AssignDlys in suspendable processes
AstAlwaysPost* suspFinalp = nullptr;
// Post block for this variable
AstAlwaysPost* finalp = nullptr;
// Last blocking or non-blocking reference
AstNodeVarRef* lastRefp = nullptr;
};
AstUser1Allocator<AstVarScope, AuxAstVarScope> m_vscpAux;
// STATE - across all visitors // STATE - across all visitors
std::unordered_map<const AstVarScope*, int> m_scopeVecMap; // Next var number for each scope std::unordered_map<const AstVarScope*, int> m_scopeVecMap; // Next var number for each scope
@ -116,14 +123,14 @@ private:
// Ignore if warning is disabled on this reference (used by V3Force). // Ignore if warning is disabled on this reference (used by V3Force).
if (nodep->fileline()->warnIsOff(V3ErrorCode::BLKANDNBLK)) return; if (nodep->fileline()->warnIsOff(V3ErrorCode::BLKANDNBLK)) return;
if (m_ignoreBlkAndNBlk) return; if (m_ignoreBlkAndNBlk) return;
if (blocking) nodep->user5(true); if (blocking) nodep->user1(true);
AstVarScope* const vscp = nodep->varScopep(); AstVarScope* const vscp = nodep->varScopep();
// UINFO(4, " MVU " << blocking << " " << nodep << endl); // UINFO(4, " MVU " << blocking << " " << nodep << endl);
const AstNode* const lastrefp = vscp->user5p(); const AstNode* const lastrefp = m_vscpAux(vscp).lastRefp;
if (!lastrefp) { if (!lastrefp) {
vscp->user5p(nodep); m_vscpAux(vscp).lastRefp = nodep;
} else { } else {
const bool last_was_blocking = lastrefp->user5(); const bool last_was_blocking = lastrefp->user1();
if (last_was_blocking != blocking) { if (last_was_blocking != blocking) {
const AstNode* nonblockingp = blocking ? nodep : lastrefp; const AstNode* nonblockingp = blocking ? nodep : lastrefp;
if (const AstNode* np = containingAssignment(nonblockingp)) nonblockingp = np; if (const AstNode* np = containingAssignment(nonblockingp)) nonblockingp = np;
@ -351,7 +358,7 @@ private:
UINFO(9, " & " << varrefp << endl); UINFO(9, " & " << varrefp << endl);
AstAlwaysPost* finalp = nullptr; AstAlwaysPost* finalp = nullptr;
if (m_inSuspendableOrFork) { if (m_inSuspendableOrFork) {
finalp = VN_AS(varrefp->varScopep()->user3p(), AlwaysPost); finalp = m_vscpAux(varrefp->varScopep()).suspFinalp;
if (!finalp) { if (!finalp) {
FileLine* const flp = nodep->fileline(); FileLine* const flp = nodep->fileline();
finalp = new AstAlwaysPost{flp, nullptr, nullptr}; finalp = new AstAlwaysPost{flp, nullptr, nullptr};
@ -359,13 +366,13 @@ private:
if (!m_procp->user3p()) { if (!m_procp->user3p()) {
AstActive* const newactp = createActive(varrefp); AstActive* const newactp = createActive(varrefp);
m_procp->user3p(newactp); m_procp->user3p(newactp);
varrefp->varScopep()->user3p(finalp); m_vscpAux(varrefp->varScopep()).suspFinalp = finalp;
} }
AstActive* const actp = VN_AS(m_procp->user3p(), Active); AstActive* const actp = VN_AS(m_procp->user3p(), Active);
actp->addStmtsp(finalp); actp->addStmtsp(finalp);
} }
} else { } else {
finalp = VN_AS(varrefp->varScopep()->user4p(), AlwaysPost); finalp = m_vscpAux(varrefp->varScopep()).finalp;
if (finalp) { if (finalp) {
AstActive* const oldactivep = VN_AS(finalp->user2p(), Active); AstActive* const oldactivep = VN_AS(finalp->user2p(), Active);
checkActivePost(varrefp, oldactivep); checkActivePost(varrefp, oldactivep);
@ -375,7 +382,7 @@ private:
UINFO(9, " Created " << finalp << endl); UINFO(9, " Created " << finalp << endl);
AstActive* const newactp = createActive(varrefp); AstActive* const newactp = createActive(varrefp);
newactp->addStmtsp(finalp); newactp->addStmtsp(finalp);
varrefp->varScopep()->user4p(finalp); m_vscpAux(varrefp->varScopep()).finalp = finalp;
finalp->user2p(newactp); finalp->user2p(newactp);
if (setinitp) newactp->addStmtsp(setinitp); if (setinitp) newactp->addStmtsp(setinitp);
} }
@ -384,7 +391,7 @@ private:
if (finalp->user3p() == setvscp) { if (finalp->user3p() == setvscp) {
// Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*, // Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*,
// we can share the IF statement too // we can share the IF statement too
postLogicp = VN_AS(finalp->user4p(), If); postLogicp = VN_AS(finalp->user1p(), If);
UASSERT_OBJ(postLogicp, nodep, UASSERT_OBJ(postLogicp, nodep,
"Delayed assignment misoptimized; prev var found w/o associated IF"); "Delayed assignment misoptimized; prev var found w/o associated IF");
} else { } else {
@ -393,7 +400,7 @@ private:
UINFO(9, " Created " << postLogicp << endl); UINFO(9, " Created " << postLogicp << endl);
finalp->addStmtsp(postLogicp); finalp->addStmtsp(postLogicp);
finalp->user3p(setvscp); // Remember IF's vset variable finalp->user3p(setvscp); // Remember IF's vset variable
finalp->user4p(postLogicp); // and the associated IF, as we may be able to reuse it finalp->user1p(postLogicp); // and the associated IF, as we may be able to reuse it
} }
postLogicp->addThensp(new AstAssign{nodep->fileline(), selectsp, valreadp}); postLogicp->addThensp(new AstAssign{nodep->fileline(), selectsp, valreadp});
if (m_inSuspendableOrFork) { if (m_inSuspendableOrFork) {
@ -565,12 +572,11 @@ private:
} }
AstVarScope* const oldvscp = nodep->varScopep(); AstVarScope* const oldvscp = nodep->varScopep();
UASSERT_OBJ(oldvscp, nodep, "Var didn't get varscoped in V3Scope.cpp"); UASSERT_OBJ(oldvscp, nodep, "Var didn't get varscoped in V3Scope.cpp");
AstVarScope* dlyvscp = VN_AS(oldvscp->user1p(), VarScope); AstVarScope* dlyvscp = m_vscpAux(oldvscp).delayVscp;
if (dlyvscp) { // Multiple use of delayed variable if (dlyvscp) { // Multiple use of delayed variable
AstActive* const oldactivep = VN_AS(dlyvscp->user2p(), Active); AstActive* const oldactivep = m_vscpAux(dlyvscp).activep;
checkActivePost(nodep, oldactivep); checkActivePost(nodep, oldactivep);
} } else { // First use of this delayed variable
if (!dlyvscp) { // First use of this delayed variable
const string newvarname = string{"__Vdly__"} + nodep->varp()->shortName(); const string newvarname = string{"__Vdly__"} + nodep->varp()->shortName();
dlyvscp = createVarSc(oldvscp, newvarname, 0, nullptr); dlyvscp = createVarSc(oldvscp, newvarname, 0, nullptr);
AstNodeAssign* const prep = new AstAssignPre{ AstNodeAssign* const prep = new AstAssignPre{
@ -582,10 +588,10 @@ private:
new AstVarRef{nodep->fileline(), oldvscp, VAccess::WRITE}, new AstVarRef{nodep->fileline(), oldvscp, VAccess::WRITE},
new AstVarRef{nodep->fileline(), dlyvscp, VAccess::READ}}; new AstVarRef{nodep->fileline(), dlyvscp, VAccess::READ}};
postp->lhsp()->user2(true); // Don't detect this assignment postp->lhsp()->user2(true); // Don't detect this assignment
oldvscp->user1p(dlyvscp); // So we can find it later m_vscpAux(oldvscp).delayVscp = dlyvscp; // So we can find it later
// Make new ACTIVE with identical sensitivity tree // Make new ACTIVE with identical sensitivity tree
AstActive* const newactp = createActive(nodep); AstActive* const newactp = createActive(nodep);
dlyvscp->user2p(newactp); m_vscpAux(dlyvscp).activep = newactp;
newactp->addStmtsp(prep); // Add to FRONT of statements newactp->addStmtsp(prep); // Add to FRONT of statements
newactp->addStmtsp(postp); newactp->addStmtsp(postp);
} }

64
src/V3Gate.cpp
View File

@ -766,15 +766,22 @@ class GateDedupeHash final : public V3DupFinderUserSame {
private: private:
// NODE STATE // NODE STATE
// Ast*::user2p -> parent AstNodeAssign* for this rhsp // Ast*::user2p -> parent AstNodeAssign* for this rhsp
// Ast*::user3p -> AstActive* of assign, for isSame() in test for duplicate // AstNodeExpr::user3p -> see AuxAstNodeExpr via m_aux
// Set to nullptr if this assign's tree was later replaced
// Ast*::user5p -> AstNode* of assign if condition, for isSame() in test for duplicate
// Set to nullptr if this assign's tree was later replaced
// VNUser1InUse m_inuser1; (Allocated for use in GateVisitor) // VNUser1InUse m_inuser1; (Allocated for use in GateVisitor)
// VNUser2InUse m_inuser2; (Allocated for use in GateVisitor) // VNUser2InUse m_inuser2; (Allocated for use in GateVisitor)
const VNUser3InUse m_inuser3; const VNUser3InUse m_inuser3;
// VNUser4InUse m_inuser4; (Allocated for use in V3Hasher via V3DupFinder) // VNUser4InUse m_inuser4; (Allocated for use in V3Hasher via V3DupFinder)
const VNUser5InUse m_inuser5;
struct AuxAstNodeExpr final {
// AstActive* of assign, for isSame() in test for duplicate. Set to nullptr if this
// assign's tree was later replaced
AstActive* activep = nullptr;
// AstNodeExpr* of assign if condition, for isSame() in test for duplicate. Set to nullptr
// if this assign's tree was later replaced
AstNodeExpr* condp = nullptr;
};
AstUser3Allocator<AstNodeExpr, AuxAstNodeExpr> m_auxNodeExpr;
V3DupFinder m_dupFinder; // Duplicate finder for rhs of assigns V3DupFinder m_dupFinder; // Duplicate finder for rhs of assigns
std::unordered_set<AstNode*> m_nodeDeleteds; // Any node in this hash was deleted std::unordered_set<AstNode*> m_nodeDeleteds; // Any node in this hash was deleted
@ -814,41 +821,49 @@ public:
// or could be a rhs variable in a tree we're not replacing (or not yet anyways) // or could be a rhs variable in a tree we're not replacing (or not yet anyways)
void hashReplace(AstNode* oldp, AstNode* newp) { void hashReplace(AstNode* oldp, AstNode* newp) {
UINFO(9, "replacing " << (void*)oldp << " with " << (void*)newp << endl); UINFO(9, "replacing " << (void*)oldp << " with " << (void*)newp << endl);
// We could update the user3p and user5p but the resulting node // We could update the activep and condp but the resulting node
// still has incorrect hash. We really need to remove all hash on // still has incorrect hash. We really need to remove all hash on
// the whole hash entry tree involving the replaced node and // the whole hash entry tree involving the replaced node and
// rehash. That's complicated and this is rare, so just remove it // rehash. That's complicated and this is rare, so just remove it
// from consideration. // from consideration.
m_nodeDeleteds.insert(oldp); m_nodeDeleteds.insert(oldp);
} }
bool isReplaced(AstNode* nodep) { bool isReplaced(AstNodeExpr* nodep) {
// Assignment may have been hashReplaced, if so consider non-match (effectively removed) // Assignment may have been hashReplaced, if so consider non-match (effectively removed)
UASSERT_OBJ(!VN_IS(nodep, NodeAssign), nodep, "Dedup attempt on non-assign"); const auto& aux = m_auxNodeExpr(nodep);
AstNode* const extra1p = nodep->user3p(); AstActive* const activep = aux.activep;
AstNode* const extra2p = nodep->user5p(); AstNodeExpr* const condp = aux.condp;
return ((extra1p && m_nodeDeleteds.find(extra1p) != m_nodeDeleteds.end()) return (activep && m_nodeDeleteds.count(activep))
|| (extra2p && m_nodeDeleteds.find(extra2p) != m_nodeDeleteds.end())); || (condp && m_nodeDeleteds.count(condp));
} }
// Callback from V3DupFinder::findDuplicate // Callback from V3DupFinder::findDuplicate
bool isSame(AstNode* node1p, AstNode* node2p) override { bool isSame(AstNode* node1p, AstNode* node2p) override {
AstNodeExpr* const expr1p = VN_AS(node1p, NodeExpr);
AstNodeExpr* const expr2p = VN_AS(node2p, NodeExpr);
// Assignment may have been hashReplaced, if so consider non-match (effectively removed) // Assignment may have been hashReplaced, if so consider non-match (effectively removed)
if (isReplaced(node1p) || isReplaced(node2p)) { if (isReplaced(expr1p) || isReplaced(expr2p)) {
// UINFO(9, "isSame hit on replaced "<<(void*)node1p<<" "<<(void*)node2p<<endl); // UINFO(9, "isSame hit on replaced "<<(void*)node1p<<" "<<(void*)node2p<<endl);
return false; return false;
} }
return same(node1p->user3p(), node2p->user3p()) && same(node1p->user5p(), node2p->user5p())
const auto& aux1 = m_auxNodeExpr(expr1p);
const auto& aux2 = m_auxNodeExpr(expr2p);
return same(aux1.activep, aux2.activep) && same(aux1.condp, aux2.condp)
&& node1p->user2p()->type() == node2p->user2p()->type(); && node1p->user2p()->type() == node2p->user2p()->type();
} }
const AstNodeAssign* hashAndFindDupe(AstNodeAssign* assignp, AstNode* extra1p, const AstNodeAssign* hashAndFindDupe(AstNodeAssign* assignp, AstActive* extra1p,
AstNode* extra2p) { AstNodeExpr* extra2p) {
// Legal for extra1p/2p to be nullptr, we'll compare with other assigns with extras also // Legal for extra1p/2p to be nullptr, we'll compare with other assigns with extras also
// nullptr // nullptr
AstNode* const rhsp = assignp->rhsp(); AstNodeExpr* const rhsp = assignp->rhsp();
rhsp->user2p(assignp); rhsp->user2p(assignp);
rhsp->user3p(extra1p); auto& aux = m_auxNodeExpr(rhsp);
rhsp->user5p(extra2p); aux.activep = extra1p;
aux.condp = extra2p;
const auto inserted = m_dupFinder.insert(rhsp); const auto inserted = m_dupFinder.insert(rhsp);
const auto dupit = m_dupFinder.findDuplicate(rhsp, this); const auto dupit = m_dupFinder.findDuplicate(rhsp, this);
@ -865,13 +880,14 @@ public:
void check() { void check() {
for (const auto& itr : m_dupFinder) { for (const auto& itr : m_dupFinder) {
AstNode* const nodep = itr.second; AstNodeExpr* const nodep = VN_AS(itr.second, NodeExpr);
const AstNode* const activep = nodep->user3p(); const auto& aux = m_auxNodeExpr(nodep);
const AstNode* const condVarp = nodep->user5p(); const AstActive* const activep = aux.activep;
const AstNodeExpr* const condVarp = aux.condp;
if (!isReplaced(nodep)) { if (!isReplaced(nodep)) {
// This class won't break if activep isn't an active, or // This class won't break if activep isn't an active, or
// ifVar isn't a var, but this is checking the caller's construction. // ifVar isn't a var, but this is checking the caller's construction.
UASSERT_OBJ(!activep || (!VN_DELETED(activep) && VN_IS(activep, Active)), nodep, UASSERT_OBJ(!activep || (!VN_DELETED(activep)), nodep,
"V3DupFinder check failed, lost active pointer"); "V3DupFinder check failed, lost active pointer");
UASSERT_OBJ(!condVarp || !VN_DELETED(condVarp), nodep, UASSERT_OBJ(!condVarp || !VN_DELETED(condVarp), nodep,
"V3DupFinder check failed, lost if pointer"); "V3DupFinder check failed, lost if pointer");
@ -899,7 +915,7 @@ private:
// STATE // STATE
GateDedupeHash m_ghash; // Hash used to find dupes of rhs of assign GateDedupeHash m_ghash; // Hash used to find dupes of rhs of assign
AstNodeAssign* m_assignp = nullptr; // Assign found for dedupe AstNodeAssign* m_assignp = nullptr; // Assign found for dedupe
AstNode* m_ifCondp = nullptr; // IF condition that assign is under AstNodeExpr* m_ifCondp = nullptr; // IF condition that assign is under
bool m_always = false; // Assign is under an always bool m_always = false; // Assign is under an always
bool m_dedupable = true; // Determined the assign to be dedupable bool m_dedupable = true; // Determined the assign to be dedupable

9
src/V3Inline.cpp
View File

@ -343,8 +343,8 @@ private:
newdp->cellName(newcellp->name()); newdp->cellName(newcellp->name());
// Tag the old ifacerefp to ensure it leaves no stale // Tag the old ifacerefp to ensure it leaves no stale
// reference to the inlined cell. // reference to the inlined cell.
newdp->user5(false); newdp->user1(false);
ifacerefp->user5(true); ifacerefp->user1(true);
} }
} }
} }
@ -454,7 +454,7 @@ class InlineVisitor final : public VNVisitor {
private: private:
// NODE STATE // NODE STATE
// Cleared entire netlist // Cleared entire netlist
// AstIfaceRefDType::user5p() // Whether the cell pointed to by this // AstIfaceRefDType::user1() // Whether the cell pointed to by this
// // AstIfaceRefDType has been inlined // // AstIfaceRefDType has been inlined
// Input: // Input:
// AstNodeModule::user1p() // ModuleState instance (via m_moduleState) // AstNodeModule::user1p() // ModuleState instance (via m_moduleState)
@ -464,7 +464,6 @@ private:
// AstVar::user3() // bool Don't alias the user2, keep it as signal // AstVar::user3() // bool Don't alias the user2, keep it as signal
// AstCell::user4 // AstCell* of the created clone // AstCell::user4 // AstCell* of the created clone
const VNUser4InUse m_inuser4; const VNUser4InUse m_inuser4;
const VNUser5InUse m_inuser5;
ModuleStateUser1Allocator& m_moduleState; ModuleStateUser1Allocator& m_moduleState;
@ -586,7 +585,7 @@ private:
m_modp = nullptr; m_modp = nullptr;
} }
void visit(AstIfaceRefDType* nodep) override { void visit(AstIfaceRefDType* nodep) override {
if (nodep->user5()) { if (nodep->user1()) {
// The cell has been removed so let's make sure we don't leave a reference to it // The cell has been removed so let's make sure we don't leave a reference to it
// This dtype may still be in use by the AstAssignVarScope created earlier // This dtype may still be in use by the AstAssignVarScope created earlier
// but that'll get cleared up later // but that'll get cleared up later

26
src/V3InstrCount.cpp
View File

@ -32,9 +32,9 @@ VL_DEFINE_DEBUG_FUNCTIONS;
class InstrCountVisitor final : public VNVisitorConst { class InstrCountVisitor final : public VNVisitorConst {
private: private:
// NODE STATE // NODE STATE
// AstNode::user4() -> int. Path cost + 1, 0 means don't dump // AstNode::user1() -> bool. Processed if assertNoDups
// AstNode::user5() -> bool. Processed if assertNoDups // AstNode::user2() -> int. Path cost + 1, 0 means don't dump
const VNUser4InUse m_inuser4; const VNUser2InUse m_inuser2;
// MEMBERS // MEMBERS
uint32_t m_instrCount = 0; // Running count of instructions uint32_t m_instrCount = 0; // Running count of instructions
@ -99,10 +99,10 @@ private:
// (which at the V3Order stage represent verilog tasks, not to // (which at the V3Order stage represent verilog tasks, not to
// the CFuncs that V3Order will generate.) So don't check for // the CFuncs that V3Order will generate.) So don't check for
// collisions in CFuncs. // collisions in CFuncs.
UASSERT_OBJ(!nodep->user5p(), nodep, UASSERT_OBJ(!nodep->user1p(), nodep,
"Node originally inserted below logic vertex " "Node originally inserted below logic vertex "
<< static_cast<AstNode*>(nodep->user5p())); << static_cast<AstNode*>(nodep->user1p()));
nodep->user5p(const_cast<void*>(reinterpret_cast<const void*>(m_startNodep))); nodep->user1p(const_cast<void*>(reinterpret_cast<const void*>(m_startNodep)));
} }
// Save the count, and add it back in during ~VisitBase This allows // Save the count, and add it back in during ~VisitBase This allows
@ -118,7 +118,7 @@ private:
if (!m_ignoreRemaining) m_instrCount += savedCount; if (!m_ignoreRemaining) m_instrCount += savedCount;
} }
void markCost(AstNode* nodep) { void markCost(AstNode* nodep) {
if (m_osp) nodep->user4(m_instrCount + 1); // Else don't mark to avoid writeback if (m_osp) nodep->user2(m_instrCount + 1); // Else don't mark to avoid writeback
} }
// VISITORS // VISITORS
@ -185,10 +185,10 @@ private:
reset(); reset();
if (ifCount >= elseCount) { if (ifCount >= elseCount) {
m_instrCount = savedCount + ifCount; m_instrCount = savedCount + ifCount;
if (nodep->elsesp()) nodep->elsesp()->user4(0); // Don't dump it if (nodep->elsesp()) nodep->elsesp()->user2(0); // Don't dump it
} else { } else {
m_instrCount = savedCount + elseCount; m_instrCount = savedCount + elseCount;
if (nodep->thensp()) nodep->thensp()->user4(0); // Don't dump it if (nodep->thensp()) nodep->thensp()->user2(0); // Don't dump it
} }
} }
void visit(AstNodeCond* nodep) override { void visit(AstNodeCond* nodep) override {
@ -212,10 +212,10 @@ private:
reset(); reset();
if (ifCount < elseCount) { if (ifCount < elseCount) {
m_instrCount = savedCount + elseCount; m_instrCount = savedCount + elseCount;
if (nodep->thenp()) nodep->thenp()->user4(0); // Don't dump it if (nodep->thenp()) nodep->thenp()->user2(0); // Don't dump it
} else { } else {
m_instrCount = savedCount + ifCount; m_instrCount = savedCount + ifCount;
if (nodep->elsep()) nodep->elsep()->user4(0); // Don't dump it if (nodep->elsep()) nodep->elsep()->user2(0); // Don't dump it
} }
} }
void visit(AstCAwait* nodep) override { void visit(AstCAwait* nodep) override {
@ -289,7 +289,7 @@ private:
class InstrCountDumpVisitor final : public VNVisitorConst { class InstrCountDumpVisitor final : public VNVisitorConst {
private: private:
// NODE STATE // NODE STATE
// AstNode::user4() -> int. Path cost, 0 means don't dump // AstNode::user2() -> int. Path cost, 0 means don't dump
// MEMBERS // MEMBERS
std::ostream* const m_osp; // Dump file std::ostream* const m_osp; // Dump file
@ -310,7 +310,7 @@ private:
string indent() const { return string(m_depth, ':') + " "; } string indent() const { return string(m_depth, ':') + " "; }
void visit(AstNode* nodep) override { void visit(AstNode* nodep) override {
++m_depth; ++m_depth;
if (unsigned costPlus1 = nodep->user4()) { if (unsigned costPlus1 = nodep->user2()) {
*m_osp << " " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1) *m_osp << " " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1)
<< " " << nodep << '\n'; << " " << nodep << '\n';
iterateChildrenConst(nodep); iterateChildrenConst(nodep);

2
src/V3InstrCount.h
View File

@ -36,7 +36,7 @@ public:
// If nodep is an AstActive, returns 0. // If nodep is an AstActive, returns 0.
// If nodep contains nested AstActives, raises an error. // If nodep contains nested AstActives, raises an error.
// //
// If assertNoDups is true, marks user5 on each AstNode scanned. Then // If assertNoDups is true, marks user1 on each AstNode scanned. Then
// if we see the same node twice (across more than one call to count, // if we see the same node twice (across more than one call to count,
// potentially) raises an error. // potentially) raises an error.
// Optional osp is stream to dump critical path to. // Optional osp is stream to dump critical path to.

24
src/V3LinkDot.cpp
View File

@ -2004,10 +2004,7 @@ private:
// *::user2p() -> See LinkDotState // *::user2p() -> See LinkDotState
// *::user3() // bool. Processed // *::user3() // bool. Processed
// *::user4() -> See LinkDotState // *::user4() -> See LinkDotState
// Cleared on Cell
// AstVar::user5() // bool. True if pin used in this cell
const VNUser3InUse m_inuser3; const VNUser3InUse m_inuser3;
const VNUser5InUse m_inuser5;
// TYPES // TYPES
enum DotPosition : uint8_t { enum DotPosition : uint8_t {
@ -2034,6 +2031,7 @@ private:
// They are added to the set only in linkDotPrimary. // They are added to the set only in linkDotPrimary.
bool m_insideClassExtParam = false; // Inside a class from m_extendsParam bool m_insideClassExtParam = false; // Inside a class from m_extendsParam
bool m_explicitSuperNew = false; // Hit a "super.new" call inside a "new" function bool m_explicitSuperNew = false; // Hit a "super.new" call inside a "new" function
std::map<AstNode*, AstPin*> m_usedPins; // Pin used in this cell, map to duplicate
struct DotStates { struct DotStates {
DotPosition m_dotPos; // Scope part of dotted resolution DotPosition m_dotPos; // Scope part of dotted resolution
@ -2162,15 +2160,15 @@ private:
UASSERT_OBJ(ifaceTopVarp, nodep, "Can't find interface var ref: " << findName); UASSERT_OBJ(ifaceTopVarp, nodep, "Can't find interface var ref: " << findName);
return ifaceTopVarp; return ifaceTopVarp;
} }
void markAndCheckPinDup(AstNode* nodep, AstNode* refp, const char* whatp) { void markAndCheckPinDup(AstPin* nodep, AstNode* refp, const char* whatp) {
if (refp->user5p() && refp->user5p() != nodep) { const auto pair = m_usedPins.emplace(refp, nodep);
if (!pair.second) {
AstNode* const origp = pair.first->second;
nodep->v3error("Duplicate " << whatp << " connection: " << nodep->prettyNameQ() << '\n' nodep->v3error("Duplicate " << whatp << " connection: " << nodep->prettyNameQ() << '\n'
<< nodep->warnContextPrimary() << '\n' << nodep->warnContextPrimary() << '\n'
<< refp->user5p()->warnOther() << origp->warnOther() << "... Location of original "
<< "... Location of original " << whatp << " connection\n" << whatp << " connection\n"
<< refp->user5p()->warnContextSecondary()); << origp->warnContextSecondary());
} else {
refp->user5p(nodep);
} }
} }
VSymEnt* getCreateClockingEventSymEnt(AstClocking* clockingp) { VSymEnt* getCreateClockingEventSymEnt(AstClocking* clockingp) {
@ -2314,7 +2312,7 @@ private:
void visit(AstCell* nodep) override { void visit(AstCell* nodep) override {
// Cell: Recurse inside or cleanup not founds // Cell: Recurse inside or cleanup not founds
checkNoDot(nodep); checkNoDot(nodep);
AstNode::user5ClearTree(); m_usedPins.clear();
UASSERT_OBJ(nodep->modp(), nodep, UASSERT_OBJ(nodep->modp(), nodep,
"Cell has unlinked module"); // V3LinkCell should have errored out "Cell has unlinked module"); // V3LinkCell should have errored out
VL_RESTORER(m_cellp); VL_RESTORER(m_cellp);
@ -2343,7 +2341,7 @@ private:
void visit(AstClassRefDType* nodep) override { void visit(AstClassRefDType* nodep) override {
// Cell: Recurse inside or cleanup not founds // Cell: Recurse inside or cleanup not founds
checkNoDot(nodep); checkNoDot(nodep);
AstNode::user5ClearTree(); m_usedPins.clear();
UASSERT_OBJ(nodep->classp(), nodep, "ClassRef has unlinked class"); UASSERT_OBJ(nodep->classp(), nodep, "ClassRef has unlinked class");
UASSERT_OBJ(m_statep->forPrimary() || !nodep->paramsp(), nodep, UASSERT_OBJ(m_statep->forPrimary() || !nodep->paramsp(), nodep,
"class reference parameter not removed by V3Param"); "class reference parameter not removed by V3Param");
@ -2905,7 +2903,7 @@ private:
void visit(AstClassOrPackageRef* nodep) override { void visit(AstClassOrPackageRef* nodep) override {
// Class: Recurse inside or cleanup not founds // Class: Recurse inside or cleanup not founds
// checkNoDot not appropriate, can be under a dot // checkNoDot not appropriate, can be under a dot
AstNode::user5ClearTree(); m_usedPins.clear();
UASSERT_OBJ(m_statep->forPrimary() || VN_IS(nodep->classOrPackageNodep(), ParamTypeDType) UASSERT_OBJ(m_statep->forPrimary() || VN_IS(nodep->classOrPackageNodep(), ParamTypeDType)
|| nodep->classOrPackagep(), || nodep->classOrPackagep(),
nodep, "ClassRef has unlinked class"); nodep, "ClassRef has unlinked class");

21
src/V3MergeCond.cpp
View File

@ -159,11 +159,10 @@ class CodeMotionAnalysisVisitor final : public VNVisitorConst {
// NODE STATE // NODE STATE
// AstNodeStmt::user3 -> StmtProperties (accessed via m_stmtProperties, managed externally, // AstNodeStmt::user3 -> StmtProperties (accessed via m_stmtProperties, managed externally,
// see MergeCondVisitor::process) // see MergeCondVisitor::process)
// AstNodeExpr::user3 -> AstNodeStmt*: Set on a condition node, points to the last
// conditional with that condition so far encountered in the same
// AstNode list
// AstNode::user4 -> Used by V3Hasher // AstNode::user4 -> Used by V3Hasher
// AstNode::user5 -> AstNode*: Set on a condition node, points to the last conditional
// with that condition so far encountered in the same AstNode list
VNUser5InUse m_user5InUse;
StmtPropertiesAllocator& m_stmtProperties; StmtPropertiesAllocator& m_stmtProperties;
@ -212,14 +211,14 @@ class CodeMotionAnalysisVisitor final : public VNVisitorConst {
// First time seeing this condition in the current list // First time seeing this condition in the current list
dupFinder.insert(condp); dupFinder.insert(condp);
// Remember last statement with this condition (which is this statement) // Remember last statement with this condition (which is this statement)
condp->user5p(nodep); condp->user3p(nodep);
} else { } else {
// Seen a conditional with the same condition earlier in the current list // Seen a conditional with the same condition earlier in the current list
AstNode* const firstp = dit->second; AstNodeExpr* const firstp = VN_AS(dit->second, NodeExpr);
// Add to properties for easy retrieval during optimization // Add to properties for easy retrieval during optimization
m_propsp->m_prevWithSameCondp = static_cast<AstNodeStmt*>(firstp->user5p()); m_propsp->m_prevWithSameCondp = static_cast<AstNodeStmt*>(firstp->user3p());
// Remember last statement with this condition (which is this statement) // Remember last statement with this condition (which is this statement)
firstp->user5p(nodep); firstp->user3p(nodep);
} }
} }
} }
@ -430,13 +429,13 @@ private:
// NODE STATE // NODE STATE
// AstVar::user1 -> bool: Set for variables referenced by m_mgCondp // AstVar::user1 -> bool: Set for variables referenced by m_mgCondp
// (Only below MergeCondVisitor::process). // (Only below MergeCondVisitor::process).
// AstNode::user2 -> bool: Marking node as included in merge because cheap to // AstNode::user2 -> bool: Marking node as included in merge because cheap to duplicate
// duplicate
// (Only below MergeCondVisitor::process). // (Only below MergeCondVisitor::process).
// AstNodeStmt::user3 -> StmtProperties // AstNodeStmt::user3 -> StmtProperties
// (Only below MergeCondVisitor::process). // (Only below MergeCondVisitor::process).
// AstNodeExpr::user3 -> See CodeMotionAnalysisVisitor
// (Only below MergeCondVisitor::process).
// AstNode::user4 -> See CodeMotionAnalysisVisitor/CodeMotionOptimizeVisitor // AstNode::user4 -> See CodeMotionAnalysisVisitor/CodeMotionOptimizeVisitor
// AstNode::user5 -> See CodeMotionAnalysisVisitor
// STATE // STATE
VDouble0 m_statMerges; // Statistic tracking VDouble0 m_statMerges; // Statistic tracking

58
src/V3Param.cpp
View File

@ -218,21 +218,21 @@ public:
class ParamProcessor final { class ParamProcessor final {
// NODE STATE - Local // NODE STATE - Local
// AstVar::user4() // int Global parameter number (for naming new module) // AstVar::user3() // int Global parameter number (for naming new module)
// // (0=not processed, 1=iterated, but no number, // // (0=not processed, 1=iterated, but no number,
// // 65+ parameter numbered) // // 65+ parameter numbered)
// NODE STATE - Shared with ParamVisitor // NODE STATE - Shared with ParamVisitor
// AstClass::user4p() // AstClass* Unchanged copy of the parameterized class node. // AstClass::user3p() // AstClass* Unchanged copy of the parameterized class node.
// The class node may be modified according to parameter // The class node may be modified according to parameter
// values and an unchanged copy is needed to instantiate // values and an unchanged copy is needed to instantiate
// classes with different parameters. // classes with different parameters.
// AstNodeModule::user5() // bool True if processed // AstNodeModule::user2() // bool True if processed
// AstGenFor::user5() // bool True if processed // AstGenFor::user2() // bool True if processed
// AstVar::user5() // bool True if constant propagated // AstVar::user2() // bool True if constant propagated
// AstCell::user5p() // string* Generate portion of hierarchical name // AstCell::user2p() // string* Generate portion of hierarchical name
const VNUser4InUse m_inuser4; const VNUser2InUse m_inuser2;
const VNUser5InUse m_inuser5; const VNUser3InUse m_inuser3;
// User1/2/3 used by constant function simulations // User1 used by constant function simulations
// TYPES // TYPES
// Note may have duplicate entries // Note may have duplicate entries
@ -284,20 +284,20 @@ class ParamProcessor final {
char ch = varp->name()[0]; char ch = varp->name()[0];
ch = std::toupper(ch); ch = std::toupper(ch);
if (ch < 'A' || ch > 'Z') ch = 'Z'; if (ch < 'A' || ch > 'Z') ch = 'Z';
varp->user4(usedLetter[static_cast<int>(ch)] * 256 + ch); varp->user3(usedLetter[static_cast<int>(ch)] * 256 + ch);
usedLetter[static_cast<int>(ch)]++; usedLetter[static_cast<int>(ch)]++;
} }
} else if (AstParamTypeDType* const typep = VN_CAST(stmtp, ParamTypeDType)) { } else if (AstParamTypeDType* const typep = VN_CAST(stmtp, ParamTypeDType)) {
const char ch = 'T'; const char ch = 'T';
typep->user4(usedLetter[static_cast<int>(ch)] * 256 + ch); typep->user3(usedLetter[static_cast<int>(ch)] * 256 + ch);
usedLetter[static_cast<int>(ch)]++; usedLetter[static_cast<int>(ch)]++;
} }
} }
} }
static string paramSmallName(AstNodeModule* modp, AstNode* varp) { static string paramSmallName(AstNodeModule* modp, AstNode* varp) {
if (varp->user4() <= 1) makeSmallNames(modp); if (varp->user3() <= 1) makeSmallNames(modp);
int index = varp->user4() / 256; int index = varp->user3() / 256;
const char ch = varp->user4() & 255; const char ch = varp->user3() & 255;
string st = cvtToStr(ch); string st = cvtToStr(ch);
while (index) { while (index) {
st += cvtToStr(char((index % 25) + 'A')); st += cvtToStr(char((index % 25) + 'A'));
@ -571,8 +571,8 @@ class ParamProcessor final {
// Note all module internal variables will be re-linked to the new modules by clone // Note all module internal variables will be re-linked to the new modules by clone
// However links outside the module (like on the upper cells) will not. // However links outside the module (like on the upper cells) will not.
AstNodeModule* newmodp; AstNodeModule* newmodp;
if (srcModp->user4p()) { if (srcModp->user3p()) {
newmodp = VN_CAST(srcModp->user4p()->cloneTree(false), NodeModule); newmodp = VN_CAST(srcModp->user3p()->cloneTree(false), NodeModule);
} else { } else {
newmodp = srcModp->cloneTree(false); newmodp = srcModp->cloneTree(false);
} }
@ -583,7 +583,7 @@ class ParamProcessor final {
} }
newmodp->name(newname); newmodp->name(newname);
newmodp->user5(false); // We need to re-recurse this module once changed newmodp->user2(false); // We need to re-recurse this module once changed
newmodp->recursive(false); newmodp->recursive(false);
newmodp->recursiveClone(false); newmodp->recursiveClone(false);
// Only the first generation of clone holds this property // Only the first generation of clone holds this property
@ -614,7 +614,7 @@ class ParamProcessor final {
// Grab all I/O so we can remap our pins later // Grab all I/O so we can remap our pins later
// Note we allow multiple users of a parameterized model, // Note we allow multiple users of a parameterized model,
// thus we need to stash this info. // thus we need to stash this info.
collectPins(clonemapp, newmodp, srcModp->user4p()); collectPins(clonemapp, newmodp, srcModp->user3p());
// Relink parameter vars to the new module // Relink parameter vars to the new module
relinkPins(clonemapp, paramsp); relinkPins(clonemapp, paramsp);
// Fix any interface references // Fix any interface references
@ -853,14 +853,14 @@ class ParamProcessor final {
if (!any_overrides) { if (!any_overrides) {
UINFO(8, "Cell parameters all match original values, skipping expansion.\n"); UINFO(8, "Cell parameters all match original values, skipping expansion.\n");
// If it's the first use of the default instance, create a copy and store it in user4p. // If it's the first use of the default instance, create a copy and store it in user3p.
// user4p will also be used to check if the default instance is used. // user3p will also be used to check if the default instance is used.
if (!srcModpr->user4p() && VN_IS(srcModpr, Class)) { if (!srcModpr->user3p() && VN_IS(srcModpr, Class)) {
AstClass* classCopyp = VN_AS(srcModpr, Class)->cloneTree(false); AstClass* classCopyp = VN_AS(srcModpr, Class)->cloneTree(false);
// It is a temporary copy of the original class node, stored in order to create // It is a temporary copy of the original class node, stored in order to create
// another instances. It is needed only during class instantiation. // another instances. It is needed only during class instantiation.
m_deleter.pushDeletep(classCopyp); m_deleter.pushDeletep(classCopyp);
srcModpr->user4p(classCopyp); srcModpr->user3p(classCopyp);
storeOriginalParams(classCopyp); storeOriginalParams(classCopyp);
} }
} else if (AstNodeModule* const paramedModp } else if (AstNodeModule* const paramedModp
@ -1002,9 +1002,9 @@ class ParamVisitor final : public VNVisitor {
AstNodeModule* const modp = itm->second; AstNodeModule* const modp = itm->second;
workQueue.erase(itm); workQueue.erase(itm);
// Process once; note user5 will be cleared on specialization, so we will do the // Process once; note user2 will be cleared on specialization, so we will do the
// specialized module if needed // specialized module if needed
if (!modp->user5SetOnce()) { if (!modp->user2SetOnce()) {
// TODO: this really should be an assert, but classes and hier_blocks are // TODO: this really should be an assert, but classes and hier_blocks are
// special... // special...
@ -1040,9 +1040,9 @@ class ParamVisitor final : public VNVisitor {
// Update path // Update path
string someInstanceName(modp->someInstanceName()); string someInstanceName(modp->someInstanceName());
if (const string* const genHierNamep = cellp->user5u().to<string*>()) { if (const string* const genHierNamep = cellp->user2u().to<string*>()) {
someInstanceName += *genHierNamep; someInstanceName += *genHierNamep;
cellp->user5p(nullptr); cellp->user2p(nullptr);
VL_DO_DANGLING(delete genHierNamep, genHierNamep); VL_DO_DANGLING(delete genHierNamep, genHierNamep);
} }
@ -1077,7 +1077,7 @@ class ParamVisitor final : public VNVisitor {
void visitCellOrClassRef(AstNode* nodep, bool isIface) { void visitCellOrClassRef(AstNode* nodep, bool isIface) {
// Must do ifaces first, so push to list and do in proper order // Must do ifaces first, so push to list and do in proper order
string* const genHierNamep = new std::string{m_generateHierName}; string* const genHierNamep = new std::string{m_generateHierName};
nodep->user5p(genHierNamep); nodep->user2p(genHierNamep);
// Visit parameters in the instantiation. // Visit parameters in the instantiation.
iterateChildren(nodep); iterateChildren(nodep);
m_cellps.emplace(!isIface, nodep); m_cellps.emplace(!isIface, nodep);
@ -1133,7 +1133,7 @@ class ParamVisitor final : public VNVisitor {
// Make sure all parameters are constantified // Make sure all parameters are constantified
void visit(AstVar* nodep) override { void visit(AstVar* nodep) override {
if (nodep->user5SetOnce()) return; // Process once if (nodep->user2SetOnce()) return; // Process once
iterateChildren(nodep); iterateChildren(nodep);
if (nodep->isParam()) { if (nodep->isParam()) {
if (!nodep->valuep() && !VN_IS(m_modp, Class)) { if (!nodep->valuep() && !VN_IS(m_modp, Class)) {
@ -1428,7 +1428,7 @@ public:
for (AstNodeModule* const modp : modps) netlistp->addModulesp(modp); for (AstNodeModule* const modp : modps) netlistp->addModulesp(modp);
for (AstClass* const classp : m_paramClasses) { for (AstClass* const classp : m_paramClasses) {
if (!classp->user4p()) { if (!classp->user3p()) {
// The default value isn't referenced, so it can be removed // The default value isn't referenced, so it can be removed
VL_DO_DANGLING(pushDeletep(classp->unlinkFrBack()), classp); VL_DO_DANGLING(pushDeletep(classp->unlinkFrBack()), classp);
} else { } else {

4
src/V3Partition.cpp
View File

@ -2662,9 +2662,9 @@ uint32_t V3Partition::setupMTaskDeps(V3Graph* mtasksp) {
// coarsening algorithm assumes that the graph is connected. // coarsening algorithm assumes that the graph is connected.
m_entryMTaskp = new LogicMTask{mtasksp, nullptr}; m_entryMTaskp = new LogicMTask{mtasksp, nullptr};
// The V3InstrCount within LogicMTask will set user5 on each AST // The V3InstrCount within LogicMTask will set user1 on each AST
// node, to assert that we never count any node twice. // node, to assert that we never count any node twice.
const VNUser5InUse user5inUse; const VNUser1InUse user1inUse;
// Create the LogicMTasks for each MTaskMoveVertex // Create the LogicMTasks for each MTaskMoveVertex
for (V3GraphVertex *vtxp = m_fineDepsGraphp->verticesBeginp(), *nextp; vtxp; vtxp = nextp) { for (V3GraphVertex *vtxp = m_fineDepsGraphp->verticesBeginp(), *nextp; vtxp; vtxp = nextp) {

68
src/V3Simulate.h
View File

@ -36,6 +36,7 @@
#include "verilatedos.h" #include "verilatedos.h"
#include "V3Ast.h" #include "V3Ast.h"
#include "V3AstUserAllocator.h"
#include "V3Error.h" #include "V3Error.h"
#include "V3Task.h" #include "V3Task.h"
#include "V3Width.h" #include "V3Width.h"
@ -76,19 +77,25 @@ private:
// NODE STATE // NODE STATE
// Cleared on each always/assignw // Cleared on each always/assignw
const VNUser1InUse m_inuser1; const VNUser1InUse m_inuser1;
const VNUser2InUse m_inuser2;
const VNUser3InUse m_inuser3;
// Checking: // AstVar/AstVarScope::user1p() -> See AuxAstVar via m_varAux
// AstVar(Scope)::user1() -> VarUsage. Set true to indicate tracking as lvalue/rvalue // AstConst::user1() -> bool. This AstConst (allocated by this class) is in use
// Simulating:
// AstConst::user2() -> bool. This AstConst (allocated by this class) is in use
// AstVar(Scope)::user3() -> AstConst*. Input value of variable or node
// (and output for non-delayed assignments)
// AstVar(Scope)::user2() -> AstCont*. Output value of variable (delayed assignments)
enum VarUsage : uint8_t { VU_NONE = 0, VU_LV = 1, VU_RV = 2, VU_LVDLY = 4 }; enum VarUsage : uint8_t { VU_NONE = 0, VU_LV = 1, VU_RV = 2, VU_LVDLY = 4 };
struct AuxVariable final {
// Checking:
// Set true to indicate tracking as lvalue/rvalue
uint8_t usage = VU_NONE;
// Simulating:
// Output value of variable (delayed assignments)
AstNodeExpr* outValuep = nullptr;
// Input value of variable or node (and output for non-delayed assignments)
AstNodeExpr* valuep = nullptr;
};
AstUser1Allocator<AstNode, AuxVariable> m_varAux;
// STATE // STATE
// Major mode // Major mode
bool m_checkOnly; ///< Checking only (no simulation) mode bool m_checkOnly; ///< Checking only (no simulation) mode
@ -223,14 +230,14 @@ private:
bool allocNewConst = true; bool allocNewConst = true;
if (!freeList.empty()) { if (!freeList.empty()) {
constp = freeList.front(); constp = freeList.front();
if (!constp->user2()) { if (!constp->user1()) {
// Front of free list is free, reuse it (otherwise allocate new node) // Front of free list is free, reuse it (otherwise allocate new node)
allocNewConst = false; // No need to allocate allocNewConst = false; // No need to allocate
// Mark the AstConst node as used, and move it to the back of the free list. This // Mark the AstConst node as used, and move it to the back of the free list. This
// ensures that when all AstConst instances within the list are used, then the // ensures that when all AstConst instances within the list are used, then the
// front of the list will be marked as used, in which case the enclosing 'if' will // front of the list will be marked as used, in which case the enclosing 'if' will
// fail and we fall back to allocation. // fail and we fall back to allocation.
constp->user2(1); constp->user1(1);
freeList.pop_front(); freeList.pop_front();
freeList.push_back(constp); freeList.push_back(constp);
// configure const // configure const
@ -241,7 +248,7 @@ private:
// Need to allocate new constant // Need to allocate new constant
constp = new AstConst{nodep->fileline(), AstConst::DTyped{}, nodep->dtypep()}; constp = new AstConst{nodep->fileline(), AstConst::DTyped{}, nodep->dtypep()};
// Mark as in use, add to free list for later reuse // Mark as in use, add to free list for later reuse
constp->user2(1); constp->user1(1);
freeList.push_back(constp); freeList.push_back(constp);
} }
return constp; return constp;
@ -273,7 +280,7 @@ private:
} }
AstConst* newConst(AstNode* nodep) { AstConst* newConst(AstNode* nodep) {
// Set a constant value for this node // Set a constant value for this node
if (!VN_IS(nodep->user3p(), Const)) { if (!VN_IS(m_varAux(nodep).valuep, Const)) {
AstConst* const constp = allocConst(nodep); AstConst* const constp = allocConst(nodep);
setValue(nodep, constp); setValue(nodep, constp);
return constp; return constp;
@ -283,7 +290,7 @@ private:
} }
AstConst* newOutConst(AstNode* nodep) { AstConst* newOutConst(AstNode* nodep) {
// Set a var-output constant value for this node // Set a var-output constant value for this node
if (!VN_IS(nodep->user2p(), Const)) { if (!VN_IS(m_varAux(nodep).outValuep, Const)) {
AstConst* const constp = allocConst(nodep); AstConst* const constp = allocConst(nodep);
setOutValue(nodep, constp); setOutValue(nodep, constp);
return constp; return constp;
@ -293,10 +300,10 @@ private:
} }
public: public:
AstNodeExpr* fetchValueNull(AstNode* nodep) { return VN_AS(nodep->user3p(), NodeExpr); } AstNodeExpr* fetchValueNull(AstNode* nodep) { return m_varAux(nodep).valuep; }
private: private:
AstNodeExpr* fetchOutValueNull(AstNode* nodep) { return VN_AS(nodep->user2p(), NodeExpr); } AstNodeExpr* fetchOutValueNull(AstNode* nodep) { return m_varAux(nodep).outValuep; }
AstConst* fetchConstNull(AstNode* nodep) { return VN_CAST(fetchValueNull(nodep), Const); } AstConst* fetchConstNull(AstNode* nodep) { return VN_CAST(fetchValueNull(nodep), Const); }
AstConst* fetchOutConstNull(AstNode* nodep) { AstConst* fetchOutConstNull(AstNode* nodep) {
return VN_CAST(fetchOutValueNull(nodep), Const); return VN_CAST(fetchOutValueNull(nodep), Const);
@ -332,15 +339,15 @@ public:
} }
private: private:
void setValue(AstNode* nodep, const AstNodeExpr* valuep) { void setValue(AstNode* nodep, AstNodeExpr* valuep) {
UASSERT_OBJ(valuep, nodep, "Simulate setting null value"); UASSERT_OBJ(valuep, nodep, "Simulate setting null value");
UINFO(9, " set val " << valuep->name() << " on " << nodep << endl); UINFO(9, " set val " << valuep->name() << " on " << nodep << endl);
nodep->user3p((void*)valuep); m_varAux(nodep).valuep = valuep;
} }
void setOutValue(AstNode* nodep, const AstNodeExpr* valuep) { void setOutValue(AstNode* nodep, AstNodeExpr* valuep) {
UASSERT_OBJ(valuep, nodep, "Simulate setting null value"); UASSERT_OBJ(valuep, nodep, "Simulate setting null value");
UINFO(9, " set oval " << valuep->name() << " on " << nodep << endl); UINFO(9, " set oval " << valuep->name() << " on " << nodep << endl);
nodep->user2p((void*)valuep); m_varAux(nodep).outValuep = valuep;
} }
void checkNodeInfo(AstNode* nodep, bool ignorePredict = false) { void checkNodeInfo(AstNode* nodep, bool ignorePredict = false) {
@ -429,26 +436,26 @@ private:
clearOptimizable(nodep, "Array references/not basic"); clearOptimizable(nodep, "Array references/not basic");
if (nodep->access().isWriteOrRW()) { if (nodep->access().isWriteOrRW()) {
if (m_inDlyAssign) { if (m_inDlyAssign) {
if (!(vscp->user1() & VU_LVDLY)) { if (!(m_varAux(vscp).usage & VU_LVDLY)) {
vscp->user1(vscp->user1() | VU_LVDLY); m_varAux(vscp).usage |= VU_LVDLY;
if (m_checkOnly) varRefCb(nodep); if (m_checkOnly) varRefCb(nodep);
} }
} else { // nondly asn } else { // nondly asn
if (!(vscp->user1() & VU_LV)) { if (!(m_varAux(vscp).usage & VU_LV)) {
if (!m_params && (vscp->user1() & VU_RV)) { if (!m_params && (m_varAux(vscp).usage & VU_RV)) {
clearOptimizable(nodep, "Var read & write"); clearOptimizable(nodep, "Var read & write");
} }
vscp->user1(vscp->user1() | VU_LV); m_varAux(vscp).usage |= VarUsage::VU_LV;
if (m_checkOnly) varRefCb(nodep); if (m_checkOnly) varRefCb(nodep);
} }
} }
} }
if (nodep->access().isReadOrRW()) { if (nodep->access().isReadOrRW()) {
if (!(vscp->user1() & VU_RV)) { if (!(m_varAux(vscp).usage & VU_RV)) {
if (!m_params && (vscp->user1() & VU_LV)) { if (!m_params && (m_varAux(vscp).usage & VU_LV)) {
clearOptimizable(nodep, "Var write & read"); clearOptimizable(nodep, "Var write & read");
} }
vscp->user1(vscp->user1() | VU_RV); m_varAux(vscp).usage |= VU_RV;
const bool isConst = (nodep->varp()->isConst() || nodep->varp()->isParam()) const bool isConst = (nodep->varp()->isConst() || nodep->varp()->isParam())
&& nodep->varp()->valuep(); && nodep->varp()->valuep();
AstNodeExpr* const valuep AstNodeExpr* const valuep
@ -717,7 +724,7 @@ private:
AstNodeExpr* const valuep = newTrackedClone(fetchValue(nodep->rhsp())); AstNodeExpr* const valuep = newTrackedClone(fetchValue(nodep->rhsp()));
UINFO(9, " set val[" << index << "] = " << valuep << endl); UINFO(9, " set val[" << index << "] = " << valuep << endl);
// Values are in the "real" tree under the InitArray so can eventually extract it, // Values are in the "real" tree under the InitArray so can eventually extract it,
// Not in the usual setValue (pointed to by user2/3p) // Not in the usual setValue (via m_varAux)
initp->addIndexValuep(index, valuep); initp->addIndexValuep(index, valuep);
if (debug() >= 9) initp->dumpTree("- array: "); if (debug() >= 9) initp->dumpTree("- array: ");
assignOutValue(nodep, vscp, initp); assignOutValue(nodep, vscp, initp);
@ -1224,8 +1231,7 @@ public:
m_jumpp = nullptr; m_jumpp = nullptr;
AstNode::user1ClearTree(); AstNode::user1ClearTree();
AstNode::user2ClearTree(); // Also marks all elements in m_constps as free m_varAux.clear();
AstNode::user3ClearTree();
} }
void mainTableCheck(AstNode* nodep) { void mainTableCheck(AstNode* nodep) {
setMode(true /*scoped*/, true /*checking*/, false /*params*/); setMode(true /*scoped*/, true /*checking*/, false /*params*/);

6
src/V3Timing.cpp
View File

@ -183,7 +183,7 @@ private:
const VNUser1InUse m_user1InUse; const VNUser1InUse m_user1InUse;
const VNUser2InUse m_user2InUse; const VNUser2InUse m_user2InUse;
const VNUser3InUse m_user3InUse; const VNUser3InUse m_user3InUse;
const VNUser5InUse m_user5InUse; const VNUser4InUse m_user4InUse;
// STATE // STATE
VMemberMap m_memberMap; // Member names cached for fast lookup VMemberMap m_memberMap; // Member names cached for fast lookup
@ -214,8 +214,8 @@ private:
classp = VN_CAST(funcp->scopep()->modp(), Class); classp = VN_CAST(funcp->scopep()->modp(), Class);
} }
} }
if (!nodep->user5p()) nodep->user5p(new NeedsProcDepVtx{&m_procGraph, nodep, classp}); if (!nodep->user4p()) nodep->user4p(new NeedsProcDepVtx{&m_procGraph, nodep, classp});
return nodep->user5u().to<NeedsProcDepVtx*>(); return nodep->user4u().to<NeedsProcDepVtx*>();
} }
// Pass timing flag between nodes // Pass timing flag between nodes
bool passFlag(const AstNode* from, AstNode* to, NodeFlag flag) { bool passFlag(const AstNode* from, AstNode* to, NodeFlag flag) {

59
src/V3Tristate.cpp
View File

@ -119,6 +119,7 @@
#include "V3Tristate.h" #include "V3Tristate.h"
#include "V3AstUserAllocator.h"
#include "V3Graph.h" #include "V3Graph.h"
#include "V3Inst.h" #include "V3Inst.h"
#include "V3Stats.h" #include "V3Stats.h"
@ -176,8 +177,8 @@ public:
class TristateGraph final { class TristateGraph final {
// NODE STATE // NODE STATE
// AstVar::user5p -> TristateVertex* for variable being built // AstVar::user4p -> TristateVertex* for variable being built
// VNUser5InUse m_inuser5; // In visitor below // VNUser4InUse m_inuser4; // In visitor below
// TYPES // TYPES
public: public:
@ -197,11 +198,11 @@ private:
// METHODS // METHODS
TristateVertex* makeVertex(AstNode* nodep) { TristateVertex* makeVertex(AstNode* nodep) {
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p()); TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
if (!vertexp) { if (!vertexp) {
UINFO(6, " New vertex " << nodep << endl); UINFO(6, " New vertex " << nodep << endl);
vertexp = new TristateVertex{&m_graph, nodep}; vertexp = new TristateVertex{&m_graph, nodep};
nodep->user5p(vertexp); nodep->user4p(vertexp);
} }
return vertexp; return vertexp;
} }
@ -279,7 +280,7 @@ public:
} }
} }
m_graph.clear(); m_graph.clear();
AstNode::user5ClearTree(); // Wipe all node user5p's that point to vertexes AstNode::user4ClearTree(); // Wipe all node user4p's that point to vertexes
} }
void graphWalk(AstNodeModule* nodep) { void graphWalk(AstNodeModule* nodep) {
UINFO(9, " Walking " << nodep << endl); UINFO(9, " Walking " << nodep << endl);
@ -298,7 +299,7 @@ public:
if (!nodep) return; if (!nodep) return;
// Skip vars, because they may be connected to more than one varref // Skip vars, because they may be connected to more than one varref
if (!VN_IS(nodep, Var)) { if (!VN_IS(nodep, Var)) {
TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p()); TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
if (vertexp) vertexp->unlinkDelete(&m_graph); if (vertexp) vertexp->unlinkDelete(&m_graph);
} }
deleteVerticesFromSubtreeRecurse(nodep->op1p()); deleteVerticesFromSubtreeRecurse(nodep->op1p());
@ -308,15 +309,15 @@ public:
} }
void setTristate(AstNode* nodep) { makeVertex(nodep)->isTristate(true); } void setTristate(AstNode* nodep) { makeVertex(nodep)->isTristate(true); }
bool isTristate(AstNode* nodep) { bool isTristate(AstNode* nodep) {
const TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p()); const TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
return vertexp && vertexp->isTristate(); return vertexp && vertexp->isTristate();
} }
bool feedsTri(AstNode* nodep) { bool feedsTri(AstNode* nodep) {
const TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p()); const TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
return vertexp && vertexp->feedsTri(); return vertexp && vertexp->feedsTri();
} }
void didProcess(AstNode* nodep) { void didProcess(AstNode* nodep) {
TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p()); TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
if (!vertexp) { if (!vertexp) {
// Not v3errorSrc as no reason to stop the world // Not v3errorSrc as no reason to stop the world
nodep->v3error("Unsupported tristate construct (not in propagation graph): " nodep->v3error("Unsupported tristate construct (not in propagation graph): "
@ -390,16 +391,21 @@ class TristateVisitor final : public TristateBaseVisitor {
// NODE STATE // NODE STATE
// *::user1p -> pointer to output enable __en expressions // *::user1p -> pointer to output enable __en expressions
// *::user2 -> int - already visited, see U2_ enum // *::user2 -> int - already visited, see U2_ enum
// AstVar::user3p -> AstPull* pullup/pulldown direction (input Var's user3p) // AstVar::user3p -> See AuxAstVar via m_varAux
// AstVar::user4p -> AstVar* pointer to output __out var (input Var's user2p)
// See TristateGraph: // See TristateGraph:
// AstVar::user5p -> TristateVertex* for variable being built // AstVar::user4p -> TristateVertex* for variable being built
// AstStmt*::user5p -> TristateVertex* for this statement // AstStmt::user4p -> TristateVertex* for this statement
const VNUser1InUse m_inuser1; const VNUser1InUse m_inuser1;
const VNUser2InUse m_inuser2; const VNUser2InUse m_inuser2;
const VNUser3InUse m_inuser3; const VNUser3InUse m_inuser3;
const VNUser4InUse m_inuser4; const VNUser4InUse m_inuser4;
const VNUser5InUse m_inuser5;
struct AuxAstVar final {
AstPull* pullp = nullptr; // pullup/pulldown direction
AstVar* outVarp = nullptr; // output __out var
};
AstUser3Allocator<AstVar, AuxAstVar> m_varAux;
// TYPES // TYPES
struct RefStrength { struct RefStrength {
@ -531,14 +537,14 @@ class TristateVisitor final : public TristateBaseVisitor {
} }
AstVar* getCreateOutVarp(AstVar* invarp) { AstVar* getCreateOutVarp(AstVar* invarp) {
// Return the master __out for the specified input variable // Return the master __out for the specified input variable
if (!invarp->user4p()) { if (!m_varAux(invarp).outVarp) {
AstVar* const newp = new AstVar{invarp->fileline(), VVarType::MODULETEMP, AstVar* const newp = new AstVar{invarp->fileline(), VVarType::MODULETEMP,
invarp->name() + "__out", invarp}; invarp->name() + "__out", invarp};
UINFO(9, " newout " << newp << endl); UINFO(9, " newout " << newp << endl);
modAddStmtp(invarp, newp); modAddStmtp(invarp, newp);
invarp->user4p(newp); // find outvar given invarp m_varAux(invarp).outVarp = newp; // find outvar given invarp
} }
return VN_AS(invarp->user4p(), Var); return m_varAux(invarp).outVarp;
} }
AstVar* getCreateUnconnVarp(AstNode* fromp, AstNodeDType* dtypep) { AstVar* getCreateUnconnVarp(AstNode* fromp, AstNodeDType* dtypep) {
AstVar* const newp = new AstVar{fromp->fileline(), VVarType::MODULETEMP, AstVar* const newp = new AstVar{fromp->fileline(), VVarType::MODULETEMP,
@ -566,9 +572,9 @@ class TristateVisitor final : public TristateBaseVisitor {
} }
void setPullDirection(AstVar* varp, AstPull* pullp) { void setPullDirection(AstVar* varp, AstPull* pullp) {
const AstPull* const oldpullp = static_cast<AstPull*>(varp->user3p()); const AstPull* const oldpullp = m_varAux(varp).pullp;
if (!oldpullp) { if (!oldpullp) {
varp->user3p(pullp); // save off to indicate the pull direction m_varAux(varp).pullp = pullp; // save off to indicate the pull direction
} else { } else {
if (oldpullp->direction() != pullp->direction()) { if (oldpullp->direction() != pullp->direction()) {
pullp->v3warn(E_UNSUPPORTED, "Unsupported: Conflicting pull directions.\n" pullp->v3warn(E_UNSUPPORTED, "Unsupported: Conflicting pull directions.\n"
@ -725,8 +731,8 @@ class TristateVisitor final : public TristateBaseVisitor {
envarp = getCreateEnVarp(invarp); // direction will be sen in visit(AstPin*) envarp = getCreateEnVarp(invarp); // direction will be sen in visit(AstPin*)
// //
outvarp->user1p(envarp); outvarp->user1p(envarp);
outvarp->user3p(invarp->user3p()); // AstPull* propagation m_varAux(outvarp).pullp = m_varAux(invarp).pullp; // AstPull* propagation
if (invarp->user3p()) UINFO(9, "propagate pull to " << outvarp << endl); if (m_varAux(invarp).pullp) UINFO(9, "propagate pull to " << outvarp << endl);
} else if (invarp->user1p()) { } else if (invarp->user1p()) {
envarp = VN_AS(invarp->user1p(), Var); // From CASEEQ, foo === 1'bz envarp = VN_AS(invarp->user1p(), Var); // From CASEEQ, foo === 1'bz
} }
@ -784,7 +790,7 @@ class TristateVisitor final : public TristateBaseVisitor {
if (!outvarp) { if (!outvarp) {
// This is the final pre-forced resolution of the tristate, so we apply // This is the final pre-forced resolution of the tristate, so we apply
// the pull direction to any undriven pins. // the pull direction to any undriven pins.
const AstPull* const pullp = static_cast<AstPull*>(lhsp->user3p()); const AstPull* const pullp = m_varAux(lhsp).pullp;
bool pull1 = pullp && pullp->direction() == 1; // Else default is down bool pull1 = pullp && pullp->direction() == 1; // Else default is down
AstNodeExpr* undrivenp; AstNodeExpr* undrivenp;
@ -1435,7 +1441,7 @@ class TristateVisitor final : public TristateBaseVisitor {
associateLogic(nodep, varrefp->varp()); associateLogic(nodep, varrefp->varp());
} else { } else {
// Replace any pullup/pulldowns with assignw logic and set the // Replace any pullup/pulldowns with assignw logic and set the
// direction of the pull in the user3() data on the var. Given // direction of the pull in the var aux data. Given
// the complexity of merging tristate drivers at any level, the // the complexity of merging tristate drivers at any level, the
// current limitation of this implementation is that a pullup/down // current limitation of this implementation is that a pullup/down
// gets applied to all bits of a bus and a bus cannot have drivers // gets applied to all bits of a bus and a bus cannot have drivers
@ -1448,7 +1454,8 @@ class TristateVisitor final : public TristateBaseVisitor {
} }
if (!m_graphing) { if (!m_graphing) {
nodep->unlinkFrBack(); nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep); // Node must persist as user3p points to it // Node must persist as var aux data points to it
VL_DO_DANGLING(pushDeletep(nodep), nodep);
} }
} }
@ -1563,7 +1570,7 @@ class TristateVisitor final : public TristateBaseVisitor {
// Create new output pin // Create new output pin
const AstAssignW* outAssignp = nullptr; // If reconnected, the related assignment const AstAssignW* outAssignp = nullptr; // If reconnected, the related assignment
AstPin* outpinp = nullptr; AstPin* outpinp = nullptr;
AstVar* const outModVarp = static_cast<AstVar*>(nodep->modVarp()->user4p()); AstVar* const outModVarp = m_varAux(nodep->modVarp()).outVarp;
if (!outModVarp) { if (!outModVarp) {
// At top, no need for __out as might be input only. Otherwise resolvable. // At top, no need for __out as might be input only. Otherwise resolvable.
if (!m_modp->isTop()) { if (!m_modp->isTop()) {
@ -1638,7 +1645,7 @@ class TristateVisitor final : public TristateBaseVisitor {
// Propagate any pullups/pulldowns upwards if necessary // Propagate any pullups/pulldowns upwards if necessary
if (exprrefp) { if (exprrefp) {
if (AstPull* const pullp = static_cast<AstPull*>(nodep->modVarp()->user3p())) { if (AstPull* const pullp = m_varAux(nodep->modVarp()).pullp) {
UINFO(9, "propagate pull on " << exprrefp << endl); UINFO(9, "propagate pull on " << exprrefp << endl);
setPullDirection(exprrefp->varp(), pullp); setPullDirection(exprrefp->varp(), pullp);
} }