mirror of
https://github.com/verilator/verilator.git
synced 2025-04-04 19:52:39 +00:00
Delete AstNode user5 (#4638)
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
GitHub
parent
7ba6647c4f
commit
3c144ada53
@ -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
|
||||
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
|
||||
``user5p()`` methods (a common technique lifted from graph traversal
|
||||
``user4p()`` methods (a common technique lifted from graph traversal
|
||||
packages).
|
||||
|
||||
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.
|
||||
|
||||
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
|
||||
Many nodes have an explicit data type. "@dt=0x..." indicates the
|
||||
|
||||
@ -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 VNUser3InUse::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 VNUser2InUse::s_userBusy = false;
|
||||
bool VNUser3InUse::s_userBusy = false;
|
||||
bool VNUser4InUse::s_userBusy = false;
|
||||
bool VNUser5InUse::s_userBusy = false;
|
||||
|
||||
int AstNodeDType::s_uniqueNum = 0;
|
||||
|
||||
@ -1235,7 +1233,6 @@ void AstNode::dumpPtrs(std::ostream& os) const {
|
||||
if (user2p()) os << " user2p=" << cvtToHex(user2p());
|
||||
if (user3p()) os << " user3p=" << cvtToHex(user3p());
|
||||
if (user4p()) os << " user4p=" << cvtToHex(user4p());
|
||||
if (user5p()) os << " user5p=" << cvtToHex(user5p());
|
||||
if (m_iterpp) {
|
||||
os << " iterpp=" << cvtToHex(m_iterpp);
|
||||
// This may cause address sanitizer failures as iterpp can be stale
|
||||
|
||||
27
src/V3Ast.h
27
src/V3Ast.h
@ -1611,17 +1611,6 @@ public:
|
||||
static void clear() { clearcnt(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
|
||||
|
||||
//######################################################################
|
||||
@ -1825,8 +1814,6 @@ class AstNode VL_NOT_FINAL {
|
||||
uint32_t m_user3Cnt = 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_user5u{0}; // Contains any information the user iteration routine wants
|
||||
uint32_t m_user5Cnt = 0; // Mark of when userp was set
|
||||
|
||||
// METHODS
|
||||
void op1p(AstNode* nodep) {
|
||||
@ -2074,20 +2061,6 @@ public:
|
||||
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()
|
||||
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
|
||||
|
||||
#ifdef VL_DEBUG
|
||||
|
||||
@ -1379,7 +1379,6 @@ void AstNode::dump(std::ostream& str) const {
|
||||
if (user2p()) str << " u2=" << nodeAddr(user2p());
|
||||
if (user3p()) str << " u3=" << nodeAddr(user3p());
|
||||
if (user4p()) str << " u4=" << nodeAddr(user4p());
|
||||
if (user5p()) str << " u5=" << nodeAddr(user5p());
|
||||
if (hasDType()) {
|
||||
// Final @ so less likely to by accident read it as a nodep
|
||||
if (dtypep() == this) {
|
||||
|
||||
@ -29,7 +29,7 @@
|
||||
|
||||
template <class T_Node, class T_Data, int T_UserN>
|
||||
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");
|
||||
|
||||
private:
|
||||
@ -45,11 +45,8 @@ private:
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
|
||||
const VNUser user = nodep->user3u();
|
||||
return user.to<T_Data*>();
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
|
||||
const VNUser user = nodep->user4u();
|
||||
return user.to<T_Data*>();
|
||||
} else {
|
||||
const VNUser user = nodep->user5u();
|
||||
const VNUser user = nodep->user4u();
|
||||
return user.to<T_Data*>();
|
||||
}
|
||||
}
|
||||
@ -61,10 +58,8 @@ private:
|
||||
nodep->user2u(VNUser{userp});
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
|
||||
nodep->user3u(VNUser{userp});
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
|
||||
nodep->user4u(VNUser{userp});
|
||||
} else {
|
||||
nodep->user5u(VNUser{userp});
|
||||
nodep->user4u(VNUser{userp});
|
||||
}
|
||||
}
|
||||
|
||||
@ -76,10 +71,8 @@ protected:
|
||||
VNUser2InUse::check();
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 3) {
|
||||
VNUser3InUse::check();
|
||||
} else if VL_CONSTEXPR_CXX17 (T_UserN == 4) {
|
||||
VNUser4InUse::check();
|
||||
} else {
|
||||
VNUser5InUse::check();
|
||||
VNUser4InUse::check();
|
||||
}
|
||||
}
|
||||
|
||||
@ -107,6 +100,8 @@ public:
|
||||
|
||||
// Get a pointer to the user data if exists, otherwise nullptr
|
||||
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
|
||||
@ -120,7 +115,5 @@ template <class T_Node, class T_Data>
|
||||
class AstUser3Allocator final : public AstUserAllocatorBase<T_Node, T_Data, 3> {};
|
||||
template <class T_Node, class T_Data>
|
||||
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
|
||||
|
||||
@ -52,6 +52,7 @@
|
||||
|
||||
#include "V3Delayed.h"
|
||||
|
||||
#include "V3AstUserAllocator.h"
|
||||
#include "V3Stats.h"
|
||||
|
||||
#include <deque>
|
||||
@ -65,27 +66,33 @@ class DelayedVisitor final : public VNVisitor {
|
||||
private:
|
||||
// NODE STATE
|
||||
// Cleared each module:
|
||||
// AstVarScope::user1p() -> AstVarScope*. Points to temp var created.
|
||||
// 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
|
||||
// AstVarScope::user1p() -> aux
|
||||
// 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::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
|
||||
// (valid when AstAlwaysPost::user4p is valid)
|
||||
// AstAlwaysPost::user4() -> AstIf*. Last IF (__Vdlyvset__) created under this AlwaysPost
|
||||
// Cleared each scope/active:
|
||||
// AstAssignDly::user3() -> AstVarScope*. __Vdlyvset__ created for this assign
|
||||
// AstAlwaysPost::user3() -> AstVarScope*. __Vdlyvset__ last referenced in IF
|
||||
const VNUser1InUse m_inuser1;
|
||||
const VNUser2InUse m_inuser2;
|
||||
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
|
||||
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).
|
||||
if (nodep->fileline()->warnIsOff(V3ErrorCode::BLKANDNBLK)) return;
|
||||
if (m_ignoreBlkAndNBlk) return;
|
||||
if (blocking) nodep->user5(true);
|
||||
if (blocking) nodep->user1(true);
|
||||
AstVarScope* const vscp = nodep->varScopep();
|
||||
// UINFO(4, " MVU " << blocking << " " << nodep << endl);
|
||||
const AstNode* const lastrefp = vscp->user5p();
|
||||
const AstNode* const lastrefp = m_vscpAux(vscp).lastRefp;
|
||||
if (!lastrefp) {
|
||||
vscp->user5p(nodep);
|
||||
m_vscpAux(vscp).lastRefp = nodep;
|
||||
} else {
|
||||
const bool last_was_blocking = lastrefp->user5();
|
||||
const bool last_was_blocking = lastrefp->user1();
|
||||
if (last_was_blocking != blocking) {
|
||||
const AstNode* nonblockingp = blocking ? nodep : lastrefp;
|
||||
if (const AstNode* np = containingAssignment(nonblockingp)) nonblockingp = np;
|
||||
@ -351,7 +358,7 @@ private:
|
||||
UINFO(9, " & " << varrefp << endl);
|
||||
AstAlwaysPost* finalp = nullptr;
|
||||
if (m_inSuspendableOrFork) {
|
||||
finalp = VN_AS(varrefp->varScopep()->user3p(), AlwaysPost);
|
||||
finalp = m_vscpAux(varrefp->varScopep()).suspFinalp;
|
||||
if (!finalp) {
|
||||
FileLine* const flp = nodep->fileline();
|
||||
finalp = new AstAlwaysPost{flp, nullptr, nullptr};
|
||||
@ -359,13 +366,13 @@ private:
|
||||
if (!m_procp->user3p()) {
|
||||
AstActive* const newactp = createActive(varrefp);
|
||||
m_procp->user3p(newactp);
|
||||
varrefp->varScopep()->user3p(finalp);
|
||||
m_vscpAux(varrefp->varScopep()).suspFinalp = finalp;
|
||||
}
|
||||
AstActive* const actp = VN_AS(m_procp->user3p(), Active);
|
||||
actp->addStmtsp(finalp);
|
||||
}
|
||||
} else {
|
||||
finalp = VN_AS(varrefp->varScopep()->user4p(), AlwaysPost);
|
||||
finalp = m_vscpAux(varrefp->varScopep()).finalp;
|
||||
if (finalp) {
|
||||
AstActive* const oldactivep = VN_AS(finalp->user2p(), Active);
|
||||
checkActivePost(varrefp, oldactivep);
|
||||
@ -375,7 +382,7 @@ private:
|
||||
UINFO(9, " Created " << finalp << endl);
|
||||
AstActive* const newactp = createActive(varrefp);
|
||||
newactp->addStmtsp(finalp);
|
||||
varrefp->varScopep()->user4p(finalp);
|
||||
m_vscpAux(varrefp->varScopep()).finalp = finalp;
|
||||
finalp->user2p(newactp);
|
||||
if (setinitp) newactp->addStmtsp(setinitp);
|
||||
}
|
||||
@ -384,7 +391,7 @@ private:
|
||||
if (finalp->user3p() == setvscp) {
|
||||
// Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*,
|
||||
// we can share the IF statement too
|
||||
postLogicp = VN_AS(finalp->user4p(), If);
|
||||
postLogicp = VN_AS(finalp->user1p(), If);
|
||||
UASSERT_OBJ(postLogicp, nodep,
|
||||
"Delayed assignment misoptimized; prev var found w/o associated IF");
|
||||
} else {
|
||||
@ -393,7 +400,7 @@ private:
|
||||
UINFO(9, " Created " << postLogicp << endl);
|
||||
finalp->addStmtsp(postLogicp);
|
||||
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});
|
||||
if (m_inSuspendableOrFork) {
|
||||
@ -565,12 +572,11 @@ private:
|
||||
}
|
||||
AstVarScope* const oldvscp = nodep->varScopep();
|
||||
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
|
||||
AstActive* const oldactivep = VN_AS(dlyvscp->user2p(), Active);
|
||||
AstActive* const oldactivep = m_vscpAux(dlyvscp).activep;
|
||||
checkActivePost(nodep, oldactivep);
|
||||
}
|
||||
if (!dlyvscp) { // First use of this delayed variable
|
||||
} else { // First use of this delayed variable
|
||||
const string newvarname = string{"__Vdly__"} + nodep->varp()->shortName();
|
||||
dlyvscp = createVarSc(oldvscp, newvarname, 0, nullptr);
|
||||
AstNodeAssign* const prep = new AstAssignPre{
|
||||
@ -582,10 +588,10 @@ private:
|
||||
new AstVarRef{nodep->fileline(), oldvscp, VAccess::WRITE},
|
||||
new AstVarRef{nodep->fileline(), dlyvscp, VAccess::READ}};
|
||||
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
|
||||
AstActive* const newactp = createActive(nodep);
|
||||
dlyvscp->user2p(newactp);
|
||||
m_vscpAux(dlyvscp).activep = newactp;
|
||||
newactp->addStmtsp(prep); // Add to FRONT of statements
|
||||
newactp->addStmtsp(postp);
|
||||
}
|
||||
|
||||
@ -766,15 +766,22 @@ class GateDedupeHash final : public V3DupFinderUserSame {
|
||||
private:
|
||||
// NODE STATE
|
||||
// Ast*::user2p -> parent AstNodeAssign* for this rhsp
|
||||
// Ast*::user3p -> AstActive* of assign, for isSame() in test for duplicate
|
||||
// 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
|
||||
// AstNodeExpr::user3p -> see AuxAstNodeExpr via m_aux
|
||||
// VNUser1InUse m_inuser1; (Allocated for use in GateVisitor)
|
||||
// VNUser2InUse m_inuser2; (Allocated for use in GateVisitor)
|
||||
const VNUser3InUse m_inuser3;
|
||||
// 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
|
||||
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)
|
||||
void hashReplace(AstNode* oldp, AstNode* newp) {
|
||||
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
|
||||
// the whole hash entry tree involving the replaced node and
|
||||
// rehash. That's complicated and this is rare, so just remove it
|
||||
// from consideration.
|
||||
m_nodeDeleteds.insert(oldp);
|
||||
}
|
||||
bool isReplaced(AstNode* nodep) {
|
||||
bool isReplaced(AstNodeExpr* nodep) {
|
||||
// Assignment may have been hashReplaced, if so consider non-match (effectively removed)
|
||||
UASSERT_OBJ(!VN_IS(nodep, NodeAssign), nodep, "Dedup attempt on non-assign");
|
||||
AstNode* const extra1p = nodep->user3p();
|
||||
AstNode* const extra2p = nodep->user5p();
|
||||
return ((extra1p && m_nodeDeleteds.find(extra1p) != m_nodeDeleteds.end())
|
||||
|| (extra2p && m_nodeDeleteds.find(extra2p) != m_nodeDeleteds.end()));
|
||||
const auto& aux = m_auxNodeExpr(nodep);
|
||||
AstActive* const activep = aux.activep;
|
||||
AstNodeExpr* const condp = aux.condp;
|
||||
return (activep && m_nodeDeleteds.count(activep))
|
||||
|| (condp && m_nodeDeleteds.count(condp));
|
||||
}
|
||||
|
||||
// Callback from V3DupFinder::findDuplicate
|
||||
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)
|
||||
if (isReplaced(node1p) || isReplaced(node2p)) {
|
||||
if (isReplaced(expr1p) || isReplaced(expr2p)) {
|
||||
// UINFO(9, "isSame hit on replaced "<<(void*)node1p<<" "<<(void*)node2p<<endl);
|
||||
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();
|
||||
}
|
||||
|
||||
const AstNodeAssign* hashAndFindDupe(AstNodeAssign* assignp, AstNode* extra1p,
|
||||
AstNode* extra2p) {
|
||||
const AstNodeAssign* hashAndFindDupe(AstNodeAssign* assignp, AstActive* extra1p,
|
||||
AstNodeExpr* extra2p) {
|
||||
// Legal for extra1p/2p to be nullptr, we'll compare with other assigns with extras also
|
||||
// nullptr
|
||||
AstNode* const rhsp = assignp->rhsp();
|
||||
AstNodeExpr* const rhsp = assignp->rhsp();
|
||||
rhsp->user2p(assignp);
|
||||
rhsp->user3p(extra1p);
|
||||
rhsp->user5p(extra2p);
|
||||
auto& aux = m_auxNodeExpr(rhsp);
|
||||
aux.activep = extra1p;
|
||||
aux.condp = extra2p;
|
||||
|
||||
const auto inserted = m_dupFinder.insert(rhsp);
|
||||
const auto dupit = m_dupFinder.findDuplicate(rhsp, this);
|
||||
@ -865,13 +880,14 @@ public:
|
||||
|
||||
void check() {
|
||||
for (const auto& itr : m_dupFinder) {
|
||||
AstNode* const nodep = itr.second;
|
||||
const AstNode* const activep = nodep->user3p();
|
||||
const AstNode* const condVarp = nodep->user5p();
|
||||
AstNodeExpr* const nodep = VN_AS(itr.second, NodeExpr);
|
||||
const auto& aux = m_auxNodeExpr(nodep);
|
||||
const AstActive* const activep = aux.activep;
|
||||
const AstNodeExpr* const condVarp = aux.condp;
|
||||
if (!isReplaced(nodep)) {
|
||||
// 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.
|
||||
UASSERT_OBJ(!activep || (!VN_DELETED(activep) && VN_IS(activep, Active)), nodep,
|
||||
UASSERT_OBJ(!activep || (!VN_DELETED(activep)), nodep,
|
||||
"V3DupFinder check failed, lost active pointer");
|
||||
UASSERT_OBJ(!condVarp || !VN_DELETED(condVarp), nodep,
|
||||
"V3DupFinder check failed, lost if pointer");
|
||||
@ -899,7 +915,7 @@ private:
|
||||
// STATE
|
||||
GateDedupeHash m_ghash; // Hash used to find dupes of rhs of assign
|
||||
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_dedupable = true; // Determined the assign to be dedupable
|
||||
|
||||
|
||||
@ -343,8 +343,8 @@ private:
|
||||
newdp->cellName(newcellp->name());
|
||||
// Tag the old ifacerefp to ensure it leaves no stale
|
||||
// reference to the inlined cell.
|
||||
newdp->user5(false);
|
||||
ifacerefp->user5(true);
|
||||
newdp->user1(false);
|
||||
ifacerefp->user1(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -454,8 +454,8 @@ class InlineVisitor final : public VNVisitor {
|
||||
private:
|
||||
// NODE STATE
|
||||
// Cleared entire netlist
|
||||
// AstIfaceRefDType::user5p() // Whether the cell pointed to by this
|
||||
// // AstIfaceRefDType has been inlined
|
||||
// AstIfaceRefDType::user1() // Whether the cell pointed to by this
|
||||
// // AstIfaceRefDType has been inlined
|
||||
// Input:
|
||||
// AstNodeModule::user1p() // ModuleState instance (via m_moduleState)
|
||||
// Cleared each cell
|
||||
@ -464,7 +464,6 @@ private:
|
||||
// AstVar::user3() // bool Don't alias the user2, keep it as signal
|
||||
// AstCell::user4 // AstCell* of the created clone
|
||||
const VNUser4InUse m_inuser4;
|
||||
const VNUser5InUse m_inuser5;
|
||||
|
||||
ModuleStateUser1Allocator& m_moduleState;
|
||||
|
||||
@ -586,7 +585,7 @@ private:
|
||||
m_modp = nullptr;
|
||||
}
|
||||
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
|
||||
// This dtype may still be in use by the AstAssignVarScope created earlier
|
||||
// but that'll get cleared up later
|
||||
|
||||
@ -32,9 +32,9 @@ VL_DEFINE_DEBUG_FUNCTIONS;
|
||||
class InstrCountVisitor final : public VNVisitorConst {
|
||||
private:
|
||||
// NODE STATE
|
||||
// AstNode::user4() -> int. Path cost + 1, 0 means don't dump
|
||||
// AstNode::user5() -> bool. Processed if assertNoDups
|
||||
const VNUser4InUse m_inuser4;
|
||||
// AstNode::user1() -> bool. Processed if assertNoDups
|
||||
// AstNode::user2() -> int. Path cost + 1, 0 means don't dump
|
||||
const VNUser2InUse m_inuser2;
|
||||
|
||||
// MEMBERS
|
||||
uint32_t m_instrCount = 0; // Running count of instructions
|
||||
@ -99,10 +99,10 @@ private:
|
||||
// (which at the V3Order stage represent verilog tasks, not to
|
||||
// the CFuncs that V3Order will generate.) So don't check for
|
||||
// collisions in CFuncs.
|
||||
UASSERT_OBJ(!nodep->user5p(), nodep,
|
||||
UASSERT_OBJ(!nodep->user1p(), nodep,
|
||||
"Node originally inserted below logic vertex "
|
||||
<< static_cast<AstNode*>(nodep->user5p()));
|
||||
nodep->user5p(const_cast<void*>(reinterpret_cast<const void*>(m_startNodep)));
|
||||
<< static_cast<AstNode*>(nodep->user1p()));
|
||||
nodep->user1p(const_cast<void*>(reinterpret_cast<const void*>(m_startNodep)));
|
||||
}
|
||||
|
||||
// Save the count, and add it back in during ~VisitBase This allows
|
||||
@ -118,7 +118,7 @@ private:
|
||||
if (!m_ignoreRemaining) m_instrCount += savedCount;
|
||||
}
|
||||
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
|
||||
@ -185,10 +185,10 @@ private:
|
||||
reset();
|
||||
if (ifCount >= elseCount) {
|
||||
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 {
|
||||
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 {
|
||||
@ -212,10 +212,10 @@ private:
|
||||
reset();
|
||||
if (ifCount < 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 {
|
||||
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 {
|
||||
@ -289,7 +289,7 @@ private:
|
||||
class InstrCountDumpVisitor final : public VNVisitorConst {
|
||||
private:
|
||||
// NODE STATE
|
||||
// AstNode::user4() -> int. Path cost, 0 means don't dump
|
||||
// AstNode::user2() -> int. Path cost, 0 means don't dump
|
||||
|
||||
// MEMBERS
|
||||
std::ostream* const m_osp; // Dump file
|
||||
@ -310,7 +310,7 @@ private:
|
||||
string indent() const { return string(m_depth, ':') + " "; }
|
||||
void visit(AstNode* nodep) override {
|
||||
++m_depth;
|
||||
if (unsigned costPlus1 = nodep->user4()) {
|
||||
if (unsigned costPlus1 = nodep->user2()) {
|
||||
*m_osp << " " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1)
|
||||
<< " " << nodep << '\n';
|
||||
iterateChildrenConst(nodep);
|
||||
|
||||
@ -36,7 +36,7 @@ public:
|
||||
// If nodep is an AstActive, returns 0.
|
||||
// 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,
|
||||
// potentially) raises an error.
|
||||
// Optional osp is stream to dump critical path to.
|
||||
|
||||
@ -2004,10 +2004,7 @@ private:
|
||||
// *::user2p() -> See LinkDotState
|
||||
// *::user3() // bool. Processed
|
||||
// *::user4() -> See LinkDotState
|
||||
// Cleared on Cell
|
||||
// AstVar::user5() // bool. True if pin used in this cell
|
||||
const VNUser3InUse m_inuser3;
|
||||
const VNUser5InUse m_inuser5;
|
||||
|
||||
// TYPES
|
||||
enum DotPosition : uint8_t {
|
||||
@ -2034,6 +2031,7 @@ private:
|
||||
// They are added to the set only in linkDotPrimary.
|
||||
bool m_insideClassExtParam = false; // Inside a class from m_extendsParam
|
||||
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 {
|
||||
DotPosition m_dotPos; // Scope part of dotted resolution
|
||||
@ -2162,15 +2160,15 @@ private:
|
||||
UASSERT_OBJ(ifaceTopVarp, nodep, "Can't find interface var ref: " << findName);
|
||||
return ifaceTopVarp;
|
||||
}
|
||||
void markAndCheckPinDup(AstNode* nodep, AstNode* refp, const char* whatp) {
|
||||
if (refp->user5p() && refp->user5p() != nodep) {
|
||||
void markAndCheckPinDup(AstPin* nodep, AstNode* refp, const char* whatp) {
|
||||
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->warnContextPrimary() << '\n'
|
||||
<< refp->user5p()->warnOther()
|
||||
<< "... Location of original " << whatp << " connection\n"
|
||||
<< refp->user5p()->warnContextSecondary());
|
||||
} else {
|
||||
refp->user5p(nodep);
|
||||
<< origp->warnOther() << "... Location of original "
|
||||
<< whatp << " connection\n"
|
||||
<< origp->warnContextSecondary());
|
||||
}
|
||||
}
|
||||
VSymEnt* getCreateClockingEventSymEnt(AstClocking* clockingp) {
|
||||
@ -2314,7 +2312,7 @@ private:
|
||||
void visit(AstCell* nodep) override {
|
||||
// Cell: Recurse inside or cleanup not founds
|
||||
checkNoDot(nodep);
|
||||
AstNode::user5ClearTree();
|
||||
m_usedPins.clear();
|
||||
UASSERT_OBJ(nodep->modp(), nodep,
|
||||
"Cell has unlinked module"); // V3LinkCell should have errored out
|
||||
VL_RESTORER(m_cellp);
|
||||
@ -2343,7 +2341,7 @@ private:
|
||||
void visit(AstClassRefDType* nodep) override {
|
||||
// Cell: Recurse inside or cleanup not founds
|
||||
checkNoDot(nodep);
|
||||
AstNode::user5ClearTree();
|
||||
m_usedPins.clear();
|
||||
UASSERT_OBJ(nodep->classp(), nodep, "ClassRef has unlinked class");
|
||||
UASSERT_OBJ(m_statep->forPrimary() || !nodep->paramsp(), nodep,
|
||||
"class reference parameter not removed by V3Param");
|
||||
@ -2905,7 +2903,7 @@ private:
|
||||
void visit(AstClassOrPackageRef* nodep) override {
|
||||
// Class: Recurse inside or cleanup not founds
|
||||
// checkNoDot not appropriate, can be under a dot
|
||||
AstNode::user5ClearTree();
|
||||
m_usedPins.clear();
|
||||
UASSERT_OBJ(m_statep->forPrimary() || VN_IS(nodep->classOrPackageNodep(), ParamTypeDType)
|
||||
|| nodep->classOrPackagep(),
|
||||
nodep, "ClassRef has unlinked class");
|
||||
|
||||
@ -159,11 +159,10 @@ class CodeMotionAnalysisVisitor final : public VNVisitorConst {
|
||||
// NODE STATE
|
||||
// AstNodeStmt::user3 -> StmtProperties (accessed via m_stmtProperties, managed externally,
|
||||
// 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::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;
|
||||
|
||||
@ -212,14 +211,14 @@ class CodeMotionAnalysisVisitor final : public VNVisitorConst {
|
||||
// First time seeing this condition in the current list
|
||||
dupFinder.insert(condp);
|
||||
// Remember last statement with this condition (which is this statement)
|
||||
condp->user5p(nodep);
|
||||
condp->user3p(nodep);
|
||||
} else {
|
||||
// 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
|
||||
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)
|
||||
firstp->user5p(nodep);
|
||||
firstp->user3p(nodep);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -430,13 +429,13 @@ private:
|
||||
// NODE STATE
|
||||
// AstVar::user1 -> bool: Set for variables referenced by m_mgCondp
|
||||
// (Only below MergeCondVisitor::process).
|
||||
// AstNode::user2 -> bool: Marking node as included in merge because cheap to
|
||||
// duplicate
|
||||
// AstNode::user2 -> bool: Marking node as included in merge because cheap to duplicate
|
||||
// (Only below MergeCondVisitor::process).
|
||||
// AstNodeStmt::user3 -> StmtProperties
|
||||
// (Only below MergeCondVisitor::process).
|
||||
// AstNodeExpr::user3 -> See CodeMotionAnalysisVisitor
|
||||
// (Only below MergeCondVisitor::process).
|
||||
// AstNode::user4 -> See CodeMotionAnalysisVisitor/CodeMotionOptimizeVisitor
|
||||
// AstNode::user5 -> See CodeMotionAnalysisVisitor
|
||||
|
||||
// STATE
|
||||
VDouble0 m_statMerges; // Statistic tracking
|
||||
|
||||
@ -218,21 +218,21 @@ public:
|
||||
|
||||
class ParamProcessor final {
|
||||
// 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,
|
||||
// // 65+ parameter numbered)
|
||||
// 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
|
||||
// values and an unchanged copy is needed to instantiate
|
||||
// classes with different parameters.
|
||||
// AstNodeModule::user5() // bool True if processed
|
||||
// AstGenFor::user5() // bool True if processed
|
||||
// AstVar::user5() // bool True if constant propagated
|
||||
// AstCell::user5p() // string* Generate portion of hierarchical name
|
||||
const VNUser4InUse m_inuser4;
|
||||
const VNUser5InUse m_inuser5;
|
||||
// User1/2/3 used by constant function simulations
|
||||
// AstNodeModule::user2() // bool True if processed
|
||||
// AstGenFor::user2() // bool True if processed
|
||||
// AstVar::user2() // bool True if constant propagated
|
||||
// AstCell::user2p() // string* Generate portion of hierarchical name
|
||||
const VNUser2InUse m_inuser2;
|
||||
const VNUser3InUse m_inuser3;
|
||||
// User1 used by constant function simulations
|
||||
|
||||
// TYPES
|
||||
// Note may have duplicate entries
|
||||
@ -284,20 +284,20 @@ class ParamProcessor final {
|
||||
char ch = varp->name()[0];
|
||||
ch = std::toupper(ch);
|
||||
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)]++;
|
||||
}
|
||||
} else if (AstParamTypeDType* const typep = VN_CAST(stmtp, ParamTypeDType)) {
|
||||
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)]++;
|
||||
}
|
||||
}
|
||||
}
|
||||
static string paramSmallName(AstNodeModule* modp, AstNode* varp) {
|
||||
if (varp->user4() <= 1) makeSmallNames(modp);
|
||||
int index = varp->user4() / 256;
|
||||
const char ch = varp->user4() & 255;
|
||||
if (varp->user3() <= 1) makeSmallNames(modp);
|
||||
int index = varp->user3() / 256;
|
||||
const char ch = varp->user3() & 255;
|
||||
string st = cvtToStr(ch);
|
||||
while (index) {
|
||||
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
|
||||
// However links outside the module (like on the upper cells) will not.
|
||||
AstNodeModule* newmodp;
|
||||
if (srcModp->user4p()) {
|
||||
newmodp = VN_CAST(srcModp->user4p()->cloneTree(false), NodeModule);
|
||||
if (srcModp->user3p()) {
|
||||
newmodp = VN_CAST(srcModp->user3p()->cloneTree(false), NodeModule);
|
||||
} else {
|
||||
newmodp = srcModp->cloneTree(false);
|
||||
}
|
||||
@ -583,7 +583,7 @@ class ParamProcessor final {
|
||||
}
|
||||
|
||||
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->recursiveClone(false);
|
||||
// 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
|
||||
// Note we allow multiple users of a parameterized model,
|
||||
// thus we need to stash this info.
|
||||
collectPins(clonemapp, newmodp, srcModp->user4p());
|
||||
collectPins(clonemapp, newmodp, srcModp->user3p());
|
||||
// Relink parameter vars to the new module
|
||||
relinkPins(clonemapp, paramsp);
|
||||
// Fix any interface references
|
||||
@ -853,14 +853,14 @@ class ParamProcessor final {
|
||||
|
||||
if (!any_overrides) {
|
||||
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.
|
||||
// user4p will also be used to check if the default instance is used.
|
||||
if (!srcModpr->user4p() && VN_IS(srcModpr, Class)) {
|
||||
// If it's the first use of the default instance, create a copy and store it in user3p.
|
||||
// user3p will also be used to check if the default instance is used.
|
||||
if (!srcModpr->user3p() && VN_IS(srcModpr, Class)) {
|
||||
AstClass* classCopyp = VN_AS(srcModpr, Class)->cloneTree(false);
|
||||
// It is a temporary copy of the original class node, stored in order to create
|
||||
// another instances. It is needed only during class instantiation.
|
||||
m_deleter.pushDeletep(classCopyp);
|
||||
srcModpr->user4p(classCopyp);
|
||||
srcModpr->user3p(classCopyp);
|
||||
storeOriginalParams(classCopyp);
|
||||
}
|
||||
} else if (AstNodeModule* const paramedModp
|
||||
@ -1002,9 +1002,9 @@ class ParamVisitor final : public VNVisitor {
|
||||
AstNodeModule* const modp = itm->second;
|
||||
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
|
||||
if (!modp->user5SetOnce()) {
|
||||
if (!modp->user2SetOnce()) {
|
||||
|
||||
// TODO: this really should be an assert, but classes and hier_blocks are
|
||||
// special...
|
||||
@ -1040,9 +1040,9 @@ class ParamVisitor final : public VNVisitor {
|
||||
|
||||
// Update path
|
||||
string someInstanceName(modp->someInstanceName());
|
||||
if (const string* const genHierNamep = cellp->user5u().to<string*>()) {
|
||||
if (const string* const genHierNamep = cellp->user2u().to<string*>()) {
|
||||
someInstanceName += *genHierNamep;
|
||||
cellp->user5p(nullptr);
|
||||
cellp->user2p(nullptr);
|
||||
VL_DO_DANGLING(delete genHierNamep, genHierNamep);
|
||||
}
|
||||
|
||||
@ -1077,7 +1077,7 @@ class ParamVisitor final : public VNVisitor {
|
||||
void visitCellOrClassRef(AstNode* nodep, bool isIface) {
|
||||
// Must do ifaces first, so push to list and do in proper order
|
||||
string* const genHierNamep = new std::string{m_generateHierName};
|
||||
nodep->user5p(genHierNamep);
|
||||
nodep->user2p(genHierNamep);
|
||||
// Visit parameters in the instantiation.
|
||||
iterateChildren(nodep);
|
||||
m_cellps.emplace(!isIface, nodep);
|
||||
@ -1133,7 +1133,7 @@ class ParamVisitor final : public VNVisitor {
|
||||
|
||||
// Make sure all parameters are constantified
|
||||
void visit(AstVar* nodep) override {
|
||||
if (nodep->user5SetOnce()) return; // Process once
|
||||
if (nodep->user2SetOnce()) return; // Process once
|
||||
iterateChildren(nodep);
|
||||
if (nodep->isParam()) {
|
||||
if (!nodep->valuep() && !VN_IS(m_modp, Class)) {
|
||||
@ -1428,7 +1428,7 @@ public:
|
||||
for (AstNodeModule* const modp : modps) netlistp->addModulesp(modp);
|
||||
|
||||
for (AstClass* const classp : m_paramClasses) {
|
||||
if (!classp->user4p()) {
|
||||
if (!classp->user3p()) {
|
||||
// The default value isn't referenced, so it can be removed
|
||||
VL_DO_DANGLING(pushDeletep(classp->unlinkFrBack()), classp);
|
||||
} else {
|
||||
|
||||
@ -2662,9 +2662,9 @@ uint32_t V3Partition::setupMTaskDeps(V3Graph* mtasksp) {
|
||||
// coarsening algorithm assumes that the graph is connected.
|
||||
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.
|
||||
const VNUser5InUse user5inUse;
|
||||
const VNUser1InUse user1inUse;
|
||||
|
||||
// Create the LogicMTasks for each MTaskMoveVertex
|
||||
for (V3GraphVertex *vtxp = m_fineDepsGraphp->verticesBeginp(), *nextp; vtxp; vtxp = nextp) {
|
||||
|
||||
@ -36,6 +36,7 @@
|
||||
#include "verilatedos.h"
|
||||
|
||||
#include "V3Ast.h"
|
||||
#include "V3AstUserAllocator.h"
|
||||
#include "V3Error.h"
|
||||
#include "V3Task.h"
|
||||
#include "V3Width.h"
|
||||
@ -76,19 +77,25 @@ private:
|
||||
// NODE STATE
|
||||
// Cleared on each always/assignw
|
||||
const VNUser1InUse m_inuser1;
|
||||
const VNUser2InUse m_inuser2;
|
||||
const VNUser3InUse m_inuser3;
|
||||
|
||||
// Checking:
|
||||
// AstVar(Scope)::user1() -> VarUsage. Set true to indicate tracking as lvalue/rvalue
|
||||
// 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)
|
||||
// AstVar/AstVarScope::user1p() -> See AuxAstVar via m_varAux
|
||||
// AstConst::user1() -> bool. This AstConst (allocated by this class) is in use
|
||||
|
||||
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
|
||||
// Major mode
|
||||
bool m_checkOnly; ///< Checking only (no simulation) mode
|
||||
@ -223,14 +230,14 @@ private:
|
||||
bool allocNewConst = true;
|
||||
if (!freeList.empty()) {
|
||||
constp = freeList.front();
|
||||
if (!constp->user2()) {
|
||||
if (!constp->user1()) {
|
||||
// Front of free list is free, reuse it (otherwise allocate new node)
|
||||
allocNewConst = false; // No need to allocate
|
||||
// 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
|
||||
// front of the list will be marked as used, in which case the enclosing 'if' will
|
||||
// fail and we fall back to allocation.
|
||||
constp->user2(1);
|
||||
constp->user1(1);
|
||||
freeList.pop_front();
|
||||
freeList.push_back(constp);
|
||||
// configure const
|
||||
@ -241,7 +248,7 @@ private:
|
||||
// Need to allocate new constant
|
||||
constp = new AstConst{nodep->fileline(), AstConst::DTyped{}, nodep->dtypep()};
|
||||
// Mark as in use, add to free list for later reuse
|
||||
constp->user2(1);
|
||||
constp->user1(1);
|
||||
freeList.push_back(constp);
|
||||
}
|
||||
return constp;
|
||||
@ -273,7 +280,7 @@ private:
|
||||
}
|
||||
AstConst* newConst(AstNode* nodep) {
|
||||
// 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);
|
||||
setValue(nodep, constp);
|
||||
return constp;
|
||||
@ -283,7 +290,7 @@ private:
|
||||
}
|
||||
AstConst* newOutConst(AstNode* nodep) {
|
||||
// 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);
|
||||
setOutValue(nodep, constp);
|
||||
return constp;
|
||||
@ -293,10 +300,10 @@ private:
|
||||
}
|
||||
|
||||
public:
|
||||
AstNodeExpr* fetchValueNull(AstNode* nodep) { return VN_AS(nodep->user3p(), NodeExpr); }
|
||||
AstNodeExpr* fetchValueNull(AstNode* nodep) { return m_varAux(nodep).valuep; }
|
||||
|
||||
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* fetchOutConstNull(AstNode* nodep) {
|
||||
return VN_CAST(fetchOutValueNull(nodep), Const);
|
||||
@ -332,15 +339,15 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
void setValue(AstNode* nodep, const AstNodeExpr* valuep) {
|
||||
void setValue(AstNode* nodep, AstNodeExpr* valuep) {
|
||||
UASSERT_OBJ(valuep, nodep, "Simulate setting null value");
|
||||
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");
|
||||
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) {
|
||||
@ -429,26 +436,26 @@ private:
|
||||
clearOptimizable(nodep, "Array references/not basic");
|
||||
if (nodep->access().isWriteOrRW()) {
|
||||
if (m_inDlyAssign) {
|
||||
if (!(vscp->user1() & VU_LVDLY)) {
|
||||
vscp->user1(vscp->user1() | VU_LVDLY);
|
||||
if (!(m_varAux(vscp).usage & VU_LVDLY)) {
|
||||
m_varAux(vscp).usage |= VU_LVDLY;
|
||||
if (m_checkOnly) varRefCb(nodep);
|
||||
}
|
||||
} else { // nondly asn
|
||||
if (!(vscp->user1() & VU_LV)) {
|
||||
if (!m_params && (vscp->user1() & VU_RV)) {
|
||||
if (!(m_varAux(vscp).usage & VU_LV)) {
|
||||
if (!m_params && (m_varAux(vscp).usage & VU_RV)) {
|
||||
clearOptimizable(nodep, "Var read & write");
|
||||
}
|
||||
vscp->user1(vscp->user1() | VU_LV);
|
||||
m_varAux(vscp).usage |= VarUsage::VU_LV;
|
||||
if (m_checkOnly) varRefCb(nodep);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (nodep->access().isReadOrRW()) {
|
||||
if (!(vscp->user1() & VU_RV)) {
|
||||
if (!m_params && (vscp->user1() & VU_LV)) {
|
||||
if (!(m_varAux(vscp).usage & VU_RV)) {
|
||||
if (!m_params && (m_varAux(vscp).usage & VU_LV)) {
|
||||
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())
|
||||
&& nodep->varp()->valuep();
|
||||
AstNodeExpr* const valuep
|
||||
@ -717,7 +724,7 @@ private:
|
||||
AstNodeExpr* const valuep = newTrackedClone(fetchValue(nodep->rhsp()));
|
||||
UINFO(9, " set val[" << index << "] = " << valuep << endl);
|
||||
// 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);
|
||||
if (debug() >= 9) initp->dumpTree("- array: ");
|
||||
assignOutValue(nodep, vscp, initp);
|
||||
@ -1224,8 +1231,7 @@ public:
|
||||
m_jumpp = nullptr;
|
||||
|
||||
AstNode::user1ClearTree();
|
||||
AstNode::user2ClearTree(); // Also marks all elements in m_constps as free
|
||||
AstNode::user3ClearTree();
|
||||
m_varAux.clear();
|
||||
}
|
||||
void mainTableCheck(AstNode* nodep) {
|
||||
setMode(true /*scoped*/, true /*checking*/, false /*params*/);
|
||||
|
||||
@ -183,7 +183,7 @@ private:
|
||||
const VNUser1InUse m_user1InUse;
|
||||
const VNUser2InUse m_user2InUse;
|
||||
const VNUser3InUse m_user3InUse;
|
||||
const VNUser5InUse m_user5InUse;
|
||||
const VNUser4InUse m_user4InUse;
|
||||
|
||||
// STATE
|
||||
VMemberMap m_memberMap; // Member names cached for fast lookup
|
||||
@ -214,8 +214,8 @@ private:
|
||||
classp = VN_CAST(funcp->scopep()->modp(), Class);
|
||||
}
|
||||
}
|
||||
if (!nodep->user5p()) nodep->user5p(new NeedsProcDepVtx{&m_procGraph, nodep, classp});
|
||||
return nodep->user5u().to<NeedsProcDepVtx*>();
|
||||
if (!nodep->user4p()) nodep->user4p(new NeedsProcDepVtx{&m_procGraph, nodep, classp});
|
||||
return nodep->user4u().to<NeedsProcDepVtx*>();
|
||||
}
|
||||
// Pass timing flag between nodes
|
||||
bool passFlag(const AstNode* from, AstNode* to, NodeFlag flag) {
|
||||
|
||||
@ -119,6 +119,7 @@
|
||||
|
||||
#include "V3Tristate.h"
|
||||
|
||||
#include "V3AstUserAllocator.h"
|
||||
#include "V3Graph.h"
|
||||
#include "V3Inst.h"
|
||||
#include "V3Stats.h"
|
||||
@ -176,8 +177,8 @@ public:
|
||||
|
||||
class TristateGraph final {
|
||||
// NODE STATE
|
||||
// AstVar::user5p -> TristateVertex* for variable being built
|
||||
// VNUser5InUse m_inuser5; // In visitor below
|
||||
// AstVar::user4p -> TristateVertex* for variable being built
|
||||
// VNUser4InUse m_inuser4; // In visitor below
|
||||
|
||||
// TYPES
|
||||
public:
|
||||
@ -197,11 +198,11 @@ private:
|
||||
// METHODS
|
||||
|
||||
TristateVertex* makeVertex(AstNode* nodep) {
|
||||
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
|
||||
TristateVertex* vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
|
||||
if (!vertexp) {
|
||||
UINFO(6, " New vertex " << nodep << endl);
|
||||
vertexp = new TristateVertex{&m_graph, nodep};
|
||||
nodep->user5p(vertexp);
|
||||
nodep->user4p(vertexp);
|
||||
}
|
||||
return vertexp;
|
||||
}
|
||||
@ -279,7 +280,7 @@ public:
|
||||
}
|
||||
}
|
||||
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) {
|
||||
UINFO(9, " Walking " << nodep << endl);
|
||||
@ -298,7 +299,7 @@ public:
|
||||
if (!nodep) return;
|
||||
// Skip vars, because they may be connected to more than one varref
|
||||
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);
|
||||
}
|
||||
deleteVerticesFromSubtreeRecurse(nodep->op1p());
|
||||
@ -308,15 +309,15 @@ public:
|
||||
}
|
||||
void setTristate(AstNode* nodep) { makeVertex(nodep)->isTristate(true); }
|
||||
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();
|
||||
}
|
||||
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();
|
||||
}
|
||||
void didProcess(AstNode* nodep) {
|
||||
TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user5p());
|
||||
TristateVertex* const vertexp = reinterpret_cast<TristateVertex*>(nodep->user4p());
|
||||
if (!vertexp) {
|
||||
// Not v3errorSrc as no reason to stop the world
|
||||
nodep->v3error("Unsupported tristate construct (not in propagation graph): "
|
||||
@ -390,16 +391,21 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
// NODE STATE
|
||||
// *::user1p -> pointer to output enable __en expressions
|
||||
// *::user2 -> int - already visited, see U2_ enum
|
||||
// AstVar::user3p -> AstPull* pullup/pulldown direction (input Var's user3p)
|
||||
// AstVar::user4p -> AstVar* pointer to output __out var (input Var's user2p)
|
||||
// AstVar::user3p -> See AuxAstVar via m_varAux
|
||||
// See TristateGraph:
|
||||
// AstVar::user5p -> TristateVertex* for variable being built
|
||||
// AstStmt*::user5p -> TristateVertex* for this statement
|
||||
// AstVar::user4p -> TristateVertex* for variable being built
|
||||
// AstStmt::user4p -> TristateVertex* for this statement
|
||||
const VNUser1InUse m_inuser1;
|
||||
const VNUser2InUse m_inuser2;
|
||||
const VNUser3InUse m_inuser3;
|
||||
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
|
||||
struct RefStrength {
|
||||
@ -531,14 +537,14 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
}
|
||||
AstVar* getCreateOutVarp(AstVar* invarp) {
|
||||
// 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,
|
||||
invarp->name() + "__out", invarp};
|
||||
UINFO(9, " newout " << newp << endl);
|
||||
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* const newp = new AstVar{fromp->fileline(), VVarType::MODULETEMP,
|
||||
@ -566,9 +572,9 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
}
|
||||
|
||||
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) {
|
||||
varp->user3p(pullp); // save off to indicate the pull direction
|
||||
m_varAux(varp).pullp = pullp; // save off to indicate the pull direction
|
||||
} else {
|
||||
if (oldpullp->direction() != pullp->direction()) {
|
||||
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*)
|
||||
//
|
||||
outvarp->user1p(envarp);
|
||||
outvarp->user3p(invarp->user3p()); // AstPull* propagation
|
||||
if (invarp->user3p()) UINFO(9, "propagate pull to " << outvarp << endl);
|
||||
m_varAux(outvarp).pullp = m_varAux(invarp).pullp; // AstPull* propagation
|
||||
if (m_varAux(invarp).pullp) UINFO(9, "propagate pull to " << outvarp << endl);
|
||||
} else if (invarp->user1p()) {
|
||||
envarp = VN_AS(invarp->user1p(), Var); // From CASEEQ, foo === 1'bz
|
||||
}
|
||||
@ -784,7 +790,7 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
if (!outvarp) {
|
||||
// This is the final pre-forced resolution of the tristate, so we apply
|
||||
// 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
|
||||
|
||||
AstNodeExpr* undrivenp;
|
||||
@ -1435,7 +1441,7 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
associateLogic(nodep, varrefp->varp());
|
||||
} else {
|
||||
// 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
|
||||
// current limitation of this implementation is that a pullup/down
|
||||
// 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) {
|
||||
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
|
||||
const AstAssignW* outAssignp = nullptr; // If reconnected, the related assignment
|
||||
AstPin* outpinp = nullptr;
|
||||
AstVar* const outModVarp = static_cast<AstVar*>(nodep->modVarp()->user4p());
|
||||
AstVar* const outModVarp = m_varAux(nodep->modVarp()).outVarp;
|
||||
if (!outModVarp) {
|
||||
// At top, no need for __out as might be input only. Otherwise resolvable.
|
||||
if (!m_modp->isTop()) {
|
||||
@ -1638,7 +1645,7 @@ class TristateVisitor final : public TristateBaseVisitor {
|
||||
|
||||
// Propagate any pullups/pulldowns upwards if necessary
|
||||
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);
|
||||
setPullDirection(exprrefp->varp(), pullp);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user