From bed3101dfcf87b7ff2ac1f07b4ff1c89f5024826 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Mon, 24 Aug 2020 21:10:43 -0400 Subject: [PATCH] Internals: Use VL_RESTORER class to save/restore vars. No functional change intended. --- src/V3Assert.cpp | 9 ++-- src/V3Begin.cpp | 12 ++--- src/V3Branch.cpp | 6 +-- src/V3CUse.cpp | 3 +- src/V3Cdc.cpp | 3 +- src/V3Changed.cpp | 29 ++++++----- src/V3Class.cpp | 6 +-- src/V3Clean.cpp | 3 +- src/V3Clock.cpp | 3 +- src/V3Combine.cpp | 3 +- src/V3Const.cpp | 12 ++--- src/V3Coverage.cpp | 21 +++----- src/V3Dead.cpp | 3 +- src/V3Delayed.cpp | 22 ++++---- src/V3Depth.cpp | 3 +- src/V3DepthBlock.cpp | 9 ++-- src/V3Descope.cpp | 3 +- src/V3EmitCSyms.cpp | 3 +- src/V3Gate.cpp | 31 ++++++------ src/V3Global.h | 22 +++++++- src/V3Hashed.cpp | 5 +- src/V3HierBlock.cpp | 3 +- src/V3Inline.cpp | 7 +-- src/V3LinkCells.cpp | 6 +-- src/V3LinkDot.cpp | 114 +++++++++++++++++------------------------- src/V3LinkJump.cpp | 31 ++++++------ src/V3LinkLValue.cpp | 63 ++++++++--------------- src/V3LinkParse.cpp | 3 +- src/V3LinkResolve.cpp | 18 +++---- src/V3Name.cpp | 3 +- src/V3Order.cpp | 3 +- src/V3Premit.cpp | 12 ++--- src/V3Scope.cpp | 20 +++----- src/V3SplitVar.cpp | 9 ++-- src/V3Stats.cpp | 12 ++--- src/V3Table.cpp | 9 ++-- src/V3Task.cpp | 27 ++++------ src/V3TraceDecl.cpp | 18 +++---- src/V3Tristate.cpp | 12 ++--- src/V3Undriven.cpp | 30 ++++++----- src/V3Unknown.cpp | 3 +- src/V3Width.cpp | 3 +- 42 files changed, 253 insertions(+), 364 deletions(-) diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp index 7b1ba595a..b4205e0a1 100644 --- a/src/V3Assert.cpp +++ b/src/V3Assert.cpp @@ -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); } diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp index 288105ffe..f5a7668ec 100644 --- a/src/V3Begin.cpp +++ b/src/V3Begin.cpp @@ -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); } diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp index d2c75242c..2aa42a9b3 100644 --- a/src/V3Branch.cpp +++ b/src/V3Branch.cpp @@ -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); diff --git a/src/V3CUse.cpp b/src/V3CUse.cpp index a9b601b89..087418028 100644 --- a/src/V3CUse.cpp +++ b/src/V3CUse.cpp @@ -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 diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp index 3e638c591..24f9703aa 100644 --- a/src/V3Cdc.cpp +++ b/src/V3Cdc.cpp @@ -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); diff --git a/src/V3Changed.cpp b/src/V3Changed.cpp index df7e5d264..471d0d03c 100644 --- a/src/V3Changed.cpp +++ b/src/V3Changed.cpp @@ -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 { diff --git a/src/V3Class.cpp b/src/V3Class.cpp index a9d2fc39c..df895f107 100644 --- a/src/V3Class.cpp +++ b/src/V3Class.cpp @@ -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 { diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp index 6dd683487..c67f18c1c 100644 --- a/src/V3Clean.cpp +++ b/src/V3Clean.cpp @@ -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); diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp index f652de107..378bf4245 100644 --- a/src/V3Clock.cpp +++ b/src/V3Clock.cpp @@ -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); diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp index 6b05cabec..c938da506 100644 --- a/src/V3Combine.cpp +++ b/src/V3Combine.cpp @@ -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() { diff --git a/src/V3Const.cpp b/src/V3Const.cpp index 5a31fe395..ef617c634 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -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 { diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp index d795bb2bc..f371d4fa8 100644 --- a/src/V3Coverage.cpp +++ b/src/V3Coverage.cpp @@ -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 diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp index b13aaae6e..9f709f5ab 100644 --- a/src/V3Dead.cpp +++ b/src/V3Dead.cpp @@ -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); diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp index fb428352c..4ba1acb24 100644 --- a/src/V3Delayed.cpp +++ b/src/V3Delayed.cpp @@ -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); + } } //-------------------- diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp index 8ddb9ebb2..d76a5cc11 100644 --- a/src/V3Depth.cpp +++ b/src/V3Depth.cpp @@ -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; diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp index 6092060c6..54db059ec 100644 --- a/src/V3DepthBlock.cpp +++ b/src/V3DepthBlock.cpp @@ -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++; diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp index 44788487d..007c8236e 100644 --- a/src/V3Descope.cpp +++ b/src/V3Descope.cpp @@ -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; diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index a9fae0745..9193c8a9c 100644 --- a/src/V3EmitCSyms.cpp +++ b/src/V3EmitCSyms.cpp @@ -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()) { diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp index a7472ac38..085586bf5 100644 --- a/src/V3Gate.cpp +++ b/src/V3Gate.cpp @@ -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) diff --git a/src/V3Global.h b/src/V3Global.h index 2321fb21b..3c607052e 100644 --- a/src/V3Global.h +++ b/src/V3Global.h @@ -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 restorer_##var(var); + +// Object used by VL_RESTORER. This object must be an auto variable, not +// allocated on the heap or otherwise. +template 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); +}; //###################################################################### diff --git a/src/V3Hashed.cpp b/src/V3Hashed.cpp index 077a4524b..9196a808d 100644 --- a/src/V3Hashed.cpp +++ b/src/V3Hashed.cpp @@ -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 "<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 { diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp index bd11f7b9d..9a0c9af82 100644 --- a/src/V3Inline.cpp +++ b/src/V3Inline.cpp @@ -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 diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp index 0ded538bc..b97e1261b 100644 --- a/src/V3LinkCells.cpp +++ b/src/V3LinkCells.cpp @@ -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()); } diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index f6916a082..1ec6fc337 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -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 diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index b37647628..076ce57a4 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -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); diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp index bb6de0176..7db59b71c 100644 --- a/src/V3LinkLValue.cpp +++ b/src/V3LinkLValue.cpp @@ -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; diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index 271b6626b..8ef50018a 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -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) { diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp index b580a213d..d81e1a6b4 100644 --- a/src/V3LinkResolve.cpp +++ b/src/V3LinkResolve.cpp @@ -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 diff --git a/src/V3Name.cpp b/src/V3Name.cpp index ab49d1b9d..0d5401bf5 100644 --- a/src/V3Name.cpp +++ b/src/V3Name.cpp @@ -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 { diff --git a/src/V3Order.cpp b/src/V3Order.cpp index 3371c0aa2..b641e48e5 100644 --- a/src/V3Order.cpp +++ b/src/V3Order.cpp @@ -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 { diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp index 69f8d7ba5..154e517ee 100644 --- a/src/V3Premit.cpp +++ b/src/V3Premit.cpp @@ -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); } diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp index 6b2f8518a..7e54b0a30 100644 --- a/src/V3Scope.cpp +++ b/src/V3Scope.cpp @@ -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); diff --git a/src/V3SplitVar.cpp b/src/V3SplitVar.cpp index 8c8ef8a5a..b7f308d47 100644 --- a/src/V3SplitVar.cpp +++ b/src/V3SplitVar.cpp @@ -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"); diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp index 962e3e15e..e2a954267 100644 --- a/src/V3Stats.cpp +++ b/src/V3Stats.cpp @@ -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) { diff --git a/src/V3Table.cpp b/src/V3Table.cpp index 988a6058d..dc350a4d5 100644 --- a/src/V3Table.cpp +++ b/src/V3Table.cpp @@ -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); diff --git a/src/V3Task.cpp b/src/V3Task.cpp index 453abce14..f21ba9488 100644 --- a/src/V3Task.cpp +++ b/src/V3Task.cpp @@ -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 diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index 9ee77694e..4157347a5 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -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; } } } diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp index a38bddc85..7dda34b28 100644 --- a/src/V3Tristate.cpp +++ b/src/V3Tristate.cpp @@ -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 } diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp index 9a097916f..01890983f 100644 --- a/src/V3Undriven.cpp +++ b/src/V3Undriven.cpp @@ -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 diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp index c1c7d6c22..15e9a199b 100644 --- a/src/V3Unknown.cpp +++ b/src/V3Unknown.cpp @@ -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; diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 56b431e6e..436ebc44f 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -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