luke
/
verilator
mirror of https://github.com/verilator/verilator.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Internals: Use VL_RESTORER class to save/restore vars. No functional change intended.

This commit is contained in:
Wilson Snyder 2020-08-24 21:10:43 -04:00
parent 4265f9499d
commit bed3101dfc
42 changed files with 253 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/V3Assert.cpp
View File

@ -360,25 +360,22 @@ private:
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
unsigned origPastNum = m_modPastNum;
VL_RESTORER(m_modp);
VL_RESTORER(m_modPastNum);
{
m_modp = nodep;
m_modPastNum = 0;
iterateChildren(nodep);
}
m_modp = origModp;
m_modPastNum = origPastNum;
}
virtual void visit(AstBegin* nodep) override {
// This code is needed rather than a visitor in V3Begin,
// because V3Assert is called before V3Begin
AstBegin* lastp = m_beginp;
VL_RESTORER(m_beginp);
{
m_beginp = nodep;
iterateChildren(nodep);
}
m_beginp = lastp;
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }

12
src/V3Begin.cpp
View File

@ -71,12 +71,11 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstNodeFTask* nodep) override {
UINFO(8, " " << nodep << endl);
@ -91,8 +90,8 @@ private:
// naming; so that any begin's inside the function will rename
// inside the function.
// Process children
string oldScope = m_namedScope;
string oldUnnamed = m_unnamedScope;
VL_RESTORER(m_namedScope);
VL_RESTORER(m_unnamedScope);
{
m_namedScope = "";
m_unnamedScope = "";
@ -100,8 +99,6 @@ private:
iterateChildren(nodep);
m_ftaskp = nullptr;
}
m_namedScope = oldScope;
m_unnamedScope = oldUnnamed;
}
virtual void visit(AstBegin* nodep) override {
// Begin blocks were only useful in variable creation, change names and delete
@ -232,7 +229,7 @@ private:
// VISITORS - LINT CHECK
virtual void visit(AstIf* nodep) override { // not AstNodeIf; other types not covered
// Check IFDEPTH warning - could be in other transform files if desire
int prevIfDepth = m_ifDepth;
VL_RESTORER(m_ifDepth);
if (m_ifDepth == -1 || v3Global.opt.ifDepth() < 1) { // Turned off
} else if (nodep->uniquePragma() || nodep->unique0Pragma() || nodep->priorityPragma()) {
m_ifDepth = -1;
@ -243,7 +240,6 @@ private:
m_ifDepth = -1;
}
iterateChildren(nodep);
m_ifDepth = prevIfDepth;
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }

6
src/V3Branch.cpp
View File

@ -67,8 +67,8 @@ private:
// VISITORS
virtual void visit(AstNodeIf* nodep) override {
UINFO(4, " IF: " << nodep << endl);
int lastLikely = m_likely;
int lastUnlikely = m_unlikely;
VL_RESTORER(m_likely);
VL_RESTORER(m_unlikely);
{
// Do if
reset();
@ -88,8 +88,6 @@ private:
nodep->branchPred(VBranchPred::BP_UNLIKELY);
} // else leave unknown
}
m_likely = lastLikely;
m_unlikely = lastUnlikely;
}
virtual void visit(AstNodeCCall* nodep) override {
checkUnlikely(nodep);

3
src/V3CUse.cpp
View File

@ -86,12 +86,11 @@ class CUseDTypeVisitor : public AstNVisitor {
// No class.h, it's inside the class package's h file
m_stater.newUse(nodep, VUseType::IMP_INCLUDE, nodep->classp()->packagep()->name());
// Need to include extends() when we implement, but no need for pointers to know
bool oldImpOnly = m_impOnly;
VL_RESTORER(m_impOnly);
{
m_impOnly = true;
iterateChildren(nodep->classp()); // This also gets all extend classes
}
m_impOnly = oldImpOnly;
}
virtual void visit(AstNodeDType* nodep) override {
if (nodep->user2SetOnce()) return; // Process once

3
src/V3Cdc.cpp
View File

@ -626,12 +626,11 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);

29
src/V3Changed.cpp
View File

@ -143,23 +143,22 @@ private:
}
virtual void visit(AstUnpackArrayDType* nodep) override {
for (int index = 0; index < nodep->elementsConst(); ++index) {
AstNode* origVEp = m_varEqnp;
AstNode* origNLEp = m_newLvEqnp;
AstNode* origNREp = m_newRvEqnp;
VL_RESTORER(m_varEqnp);
VL_RESTORER(m_newLvEqnp);
VL_RESTORER(m_newRvEqnp);
{
m_varEqnp = new AstArraySel(nodep->fileline(), m_varEqnp->cloneTree(true), index);
m_newLvEqnp
= new AstArraySel(nodep->fileline(), m_newLvEqnp->cloneTree(true), index);
m_newRvEqnp
= new AstArraySel(nodep->fileline(), m_newRvEqnp->cloneTree(true), index);
m_varEqnp = new AstArraySel(nodep->fileline(), m_varEqnp->cloneTree(true), index);
m_newLvEqnp = new AstArraySel(nodep->fileline(), m_newLvEqnp->cloneTree(true), index);
m_newRvEqnp = new AstArraySel(nodep->fileline(), m_newRvEqnp->cloneTree(true), index);
iterate(nodep->subDTypep()->skipRefp());
iterate(nodep->subDTypep()->skipRefp());
m_varEqnp->deleteTree();
m_newLvEqnp->deleteTree();
m_newRvEqnp->deleteTree();
m_varEqnp = origVEp;
m_newLvEqnp = origNLEp;
m_newRvEqnp = origNREp;
m_varEqnp->deleteTree();
m_newLvEqnp->deleteTree();
m_newRvEqnp->deleteTree();
}
}
}
virtual void visit(AstNodeUOrStructDType* nodep) override {

6
src/V3Class.cpp
View File

@ -75,22 +75,20 @@ private:
classScopep->aboveScopep(), classScopep->aboveCellp());
packagep->addStmtp(scopep);
// Iterate
string prevPrefix = m_prefix;
VL_RESTORER(m_prefix);
{
m_classScopep = classScopep;
m_prefix = nodep->name() + "__02e"; // .
iterateChildren(nodep);
}
m_prefix = prevPrefix;
m_classScopep = nullptr;
}
virtual void visit(AstPackage* nodep) override {
string prevPrefix = m_prefix;
VL_RESTORER(m_prefix);
{
m_prefix = nodep->name() + "__03a__03a"; // ::
iterateChildren(nodep);
}
m_prefix = prevPrefix;
}
virtual void visit(AstVar* nodep) override {

3
src/V3Clean.cpp
View File

@ -171,12 +171,11 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);

3
src/V3Clock.cpp
View File

@ -273,12 +273,11 @@ private:
}
virtual void visit(AstNodeModule* nodep) override {
// UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) override {
// UINFO(4, " SCOPE " << nodep << endl);

3
src/V3Combine.cpp
View File

@ -195,12 +195,11 @@ private:
#ifdef VL_COMBINE_STATEMENTS
void hashFunctions(AstCFunc* nodep) {
// Compute hash of all statement trees in the function
CombineState oldState = m_state;
VL_RESTORER(m_state);
{
m_state = STATE_HASH;
iterate(nodep);
}
m_state = oldState;
}
#endif
void walkEmptyFuncs() {

12
src/V3Const.cpp
View File

@ -1284,12 +1284,11 @@ private:
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) override {
// No ASSIGNW removals under funcs, we've long eliminated INITIALs
@ -1561,10 +1560,11 @@ private:
}
virtual void visit(AstAttrOf* nodep) override {
AstAttrOf* oldAttr = m_attrp;
m_attrp = nodep;
iterateChildren(nodep);
m_attrp = oldAttr;
VL_RESTORER(m_attrp);
{
m_attrp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstArraySel* nodep) override {

21
src/V3Coverage.cpp
View File

@ -210,7 +210,7 @@ private:
// VISITORS - BOTH
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
CheckState lastState = m_state;
VL_RESTORER(m_state);
{
createHandle(nodep);
m_modp = nodep;
@ -224,7 +224,6 @@ private:
iterateChildren(nodep);
}
m_modp = origModp;
m_state = lastState;
}
virtual void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
@ -233,8 +232,8 @@ private:
if (!nodep->dpiImport()) iterateProcedure(nodep);
}
void iterateProcedure(AstNode* nodep) {
CheckState lastState = m_state;
bool oldtog = m_inToggleOff;
VL_RESTORER(m_state);
VL_RESTORER(m_inToggleOff);
{
m_inToggleOff = true;
createHandle(nodep);
@ -255,8 +254,6 @@ private:
}
}
}
m_state = lastState;
m_inToggleOff = oldtog;
}
// VISITORS - TOGGLE COVERAGE
@ -464,7 +461,7 @@ private:
// as we already have a warning when there is no default.
UINFO(4, " CASEI: " << nodep << endl);
if (m_state.lineCoverageOn(nodep)) {
CheckState lastState = m_state;
VL_RESTORER(m_state);
{
createHandle(nodep);
iterateAndNextNull(nodep->bodysp());
@ -476,12 +473,11 @@ private:
traceNameForLine(nodep, "case")));
}
}
m_state = lastState;
}
}
virtual void visit(AstCover* nodep) override {
UINFO(4, " COVER: " << nodep << endl);
CheckState lastState = m_state;
VL_RESTORER(m_state);
{
m_state.m_on = true; // Always do cover blocks, even if there's a $stop
createHandle(nodep);
@ -494,7 +490,6 @@ private:
m_beginHier + "_vlCoverageUserTrace"));
}
}
m_state = lastState;
}
virtual void visit(AstStop* nodep) override {
UINFO(4, " STOP: " << nodep << endl);
@ -517,8 +512,8 @@ private:
// generate blocks; each point should get separate consideration.
// (Currently ignored for line coverage, since any generate iteration
// covers the code in that line.)
string oldHier = m_beginHier;
bool oldtog = m_inToggleOff;
VL_RESTORER(m_beginHier);
VL_RESTORER(m_inToggleOff);
{
m_inToggleOff = true;
if (nodep->name() != "") {
@ -527,8 +522,6 @@ private:
iterateChildren(nodep);
lineTrack(nodep);
}
m_beginHier = oldHier;
m_inToggleOff = oldtog;
}
// VISITORS - BOTH

3
src/V3Dead.cpp
View File

@ -120,7 +120,7 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
if (!nodep->dead()) {
@ -135,7 +135,6 @@ private:
}
}
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) override {
iterateChildren(nodep);

22
src/V3Delayed.cpp
View File

@ -362,12 +362,13 @@ private:
}
virtual void visit(AstActive* nodep) override {
m_activep = nodep;
bool oldinit = m_inInitial;
m_inInitial = nodep->hasInitial();
AstNode::user3ClearTree(); // Two sets to same variable in different
// actives must use different vars.
iterateChildren(nodep);
m_inInitial = oldinit;
VL_RESTORER(m_inInitial);
{
m_inInitial = nodep->hasInitial();
// Two sets to same variable in different actives must use different vars.
AstNode::user3ClearTree();
iterateChildren(nodep);
}
}
virtual void visit(AstAssignDly* nodep) override {
m_inDly = true;
@ -465,10 +466,11 @@ private:
"For statements should have been converted to while statements in V3Begin");
}
virtual void visit(AstWhile* nodep) override {
bool oldloop = m_inLoop;
m_inLoop = true;
iterateChildren(nodep);
m_inLoop = oldloop;
VL_RESTORER(m_inLoop);
{
m_inLoop = true;
iterateChildren(nodep);
}
}
//--------------------

3
src/V3Depth.cpp
View File

@ -78,13 +78,12 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_funcp = nullptr;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) override {
m_funcp = nodep;

9
src/V3DepthBlock.cpp
View File

@ -68,25 +68,22 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_deepNum = 0;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) override {
// We recurse into this.
int lastDepth = m_depth;
AstCFunc* lastFuncp = m_funcp;
VL_RESTORER(m_depth);
VL_RESTORER(m_funcp);
{
m_depth = 0;
m_funcp = nodep;
iterateChildren(nodep);
}
m_depth = lastDepth;
m_funcp = lastFuncp;
}
void visitStmt(AstNodeStmt* nodep) {
m_depth++;

3
src/V3Descope.cpp
View File

@ -226,7 +226,7 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_modFuncs.clear();
@ -234,7 +234,6 @@ private:
iterateChildren(nodep);
makePublicFuncWrappers();
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) override {
m_scopep = nodep;

3
src/V3EmitCSyms.cpp
View File

@ -276,12 +276,11 @@ class EmitCSyms : EmitCBaseVisitor {
}
virtual void visit(AstNodeModule* nodep) override {
nameCheck(nodep);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCellInline* nodep) override {
if (v3Global.opt.vpi()) {

31
src/V3Gate.cpp
View File

@ -412,13 +412,12 @@ private:
replaceAssigns();
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_activeReducible = true;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
@ -469,10 +468,11 @@ private:
iterateNewStmt(nodep, (nodep->isJustOneBodyStmt() ? nullptr : "Multiple Stmts"), nullptr);
}
virtual void visit(AstAlwaysPublic* nodep) override {
bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, "AlwaysPublic", nullptr);
m_inSlow = lastslow;
VL_RESTORER(m_inSlow);
{
m_inSlow = true;
iterateNewStmt(nodep, "AlwaysPublic", nullptr);
}
}
virtual void visit(AstCFunc* nodep) override {
iterateNewStmt(nodep, "User C Function", "User C Function");
@ -487,10 +487,12 @@ private:
m_inSenItem = false;
}
virtual void visit(AstInitial* nodep) override {
bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, (nodep->isJustOneBodyStmt() ? nullptr : "Multiple Stmts"), nullptr);
m_inSlow = lastslow;
VL_RESTORER(m_inSlow);
{
m_inSlow = true;
iterateNewStmt(nodep, (nodep->isJustOneBodyStmt() ? nullptr : "Multiple Stmts"),
nullptr);
}
}
virtual void visit(AstAssignAlias* nodep) override { //
iterateNewStmt(nodep, nullptr, nullptr);
@ -502,10 +504,11 @@ private:
iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
}
virtual void visit(AstTraceDecl* nodep) override {
const bool lastslow = m_inSlow;
m_inSlow = true;
iterateNewStmt(nodep, "Tracing", "Tracing");
m_inSlow = lastslow;
VL_RESTORER(m_inSlow);
{
m_inSlow = true;
iterateNewStmt(nodep, "Tracing", "Tracing");
}
}
virtual void visit(AstConcat* nodep) override {
UASSERT_OBJ(!(VN_IS(nodep->backp(), NodeAssign)

22
src/V3Global.h
View File

@ -37,7 +37,27 @@ class AstNetlist;
class V3HierBlockPlan;
//======================================================================
// Statics
// Restorer
/// Save a given variable's value on the stack, restoring it at
/// end-of-stope.
// Object must be named, or it will not persist until end-of-scope.
// Constructor needs () or GCC 4.8 false warning.
#define VL_RESTORER(var) const VRestorer<decltype(var)> restorer_##var(var);
// Object used by VL_RESTORER. This object must be an auto variable, not
// allocated on the heap or otherwise.
template <typename T> class VRestorer {
T& m_ref; // Reference to object we're saving and restoring
const T m_saved; // Value saved, for later restore
public:
VRestorer(T& permr)
: m_ref(permr)
, m_saved(permr) {}
~VRestorer() { m_ref = m_saved; }
VL_UNCOPYABLE(VRestorer);
};
//######################################################################

5
src/V3Hashed.cpp
View File

@ -60,7 +60,7 @@ private:
nodep,
"Node " << nodep->prettyTypeName()
<< " in statement position but not marked stmt (node under function)");
V3Hash oldHash = m_lowerHash;
VL_RESTORER(m_lowerHash);
{
m_lowerHash = nodep->sameHash();
UASSERT_OBJ(!m_lowerHash.isIllegal(), nodep,
@ -74,9 +74,8 @@ private:
// Store the hash value
nodep->user4(m_lowerHash.fullValue());
// UINFO(9, " hashnode "<<m_lowerHash<<" "<<nodep<<endl);
thisHash = m_lowerHash;
}
thisHash = m_lowerHash;
m_lowerHash = oldHash;
}
// Update what will become the above node's hash
m_lowerHash += m_cacheInUser4 ? V3Hashed::nodeHash(nodep) : thisHash;

3
src/V3HierBlock.cpp
View File

@ -241,7 +241,7 @@ class HierBlockUsageCollectVisitor : public AstNVisitor {
UINFO(5, "Checking " << nodep->prettyNameQ() << " from "
<< (m_hierBlockp ? m_hierBlockp->prettyNameQ() : string("null"))
<< std::endl);
AstModule* const prevModp = m_modp;
VL_RESTORER(m_modp);
AstModule* const prevHierBlockp = m_hierBlockp;
ModuleSet prevReferred;
V3HierBlock::GParams prevGParams;
@ -260,7 +260,6 @@ class HierBlockUsageCollectVisitor : public AstNVisitor {
m_hierBlockp = prevHierBlockp;
m_referred = prevReferred;
}
m_modp = prevModp;
m_gparams = prevGParams;
}
virtual void visit(AstCell* nodep) override {

7
src/V3Inline.cpp
View File

@ -518,12 +518,11 @@ private:
}
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCell* nodep) override {
if (nodep->modp()->user1()) { // Marked with inline request
@ -638,7 +637,7 @@ private:
if (nodep->isTop()) { iterateChildren(nodep); }
}
virtual void visit(AstCell* nodep) override {
string oldScope = m_scope;
VL_RESTORER(m_scope);
if (m_scope.empty()) {
m_scope = nodep->name();
} else {
@ -668,8 +667,6 @@ private:
nodep->addIntfRefp(new AstIntfRef(nodep->fileline(), m_scope));
// No need to iterate on interface cells
}
m_scope = oldScope;
}
virtual void visit(AstAssignVarScope* nodep) override {
// Reference

6
src/V3LinkCells.cpp
View File

@ -195,7 +195,7 @@ private:
}
virtual void visit(AstNodeModule* nodep) override {
// Module: Pick up modnames, so we can resolve cells later
AstNodeModule* oldModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
UINFO(2, "Link Module: " << nodep << endl);
@ -233,7 +233,6 @@ private:
iterateChildren(nodep);
nodep->checkTree();
}
m_modp = oldModp;
}
virtual void visit(AstIfaceRefDType* nodep) override {
@ -273,14 +272,13 @@ private:
if (modp) {
AstNode* cellsp = nodep->cellsp()->unlinkFrBackWithNext();
// Module may have already linked, so need to pick up these new cells
AstNodeModule* oldModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = modp;
// Important that this adds to end, as next iterate assumes does all cells
modp->addStmtp(cellsp);
iterateAndNextNull(cellsp);
}
m_modp = oldModp;
}
pushDeletep(nodep->unlinkFrBack());
}

114
src/V3LinkDot.cpp
View File

@ -775,12 +775,12 @@ class LinkDotFindVisitor : public AstNVisitor {
// need separate handling
bool standalonePkg = !m_modSymp && (m_statep->forPrearray() && VN_IS(nodep, Package));
bool doit = (m_modSymp || standalonePkg);
string oldscope = m_scope;
VSymEnt* oldModSymp = m_modSymp;
VSymEnt* oldCurSymp = m_curSymp;
int oldParamNum = m_paramNum;
int oldBlockNum = m_blockNum;
int oldModBlockNum = m_modBlockNum;
VL_RESTORER(m_scope);
VL_RESTORER(m_modSymp);
VL_RESTORER(m_curSymp);
VL_RESTORER(m_paramNum);
VL_RESTORER(m_blockNum);
VL_RESTORER(m_modBlockNum);
if (doit && nodep->user2()) {
nodep->v3warn(E_UNSUPPORTED,
"Unsupported: Identically recursive module (module instantiates "
@ -830,24 +830,18 @@ class LinkDotFindVisitor : public AstNVisitor {
// Can't remove now, as our backwards iterator will throw up
UINFO(5, "Module not under any CELL or top - dead module: " << nodep << endl);
}
m_scope = oldscope;
m_modSymp = oldModSymp;
m_curSymp = oldCurSymp;
m_paramNum = oldParamNum;
m_blockNum = oldBlockNum;
m_modBlockNum = oldModBlockNum;
// Prep for next
m_packagep = nullptr;
}
virtual void visit(AstClass* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Class not under module/package/$unit");
UINFO(8, " " << nodep << endl);
string oldscope = m_scope;
VSymEnt* oldModSymp = m_modSymp;
VSymEnt* oldCurSymp = m_curSymp;
int oldParamNum = m_paramNum;
int oldBlockNum = m_blockNum;
int oldModBlockNum = m_modBlockNum;
VL_RESTORER(m_scope);
VL_RESTORER(m_modSymp);
VL_RESTORER(m_curSymp);
VL_RESTORER(m_paramNum);
VL_RESTORER(m_blockNum);
VL_RESTORER(m_modBlockNum);
{
UINFO(4, " Link Class: " << nodep << endl);
VSymEnt* upperSymp = m_curSymp;
@ -868,12 +862,6 @@ class LinkDotFindVisitor : public AstNVisitor {
// Implicit new needed?
if (!m_explicitNew && m_statep->forPrimary()) makeImplicitNew(nodep);
}
m_scope = oldscope;
m_modSymp = oldModSymp;
m_curSymp = oldCurSymp;
m_paramNum = oldParamNum;
m_blockNum = oldBlockNum;
m_modBlockNum = oldModBlockNum;
}
virtual void visit(AstScope* nodep) override {
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
@ -886,12 +874,12 @@ class LinkDotFindVisitor : public AstNVisitor {
if (nodep->recursive() && m_inRecursion) return;
iterateChildren(nodep);
// Recurse in, preserving state
string oldscope = m_scope;
AstNodeBlock* oldblockp = m_blockp;
VSymEnt* oldModSymp = m_modSymp;
VSymEnt* oldCurSymp = m_curSymp;
int oldParamNum = m_paramNum;
bool oldRecursion = m_inRecursion;
VL_RESTORER(m_scope);
VL_RESTORER(m_blockp);
VL_RESTORER(m_modSymp);
VL_RESTORER(m_curSymp);
VL_RESTORER(m_paramNum);
VL_RESTORER(m_inRecursion);
// Where do we add it?
VSymEnt* aboveSymp = m_curSymp;
string origname = AstNode::dedotName(nodep->name());
@ -914,12 +902,6 @@ class LinkDotFindVisitor : public AstNVisitor {
// We don't report NotFoundModule, as may be a unused module in a generate
if (nodep->modp()) iterate(nodep->modp());
}
m_scope = oldscope;
m_blockp = oldblockp;
m_modSymp = oldModSymp;
m_curSymp = oldCurSymp;
m_paramNum = oldParamNum;
m_inRecursion = oldRecursion;
}
virtual void visit(AstCellInline* nodep) override {
UINFO(5, " CELLINLINE under " << m_scope << " is " << nodep << endl);
@ -972,9 +954,10 @@ class LinkDotFindVisitor : public AstNVisitor {
if (nodep->name() == "") {
iterateChildren(nodep);
} else {
int oldNum = m_blockNum;
AstNodeBlock* oldblockp = m_blockp;
VSymEnt* oldCurSymp = m_curSymp;
VL_RESTORER(m_blockNum);
VL_RESTORER(m_blockp);
VL_RESTORER(m_curSymp);
VSymEnt* const oldCurSymp = m_curSymp;
{
m_blockNum = 0;
m_blockp = nodep;
@ -983,9 +966,6 @@ class LinkDotFindVisitor : public AstNVisitor {
// Iterate
iterateChildren(nodep);
}
m_curSymp = oldCurSymp;
m_blockp = oldblockp;
m_blockNum = oldNum;
}
}
virtual void visit(AstNodeFTask* nodep) override {
@ -994,7 +974,8 @@ class LinkDotFindVisitor : public AstNVisitor {
UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Function/Task not under module?");
if (nodep->name() == "new") m_explicitNew = true;
// Remember the existing symbol table scope
VSymEnt* oldCurSymp = m_curSymp;
VL_RESTORER(m_curSymp);
VSymEnt* const oldCurSymp = m_curSymp;
{
// Change to appropriate package if extern declaration (vs definition)
if (nodep->packagep()) {
@ -1049,7 +1030,6 @@ class LinkDotFindVisitor : public AstNVisitor {
iterateChildren(nodep);
m_ftaskp = nullptr;
}
m_curSymp = oldCurSymp;
}
virtual void visit(AstVar* nodep) override {
// Var: Remember its name for later resolution
@ -1619,14 +1599,14 @@ class LinkDotIfaceVisitor : public AstNVisitor {
virtual void visit(AstModport* nodep) override {
// Modport: Remember its name for later resolution
UINFO(5, " fiv: " << nodep << endl);
VSymEnt* oldCurSymp = m_curSymp;
VL_RESTORER(m_curSymp);
VSymEnt* const oldCurSymp = m_curSymp;
{
// Create symbol table for the vars
m_curSymp = m_statep->insertBlock(m_curSymp, nodep->name(), nodep, nullptr);
m_curSymp->fallbackp(oldCurSymp);
iterateChildren(nodep);
}
m_curSymp = oldCurSymp;
}
virtual void visit(AstModportFTaskRef* nodep) override {
UINFO(5, " fif: " << nodep << endl);
@ -1878,14 +1858,14 @@ private:
}
virtual void visit(AstScope* nodep) override {
UINFO(8, " " << nodep << endl);
VSymEnt* oldModSymp = m_modSymp;
VSymEnt* oldCurSymp = m_curSymp;
checkNoDot(nodep);
m_ds.m_dotSymp = m_curSymp = m_modSymp = m_statep->getScopeSym(nodep);
iterateChildren(nodep);
m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
m_modSymp = oldModSymp;
m_curSymp = oldCurSymp;
VL_RESTORER(m_modSymp);
VL_RESTORER(m_curSymp);
{
checkNoDot(nodep);
m_ds.m_dotSymp = m_curSymp = m_modSymp = m_statep->getScopeSym(nodep);
iterateChildren(nodep);
m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
}
}
virtual void visit(AstCellInline* nodep) override {
checkNoDot(nodep);
@ -2414,12 +2394,11 @@ private:
}
virtual void visit(AstMethodCall* nodep) override {
// Created here so should already be resolved.
DotStates lastStates = m_ds;
VL_RESTORER(m_ds);
{
m_ds.init(m_curSymp);
iterateChildren(nodep);
}
m_ds = lastStates;
}
virtual void visit(AstWith* nodep) override {
nodep->v3warn(E_UNSUPPORTED, "Unsupported: with statements");
@ -2583,12 +2562,11 @@ private:
}
taskFuncSwapCheck(nodep);
}
DotStates lastStates = m_ds;
{
VL_RESTORER(m_ds);
m_ds.init(m_curSymp);
iterateChildren(nodep);
}
m_ds = lastStates;
}
virtual void visit(AstSelBit* nodep) override {
if (nodep->user3SetOnce()) return;
@ -2602,13 +2580,14 @@ private:
}
// Pass dot state down to fromp()
iterateAndNextNull(nodep->fromp());
DotStates lastStates = m_ds;
{
m_ds.init(m_curSymp);
iterateAndNextNull(nodep->bitp());
iterateAndNextNull(nodep->attrp());
VL_RESTORER(m_ds);
{
m_ds.init(m_curSymp);
iterateAndNextNull(nodep->bitp());
iterateAndNextNull(nodep->attrp());
}
}
m_ds = lastStates;
if (m_ds.m_unresolved && m_ds.m_dotPos == DP_SCOPE) {
AstNode* exprp = nodep->bitp()->unlinkFrBack();
AstCellArrayRef* newp
@ -2628,14 +2607,13 @@ private:
return;
}
iterateAndNextNull(nodep->lhsp());
DotStates lastStates = m_ds;
VL_RESTORER(m_ds);
{
m_ds.init(m_curSymp);
iterateAndNextNull(nodep->rhsp());
iterateAndNextNull(nodep->thsp());
iterateAndNextNull(nodep->attrp());
}
m_ds = lastStates;
}
virtual void visit(AstMemberSel* nodep) override {
// checkNoDot not appropriate, can be under a dot
@ -2683,8 +2661,8 @@ private:
virtual void visit(AstClass* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VSymEnt* oldCurSymp = m_curSymp;
VSymEnt* oldModSymp = m_modSymp;
VL_RESTORER(m_curSymp);
VL_RESTORER(m_modSymp);
{
m_ds.init(m_curSymp);
// Until overridden by a SCOPE
@ -2743,8 +2721,6 @@ private:
}
}
}
m_curSymp = oldCurSymp;
m_modSymp = oldModSymp;
}
virtual void visit(AstRefDType* nodep) override {
// Resolve its reference

31
src/V3LinkJump.cpp
View File

@ -119,15 +119,13 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
AstNodeModule* origModp = m_modp;
int origRepeatNum = m_modRepeatNum;
VL_RESTORER(m_modp);
VL_RESTORER(m_modRepeatNum);
{
m_modp = nodep;
m_modRepeatNum = 0;
iterateChildren(nodep);
}
m_modp = origModp;
m_modRepeatNum = origRepeatNum;
}
virtual void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
@ -136,14 +134,13 @@ private:
}
virtual void visit(AstNodeBlock* nodep) override {
UINFO(8, " " << nodep << endl);
bool oldFork = m_inFork;
VL_RESTORER(m_inFork);
m_blockStack.push_back(nodep);
{
m_inFork = m_inFork || VN_IS(nodep, Fork);
iterateChildren(nodep);
}
m_blockStack.pop_back();
m_inFork = oldFork;
}
virtual void visit(AstRepeat* nodep) override {
// So later optimizations don't need to deal with them,
@ -186,17 +183,17 @@ private:
}
virtual void visit(AstWhile* nodep) override {
// Don't need to track AstRepeat/AstFor as they have already been converted
AstWhile* lastLoopp = m_loopp;
bool lastInc = m_loopInc;
m_loopp = nodep;
m_loopInc = false;
iterateAndNextNull(nodep->precondsp());
iterateAndNextNull(nodep->condp());
iterateAndNextNull(nodep->bodysp());
m_loopInc = true;
iterateAndNextNull(nodep->incsp());
m_loopInc = lastInc;
m_loopp = lastLoopp;
VL_RESTORER(m_loopp);
VL_RESTORER(m_loopInc);
{
m_loopp = nodep;
m_loopInc = false;
iterateAndNextNull(nodep->precondsp());
iterateAndNextNull(nodep->condp());
iterateAndNextNull(nodep->bodysp());
m_loopInc = true;
iterateAndNextNull(nodep->incsp());
}
}
virtual void visit(AstReturn* nodep) override {
iterateChildren(nodep);

63
src/V3LinkLValue.cpp
View File

@ -68,17 +68,16 @@ private:
}
}
virtual void visit(AstNodeAssign* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->lhsp());
m_setRefLvalue = false;
iterateAndNextNull(nodep->rhsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFOpen* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
@ -86,102 +85,90 @@ private:
iterateAndNextNull(nodep->filenamep());
iterateAndNextNull(nodep->modep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFOpenMcd* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
m_setRefLvalue = false;
iterateAndNextNull(nodep->filenamep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFClose* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFError* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
iterateAndNextNull(nodep->strp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFFlush* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFGetC* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFGetS* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
iterateAndNextNull(nodep->strgp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFRead* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->memp());
iterateAndNextNull(nodep->filep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFScanF* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
iterateAndNextNull(nodep->exprsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstFUngetC* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->filep());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSScanF* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->exprsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSysIgnore* nodep) override {
// Can't know if lvalue or not; presume so as stricter
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
iterateChildren(nodep);
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstReadMem* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->memp());
@ -190,30 +177,27 @@ private:
iterateAndNextNull(nodep->lsbp());
iterateAndNextNull(nodep->msbp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstValuePlusArgs* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = false;
iterateAndNextNull(nodep->searchp());
m_setRefLvalue = true;
iterateAndNextNull(nodep->outp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstSFormat* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = true;
iterateAndNextNull(nodep->lhsp());
m_setRefLvalue = false;
iterateAndNextNull(nodep->fmtp());
}
m_setRefLvalue = last_setRefLvalue;
}
void prepost_visit(AstNodeTriop* nodep) {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = false;
iterateAndNextNull(nodep->lhsp());
@ -221,7 +205,6 @@ private:
m_setRefLvalue = true;
iterateAndNextNull(nodep->thsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
@ -230,7 +213,7 @@ private:
// Nodes that change LValue state
virtual void visit(AstSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{
iterateAndNextNull(nodep->lhsp());
// Only set lvalues on the from
@ -238,34 +221,30 @@ private:
iterateAndNextNull(nodep->rhsp());
iterateAndNextNull(nodep->thsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodeSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{ // Only set lvalues on the from
iterateAndNextNull(nodep->lhsp());
m_setRefLvalue = false;
iterateAndNextNull(nodep->rhsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstCellArrayRef* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{ // selp is not an lvalue
m_setRefLvalue = false;
iterateAndNextNull(nodep->selp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodePreSel* nodep) override {
bool last_setRefLvalue = m_setRefLvalue;
VL_RESTORER(m_setRefLvalue);
{ // Only set lvalues on the from
iterateAndNextNull(nodep->lhsp());
m_setRefLvalue = false;
iterateAndNextNull(nodep->rhsp());
iterateAndNextNull(nodep->thsp());
}
m_setRefLvalue = last_setRefLvalue;
}
virtual void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;

3
src/V3LinkParse.cpp
View File

@ -481,7 +481,7 @@ private:
virtual void visit(AstNodeModule* nodep) override {
V3Config::applyModule(nodep);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
// Module: Create sim table for entire module and iterate
cleanFileline(nodep);
@ -490,7 +490,6 @@ private:
m_valueModp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
m_valueModp = nodep;
}
void visitIterateNoValueMod(AstNode* nodep) {

18
src/V3LinkResolve.cpp
View File

@ -65,9 +65,9 @@ private:
// Module: Create sim table for entire module and iterate
UINFO(8, "MODULE " << nodep << endl);
if (nodep->dead()) return;
AstNodeModule* origModp = m_modp;
VLifetime origLifetime = m_lifetime;
int origSenitemCvtNum = m_senitemCvtNum;
VL_RESTORER(m_modp);
VL_RESTORER(m_lifetime);
VL_RESTORER(m_senitemCvtNum);
{
m_modp = nodep;
m_senitemCvtNum = 0;
@ -75,21 +75,16 @@ private:
if (m_lifetime.isNone()) m_lifetime = VLifetime::STATIC;
iterateChildren(nodep);
}
m_modp = origModp;
m_senitemCvtNum = origSenitemCvtNum;
m_lifetime = origLifetime;
}
virtual void visit(AstClass* nodep) override {
AstClass* origClassp = m_classp;
VLifetime origLifetime = m_lifetime;
VL_RESTORER(m_classp);
VL_RESTORER(m_lifetime);
{
m_classp = nodep;
m_lifetime = nodep->lifetime();
if (m_lifetime.isNone()) m_lifetime = VLifetime::AUTOMATIC;
iterateChildren(nodep);
}
m_classp = origClassp;
m_lifetime = origLifetime;
}
virtual void visit(AstInitial* nodep) override {
iterateChildren(nodep);
@ -550,12 +545,11 @@ private:
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCell* nodep) override {
// Parent module inherits child's publicity

3
src/V3Name.cpp
View File

@ -68,12 +68,11 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
// Add __PVT__ to names of local signals
virtual void visit(AstVar* nodep) override {

3
src/V3Order.cpp
View File

@ -979,12 +979,11 @@ private:
AstNode::user4ClearTree();
}
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstClass*) override {}
virtual void visit(AstScope* nodep) override {

12
src/V3Premit.cpp
View File

@ -186,13 +186,12 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_funcp = nullptr;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstCFunc* nodep) override {
m_funcp = nodep;
@ -318,31 +317,28 @@ private:
virtual void visit(AstSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
VL_RESTORER(m_assignLhs);
m_assignLhs = false;
iterateAndNextNull(nodep->lsbp());
iterateAndNextNull(nodep->widthp());
m_assignLhs = prevAssign;
}
checkNode(nodep);
}
virtual void visit(AstArraySel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
VL_RESTORER(m_assignLhs);
m_assignLhs = false;
iterateAndNextNull(nodep->bitp());
m_assignLhs = prevAssign;
}
checkNode(nodep);
}
virtual void visit(AstAssocSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
bool prevAssign = m_assignLhs;
VL_RESTORER(m_assignLhs);
m_assignLhs = false;
iterateAndNextNull(nodep->bitp());
m_assignLhs = prevAssign;
}
checkNode(nodep);
}

20
src/V3Scope.cpp
View File

@ -117,9 +117,9 @@ private:
// Now for each child cell, iterate the module this cell points to
for (AstNode* cellnextp = nodep->stmtsp(); cellnextp; cellnextp = cellnextp->nextp()) {
if (AstCell* cellp = VN_CAST(cellnextp, Cell)) {
AstScope* oldScopep = m_scopep;
AstCell* oldAbCellp = m_aboveCellp;
AstScope* oldAbScopep = m_aboveScopep;
VL_RESTORER(m_scopep);
VL_RESTORER(m_aboveCellp);
VL_RESTORER(m_aboveScopep);
{
m_aboveCellp = cellp;
m_aboveScopep = m_scopep;
@ -127,10 +127,6 @@ private:
UASSERT_OBJ(modp, cellp, "Unlinked mod");
iterate(modp); // Recursive call to visit(AstNodeModule)
}
// Done, restore vars
m_scopep = oldScopep;
m_aboveCellp = oldAbCellp;
m_aboveScopep = oldAbScopep;
}
}
@ -153,9 +149,9 @@ private:
}
virtual void visit(AstClass* nodep) override {
// Create required blocks and add to module
AstScope* oldScopep = m_scopep;
AstCell* oldAbCellp = m_aboveCellp;
AstScope* oldAbScopep = m_aboveScopep;
VL_RESTORER(m_scopep);
VL_RESTORER(m_aboveCellp);
VL_RESTORER(m_aboveScopep);
{
m_aboveScopep = m_scopep;
@ -179,10 +175,6 @@ private:
iterateChildren(nodep);
}
// Done, restore vars
m_scopep = oldScopep;
m_aboveCellp = oldAbCellp;
m_aboveScopep = oldAbScopep;
}
virtual void visit(AstCellInline* nodep) override { //
nodep->scopep(m_scopep);

9
src/V3SplitVar.cpp
View File

@ -410,20 +410,18 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
}
void setContextAndIterateChildren(AstNode* nodep) {
AstNode* origContextp = m_contextp;
VL_RESTORER(m_contextp);
{
m_contextp = nodep;
iterateChildren(nodep);
}
m_contextp = origContextp;
}
void setContextAndIterate(AstNode* contextp, AstNode* nodep) {
AstNode* origContextp = m_contextp;
VL_RESTORER(m_contextp);
{
m_contextp = contextp;
iterate(nodep);
}
m_contextp = origContextp;
}
void pushDeletep(AstNode* nodep) { // overriding AstNVisitor::pusDeletep()
UASSERT_OBJ(m_modp, nodep, "Must not nullptr");
@ -472,7 +470,7 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
if (AstNode* bodysp = nodep->bodysp()) iterate(bodysp);
}
virtual void visit(AstNodeFTaskRef* nodep) override {
AstNode* origContextp = m_contextp;
VL_RESTORER(m_contextp);
{
m_contextp = nodep;
AstNodeFTask* ftaskp = nodep->taskp();
@ -508,7 +506,6 @@ class SplitUnpackedVarVisitor : public AstNVisitor, public SplitVarImpl {
m_foundTargetVar.clear();
}
}
m_contextp = origContextp;
}
virtual void visit(AstPin* nodep) override {
UINFO(5, nodep->modVarp()->prettyNameQ() << " pin \n");

12
src/V3Stats.cpp
View File

@ -135,28 +135,24 @@ private:
double ifInstrs = 0.0;
double elseInstrs = 0.0;
if (nodep->branchPred() != VBranchPred::BP_UNLIKELY) { // Check if
double prevInstr = m_instrs;
bool prevCounting = m_counting;
VL_RESTORER(m_instrs);
VL_RESTORER(m_counting);
{
m_counting = false;
m_instrs = 0.0;
iterateAndNextConstNull(nodep->ifsp());
ifInstrs = m_instrs;
}
m_instrs = prevInstr;
m_counting = prevCounting;
}
if (nodep->branchPred() != VBranchPred::BP_LIKELY) { // Check else
double prevInstr = m_instrs;
bool prevCounting = m_counting;
VL_RESTORER(m_instrs);
VL_RESTORER(m_counting);
{
m_counting = false;
m_instrs = 0.0;
iterateAndNextConstNull(nodep->elsesp());
elseInstrs = m_instrs;
}
m_instrs = prevInstr;
m_counting = prevCounting;
}
// Now collect the stats
if (m_counting) {

9
src/V3Table.cpp
View File

@ -404,18 +404,15 @@ private:
// VISITORS
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
int origModTables = m_modTables;
ModTableVector origModTableVscs = m_modTableVscs;
VL_RESTORER(m_modp);
VL_RESTORER(m_modTables);
VL_RESTORER(m_modTableVscs);
{
m_modp = nodep;
m_modTables = 0;
m_modTableVscs.clear();
iterateChildren(nodep);
}
m_modp = origModp;
m_modTables = origModTables;
m_modTableVscs = origModTableVscs;
}
virtual void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);

27
src/V3Task.cpp
View File

@ -1154,14 +1154,13 @@ private:
void iterateIntoFTask(AstNodeFTask* nodep) {
// Iterate into the FTask we are calling. Note it may be under a different
// scope then the caller, so we need to restore state.
AstScope* oldscopep = m_scopep;
InsertMode prevInsMode = m_insMode;
AstNode* prevInsStmtp = m_insStmtp;
m_scopep = m_statep->getScope(nodep);
iterate(nodep);
m_scopep = oldscopep;
m_insMode = prevInsMode;
m_insStmtp = prevInsStmtp;
VL_RESTORER(m_scopep);
VL_RESTORER(m_insMode);
VL_RESTORER(m_insStmtp);
{
m_scopep = m_statep->getScope(nodep);
iterate(nodep);
}
}
AstNode* insertBeforeStmt(AstNode* nodep, AstNode* newp) {
// Return node that must be visited, if any
@ -1193,16 +1192,14 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
AstNodeModule* origModp = m_modp;
int origNCalls = m_modNCalls;
VL_RESTORER(m_modp);
VL_RESTORER(m_modNCalls);
{
m_modp = nodep;
m_insStmtp = nullptr;
m_modNCalls = 0;
iterateChildren(nodep);
}
m_modp = origModp;
m_modNCalls = origNCalls;
}
virtual void visit(AstTopScope* nodep) override {
m_topScopep = nodep;
@ -1270,8 +1267,8 @@ private:
}
virtual void visit(AstNodeFTask* nodep) override {
UINFO(4, " Inline " << nodep << endl);
InsertMode prevInsMode = m_insMode;
AstNode* prevInsStmtp = m_insStmtp;
VL_RESTORER(m_insMode);
VL_RESTORER(m_insStmtp);
m_insMode = IM_BEFORE;
m_insStmtp = nodep->stmtsp(); // Might be null if no statements, but we won't use it
if (!nodep->user1SetOnce()) { // Just one creation needed per function
@ -1335,8 +1332,6 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
m_insMode = prevInsMode;
m_insStmtp = prevInsStmtp;
}
virtual void visit(AstWhile* nodep) override {
// Special, as statements need to be put in different places

18
src/V3TraceDecl.cpp
View File

@ -239,8 +239,8 @@ private:
// Unroll now, as have no other method to get right signal names
AstNodeDType* const subtypep = nodep->subDTypep()->skipRefToEnump();
for (int i = nodep->lsb(); i <= nodep->msb(); ++i) {
const string oldShowname = m_traShowname;
AstNode* const oldValuep = m_traValuep;
VL_RESTORER(m_traShowname);
VL_RESTORER(m_traValuep);
{
m_traShowname += string("(") + cvtToStr(i) + string(")");
m_traValuep = new AstArraySel(
@ -250,8 +250,6 @@ private:
iterate(subtypep);
VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = nullptr);
}
m_traShowname = oldShowname;
m_traValuep = oldValuep;
}
}
}
@ -266,8 +264,8 @@ private:
} else {
AstNodeDType* const subtypep = nodep->subDTypep()->skipRefToEnump();
for (int i = nodep->lsb(); i <= nodep->msb(); ++i) {
const string oldShowname = m_traShowname;
AstNode* const oldValuep = m_traValuep;
VL_RESTORER(m_traShowname);
VL_RESTORER(m_traValuep);
{
m_traShowname += string("(") + cvtToStr(i) + string(")");
m_traValuep = new AstSel(nodep->fileline(), m_traValuep->cloneTree(true),
@ -277,8 +275,6 @@ private:
iterate(subtypep);
VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = nullptr);
}
m_traShowname = oldShowname;
m_traValuep = oldValuep;
}
}
}
@ -296,8 +292,8 @@ private:
for (const AstMemberDType* itemp = nodep->membersp(); itemp;
itemp = VN_CAST_CONST(itemp->nextp(), MemberDType)) {
AstNodeDType* const subtypep = itemp->subDTypep()->skipRefToEnump();
const string oldShowname = m_traShowname;
AstNode* const oldValuep = m_traValuep;
VL_RESTORER(m_traShowname);
VL_RESTORER(m_traValuep);
{
m_traShowname += string(" ") + itemp->prettyName();
if (VN_IS(nodep, StructDType)) {
@ -311,8 +307,6 @@ private:
iterate(subtypep);
}
}
m_traShowname = oldShowname;
m_traValuep = oldValuep;
}
}
}

12
src/V3Tristate.cpp
View File

@ -1281,10 +1281,10 @@ class TristateVisitor : public TristateBaseVisitor {
virtual void visit(AstNodeModule* nodep) override {
UINFO(8, nodep << endl);
AstNodeModule* origModp = m_modp;
bool origGraphing = m_graphing;
int origUnique = m_unique;
VarMap origLhsmap = m_lhsmap;
VL_RESTORER(m_modp);
VL_RESTORER(m_graphing);
VL_RESTORER(m_unique);
VL_RESTORER(m_lhsmap);
// Not preserved, needs pointer instead: TristateGraph origTgraph = m_tgraph;
UASSERT_OBJ(m_tgraph.empty(), nodep, "Unsupported: NodeModule under NodeModule");
{
@ -1308,10 +1308,6 @@ class TristateVisitor : public TristateBaseVisitor {
// Insert new logic for all tristates
insertTristates(nodep);
}
m_modp = origModp;
m_graphing = origGraphing;
m_unique = origUnique;
m_lhsmap = origLhsmap;
m_tgraph.clear(); // Recursion not supported
}

30
src/V3Undriven.cpp
View File

@ -370,38 +370,36 @@ private:
// Don't know what black boxed calls do, assume in+out
virtual void visit(AstSysIgnore* nodep) override {
bool prevMark = m_inBBox;
m_inBBox = true;
iterateChildren(nodep);
m_inBBox = prevMark;
VL_RESTORER(m_inBBox);
{
m_inBBox = true;
iterateChildren(nodep);
}
}
virtual void visit(AstAssign* nodep) override {
bool prevProc = m_inProcAssign;
VL_RESTORER(m_inProcAssign);
{
m_inProcAssign = true;
iterateChildren(nodep);
}
m_inProcAssign = prevProc;
}
virtual void visit(AstAssignDly* nodep) override {
bool prevProc = m_inProcAssign;
VL_RESTORER(m_inProcAssign);
{
m_inProcAssign = true;
iterateChildren(nodep);
}
m_inProcAssign = prevProc;
}
virtual void visit(AstAssignW* nodep) override {
bool prevCont = m_inContAssign;
VL_RESTORER(m_inContAssign);
{
m_inContAssign = true;
iterateChildren(nodep);
}
m_inContAssign = prevCont;
}
virtual void visit(AstAlways* nodep) override {
AstAlways* prevAlwp = m_alwaysCombp;
VL_RESTORER(m_alwaysCombp);
{
AstNode::user2ClearTree();
if (nodep->keyword() == VAlwaysKwd::ALWAYS_COMB) UINFO(9, " " << nodep << endl);
@ -413,14 +411,14 @@ private:
iterateChildren(nodep);
if (nodep->keyword() == VAlwaysKwd::ALWAYS_COMB) UINFO(9, " Done " << nodep << endl);
}
m_alwaysCombp = prevAlwp;
}
virtual void visit(AstNodeFTask* nodep) override {
AstNodeFTask* prevTaskp = m_taskp;
m_taskp = nodep;
iterateChildren(nodep);
m_taskp = prevTaskp;
VL_RESTORER(m_taskp);
{
m_taskp = nodep;
iterateChildren(nodep);
}
}
// Until we support tables, primitives will have undriven and unused I/Os

3
src/V3Unknown.cpp
View File

@ -136,13 +136,12 @@ private:
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNodeModule* origModp = m_modp;
VL_RESTORER(m_modp);
{
m_modp = nodep;
m_constXCvt = true;
iterateChildren(nodep);
}
m_modp = origModp;
}
virtual void visit(AstAssignDly* nodep) override {
m_assigndlyp = nodep;

3
src/V3Width.cpp
View File

@ -1259,7 +1259,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstAttrOf* nodep) override {
AstAttrOf* oldAttr = m_attrp;
VL_RESTORER(m_attrp);
m_attrp = nodep;
userIterateAndNext(nodep->fromp(), WidthVP(SELF, BOTH).p());
if (nodep->dimp()) userIterateAndNext(nodep->dimp(), WidthVP(SELF, BOTH).p());
@ -1381,7 +1381,6 @@ private:
break;
}
}
m_attrp = oldAttr;
}
virtual void visit(AstPull* nodep) override {
// May have select underneath, let seek natural size