diff --git a/bin/verilator b/bin/verilator index a0cff1190..0e2a882a9 100755 --- a/bin/verilator +++ b/bin/verilator @@ -309,10 +309,13 @@ detailed descriptions of these arguments. +define+= Set preprocessor define --dpi-hdr-only Only produce the DPI header file --dump-defines Show preprocessor defines with -E - --dump-tree Enable dumping .tree files + --dump-graph Enable dumping V3Graphs to .dot + --dump-tree Enable dumping Ast .tree files --dump-tree-addrids Use short identifiers instead of addresses - --dump-treei Enable dumping .tree files at a level - --dump-treei- Enable dumping .tree file at a source file at a level + --dump- Enable dumping everything in source file + --dumpi-graph Enable dumping V3Graphs to .dot files at level + --dumpi-tree Enable dumping Ast .tree files at level + --dumpi- Enable dumping everything in source file at level -E Preprocess, but do not compile --error-limit Abort after this number of errors --exe Link to create executable diff --git a/docs/guide/exe_verilator.rst b/docs/guide/exe_verilator.rst index 31ba43c54..14878f869 100644 --- a/docs/guide/exe_verilator.rst +++ b/docs/guide/exe_verilator.rst @@ -263,8 +263,8 @@ Summary: generally is a less-optimized binary with symbols present (so GDB can be used on it). * Enable debugging messages (equivalent to :vlopt:`--debugi 3 <--debugi>`). * Enable internal assertions (equivalent to :vlopt:`--debug-check`). - * Enable intermediate form dump files (equivalent to :vlopt:`--dump-treei 3 - <--dump-treei>`). + * Enable intermediate form dump files (equivalent to :vlopt:`--dumpi-tree 3 + <--dumpi-tree>`). * Leak to make node numbers unique (equivalent to :vlopt:`--debug-leak <--no-debug-leak>`. * Call abort() instead of exit() if there are any errors (so GDB can see @@ -355,26 +355,21 @@ Summary: touch foo.v ; verilator -E --dump-defines foo.v +.. option:: --dump-graph + + Rarely needed. Enable dumping V3Graph .dot debug files with dumping + level 3. Before Verilator 4.228, :vlopt:`--dump-tree` used + to include this option. + .. option:: --dump-tree - Rarely needed. Enable writing .tree debug files with dumping level 3, + Rarely needed. Enable dumping Ast .tree debug files with dumping level 3, which dumps the standard critical stages. For details on the format see the Verilator Internals manual. :vlopt:`--dump-tree` is enabled automatically with :vlopt:`--debug`, so :vlopt:`--debug --no-dump-tree <--dump-tree>` may be useful if the dump files are large and not desired. -.. option:: --dump-treei - -.. option:: --dump-treei- - - Rarely needed - for developer use. Set internal tree dumping level - globally to a specific dumping level or set the specified Verilator - source file to the specified tree dumping level (e.g. - :vlopt:`--dump-treei-V3Order 9 <--dump-treei>`). Level 0 disables dumps - and is equivalent to :vlopt:`--no-dump-tree <--dump-tree>`. Level 9 - enables dumping of every stage. - .. option:: --dump-tree-addrids Rarely needed - for developer use. Replace AST node addresses with @@ -384,6 +379,28 @@ Summary: by a newly allocated node after a node with the same address has been dumped then freed. +.. option:: --dump- + + Rarely needed - for developer use. Enable all dumping in the given + source file at level 3. + +.. option:: --dumpi-graph + + Rarely needed - for developer use. Set internal V3Graph dumping level + globally to the specified value. + +.. option:: --dumpi-tree + + Rarely needed - for developer use. Set internal Ast dumping level + globally to the specified value. + +.. option:: --dumpi- + + Rarely needed - for developer use. Set the dumping level in the + specified Verilator source file to the specified value (e.g. + :vlopt:`--dumpi-V3Order 9`). Level 0 disables dumps and is equivalent + to :vlopt:`--no-dump-`. Level 9 enables dumping of everything. + .. option:: -E Preprocess the source code, but do not compile, similar to C++ diff --git a/src/V3Active.cpp b/src/V3Active.cpp index 7bf61c9cd..f753bfcd7 100644 --- a/src/V3Active.cpp +++ b/src/V3Active.cpp @@ -38,6 +38,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //***** See below for main transformation engine //###################################################################### @@ -79,8 +81,6 @@ protected: LatchDetectGraphVertex* m_curVertexp = nullptr; // Current latch detection graph vertex std::vector m_outputs; // Vector of lvalues encountered on this pass - VL_DEBUG_FUNC; // Declare debug() - static LatchDetectGraphVertex* castVertexp(void* vertexp) { return reinterpret_cast(vertexp); } @@ -183,7 +183,7 @@ public: << " (not all control paths of combinational always assign a value)\n" << nodep->warnMore() << "... Suggest use of always_latch for intentional latches"); - if (debug() >= 9) dumpDotFilePrefixed("latch_" + vrp->name()); + if (dumpGraph() >= 9) dumpDotFilePrefixed("latch_" + vrp->name()); } vertp->user(false); // Clear again (see above) vrp->varp()->isLatched(latch_detected); @@ -198,12 +198,7 @@ public: //###################################################################### // Collect existing active names -class ActiveBaseVisitor VL_NOT_FINAL : public VNVisitor { -protected: - VL_DEBUG_FUNC; // Declare debug() -}; - -class ActiveNamer final : public ActiveBaseVisitor { +class ActiveNamer final : public VNVisitor { private: // STATE AstScope* m_scopep = nullptr; // Current scope to add statement to @@ -304,7 +299,7 @@ AstActive*& ActiveNamer::getSpecialActive() { //###################################################################### // Latch checking visitor -class ActiveLatchCheckVisitor final : public ActiveBaseVisitor { +class ActiveLatchCheckVisitor final : public VNVisitor { private: // NODE STATE // Input: @@ -346,7 +341,7 @@ public: //###################################################################### // Replace unsupported non-blocking assignments with blocking assignments -class ActiveDlyVisitor final : public ActiveBaseVisitor { +class ActiveDlyVisitor final : public VNVisitor { public: enum CheckType : uint8_t { CT_SEQ, CT_COMB, CT_INITIAL }; @@ -418,7 +413,7 @@ public: //###################################################################### // Active class functions -class ActiveVisitor final : public ActiveBaseVisitor { +class ActiveVisitor final : public VNVisitor { private: // NODE STATE // Each call to V3Const::constify @@ -631,5 +626,5 @@ public: void V3Active::activeAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ActiveVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("active", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("active", 0, dumpTree() >= 3); } diff --git a/src/V3ActiveTop.cpp b/src/V3ActiveTop.cpp index 39b9b54df..266451a41 100644 --- a/src/V3ActiveTop.cpp +++ b/src/V3ActiveTop.cpp @@ -33,6 +33,8 @@ #include "V3Global.h" #include "V3SenTree.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Active class functions @@ -41,7 +43,6 @@ class ActiveTopVisitor final : public VNVisitor { SenTreeFinder m_finder; // Find global sentree's / add them under the AstTopScope // METHODS - VL_DEBUG_FUNC; // Declare debug() static bool isInitial(AstNode* nodep) { const VNUser1InUse user1InUse; @@ -144,5 +145,5 @@ public: void V3ActiveTop::activeTopAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ActiveTopVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("activetop", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("activetop", 0, dumpTree() >= 3); } diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp index e94440da1..97ced7b6b 100644 --- a/src/V3Assert.cpp +++ b/src/V3Assert.cpp @@ -23,6 +23,8 @@ #include "V3Global.h" #include "V3Stats.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Assert class functions @@ -513,5 +515,5 @@ public: void V3Assert::assertAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { AssertVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("assert", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("assert", 0, dumpTree() >= 3); } diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp index cdbcec1a4..bb0ae8b27 100644 --- a/src/V3AssertPre.cpp +++ b/src/V3AssertPre.cpp @@ -25,6 +25,8 @@ #include "V3Ast.h" #include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Assert class functions @@ -45,7 +47,6 @@ private: AstNode* m_disablep = nullptr; // Last disable // METHODS - VL_DEBUG_FUNC; // Declare debug() AstSenTree* newSenTree(AstNode* nodep) { // Create sentree based on clocked or default clock @@ -206,5 +207,5 @@ public: void V3AssertPre::assertPreAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { AssertPreVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("assertpre", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("assertpre", 0, dumpTree() >= 3); } diff --git a/src/V3Ast.cpp b/src/V3Ast.cpp index 9b406f816..8f7b102ef 100644 --- a/src/V3Ast.cpp +++ b/src/V3Ast.cpp @@ -28,6 +28,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //====================================================================== // Statics @@ -999,43 +1001,12 @@ bool AstNode::sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ig //====================================================================== // Debugging -void AstNode::checkTreeIter(AstNode* backp) { +void AstNode::checkTreeIter(const AstNode* backp) const { // private: Check a tree and children UASSERT_OBJ(backp == this->backp(), this, "Back node inconsistent"); - if (VN_IS(this, NodeTermop) || VN_IS(this, NodeVarRef)) { - // Termops have a short-circuited iterateChildren, so check usage - UASSERT_OBJ(!(op1p() || op2p() || op3p() || op4p()), this, - "Terminal operation with non-terminals"); - } - if (m_op1p) m_op1p->checkTreeIterList(this); - if (m_op2p) m_op2p->checkTreeIterList(this); - if (m_op3p) m_op3p->checkTreeIterList(this); - if (m_op4p) m_op4p->checkTreeIterList(this); -} - -void AstNode::checkTreeIterList(AstNode* backp) { - // private: Check a (possible) list of nodes, this is always the head of the list - // Audited to make sure this is never nullptr - AstNode* const headp = this; - const AstNode* tailp = this; - for (AstNode* nodep = headp; nodep; nodep = nodep->nextp()) { - nodep->checkTreeIter(backp); - UASSERT_OBJ(headp == this || !nextp(), this, - "Headtailp should be null in middle of lists"); - tailp = nodep; - backp = nodep; - } - UASSERT_OBJ(headp->m_headtailp == tailp, headp, "Tail in headtailp is inconsistent"); - UASSERT_OBJ(tailp->m_headtailp == headp, tailp, "Head in headtailp is inconsistent"); -} - -void AstNode::checkTree() { - if (!debug()) return; - if (this->backp()) { - // Linked tree- check only the passed node - this->checkTreeIter(this->backp()); - } else { - this->checkTreeIterList(this->backp()); + switch (this->type()) { +#include "V3Ast__gen_op_checks.h" + default: VL_UNREACHABLE; // LCOV_EXCL_LINE } } @@ -1151,7 +1122,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump, boo if (logsp->fail()) v3fatal("Can't write " << filename); *logsp << "Verilator Tree Dump (format 0x3900) from to \n"; - if (editCountGbl() == editCountLast() && !(v3Global.opt.dumpTree() >= 9)) { + if (editCountGbl() == editCountLast() && ::dumpTree() < 9) { *logsp << '\n'; *logsp << "No changes since last dump!\n"; } else { @@ -1161,7 +1132,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump, boo } } if (doDump && v3Global.opt.debugEmitV()) V3EmitV::debugEmitV(filename + ".v"); - if (doCheck && (v3Global.opt.debugCheck() || v3Global.opt.dumpTree())) { + if (doCheck && (v3Global.opt.debugCheck() || ::dumpTree())) { // Error check checkTree(); // Broken isn't part of check tree because it can munge iterp's diff --git a/src/V3Ast.h b/src/V3Ast.h index 0aeebbe83..d09093f7a 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -1524,8 +1524,7 @@ class AstNode VL_NOT_FINAL { private: AstNode* cloneTreeIter(); AstNode* cloneTreeIterList(); - void checkTreeIter(AstNode* backp); - void checkTreeIterList(AstNode* backp); + void checkTreeIter(const AstNode* backp) const; bool gateTreeIter() const; static bool sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext, bool gateOnly); @@ -1880,7 +1879,9 @@ public: // Does tree of this == node2p?, not allowing non-isGateOptimizable inline bool sameGateTree(const AstNode* node2p) const; void deleteTree(); // Always deletes the next link - void checkTree(); // User Interface version + void checkTree() const { + if (v3Global.opt.debugCheck()) checkTreeIter(backp()); + } void checkIter() const; void dumpPtrs(std::ostream& os = std::cout) const; void dumpTree(std::ostream& os = std::cout, const string& indent = " ", diff --git a/src/V3AstNodeDType.h b/src/V3AstNodeDType.h index e0bcf00cf..1c9e6c506 100644 --- a/src/V3AstNodeDType.h +++ b/src/V3AstNodeDType.h @@ -281,7 +281,7 @@ public: class AstAssocArrayDType final : public AstNodeDType { // Associative array data type, ie "[some_dtype]" // @astgen op1 := childDTypep : Optional[AstNodeDType] // moved to refDTypep() in V3Width - // @astgen op2 := keyChildDTypep : AstNodeDType // the key, which remains here as a pointer + // @astgen op2 := keyChildDTypep : Optional[AstNodeDType] private: AstNodeDType* m_refDTypep; // Elements of this type (after widthing) AstNodeDType* m_keyDTypep; // Keys of this type (after widthing) @@ -1000,7 +1000,7 @@ public: bool isCompound() const override { return true; } }; class AstRefDType final : public AstNodeDType { - // @astgen op1 := typeofp : AstNode + // @astgen op1 := typeofp : Optional[AstNode] // @astgen op2 := classOrPackageOpp : Optional[AstNode] // @astgen op3 := paramsp : List[AstPin] private: diff --git a/src/V3AstNodeMath.h b/src/V3AstNodeMath.h index 2d5a6f57f..977a49b96 100644 --- a/src/V3AstNodeMath.h +++ b/src/V3AstNodeMath.h @@ -187,7 +187,6 @@ protected: public: ASTGEN_MEMBERS_NodeTermop; // Know no children, and hot function, so skip iterator for speed - // See checkTreeIter also that asserts no children // cppcheck-suppress functionConst void iterateChildren(VNVisitor& v) {} void dump(std::ostream& str) const override; @@ -339,7 +338,6 @@ public: AstNodeModule* classOrPackagep() const { return m_classOrPackagep; } void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; } // Know no children, and hot function, so skip iterator for speed - // See checkTreeIter also that asserts no children // cppcheck-suppress functionConst void iterateChildren(VNVisitor& v) {} }; @@ -825,7 +823,7 @@ class AstImplication final : public AstNodeMath { // Verilog |-> |=> // @astgen op1 := lhsp : AstNode // @astgen op2 := rhsp : AstNode - // @astgen op3 := sentreep : AstSenTree + // @astgen op3 := sentreep : Optional[AstSenTree] public: AstImplication(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_Implication(fl) { diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h index d628c384a..dcf3afbb3 100644 --- a/src/V3AstNodeOther.h +++ b/src/V3AstNodeOther.h @@ -433,7 +433,7 @@ public: }; class AstNodeFTaskRef VL_NOT_FINAL : public AstNodeStmt { // A reference to a task (or function) - // @astgen op1 := namep : AstNode + // @astgen op1 := namep : Optional[AstNode] // op2 used by some sub-types only // @astgen op3 := pinsp : List[AstNode] // @astgen op4 := scopeNamep : Optional[AstScopeName] @@ -1737,7 +1737,7 @@ public: }; class AstSenItem final : public AstNode { // Parents: SENTREE - // @astgen op1 := sensp : AstNode // Sensitivity expression + // @astgen op1 := sensp : Optional[AstNode] // Sensitivity expression VEdgeType m_edgeType; // Edge type public: class Combo {}; // for constructor type-overload selection @@ -3523,7 +3523,8 @@ class AstTraceDecl final : public AstNodeStmt { // Trace point declaration // Separate from AstTraceInc; as a declaration can't be deleted // Parents: {statement list} - // @astgen op1 := valuep : AstNode // Expressio being traced + // Expression being traced - Moved to AstTraceInc by V3Trace + // @astgen op1 := valuep : Optional[AstNode] private: uint32_t m_code = 0; // Trace identifier code; converted to ASCII by trace routines const string m_showname; // Name of variable diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp index ffa5d336c..680f3b8b4 100644 --- a/src/V3Begin.cpp +++ b/src/V3Begin.cpp @@ -35,6 +35,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class BeginState final { @@ -71,7 +73,6 @@ private: bool m_underFork = false; // True if the current statement is directly under a fork // METHODS - VL_DEBUG_FUNC; // Declare debug() string dot(const string& a, const string& b) { if (a == "") return b; @@ -343,5 +344,5 @@ void V3Begin::debeginAll(AstNetlist* nodep) { { BeginVisitor{nodep, &state}; } if (state.anyFuncInBegin()) { BeginRelinkVisitor{nodep, &state}; } } // Destruct before checking - V3Global::dumpCheckGlobalTree("begin", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("begin", 0, dumpTree() >= 3); } diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp index 8cd525687..0cf4acda9 100644 --- a/src/V3Branch.cpp +++ b/src/V3Branch.cpp @@ -33,6 +33,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Branch state, as a visitor of each AstNode @@ -49,7 +51,6 @@ private: std::vector m_cfuncsp; // List of all tasks // METHODS - VL_DEBUG_FUNC; // Declare debug() void reset() { m_likely = false; diff --git a/src/V3Broken.cpp b/src/V3Broken.cpp index 2be4316d6..d039e593b 100644 --- a/src/V3Broken.cpp +++ b/src/V3Broken.cpp @@ -36,6 +36,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Generation counter for AstNode::m_brokenState diff --git a/src/V3CCtors.cpp b/src/V3CCtors.cpp index 62156ca31..e31a462b8 100644 --- a/src/V3CCtors.cpp +++ b/src/V3CCtors.cpp @@ -35,6 +35,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + class VCtorType final { public: enum en : uint8_t { MODULE, CLASS, COVERAGE }; diff --git a/src/V3CUse.cpp b/src/V3CUse.cpp index adc33fccd..11eb84957 100644 --- a/src/V3CUse.cpp +++ b/src/V3CUse.cpp @@ -32,6 +32,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Visit within a module all nodes and data types they reference, finding @@ -106,5 +108,5 @@ void V3CUse::cUseAll() { // for each output file and put under that CUseVisitor{modp}; } - V3Global::dumpCheckGlobalTree("cuse", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("cuse", 0, dumpTree() >= 3); } diff --git a/src/V3Case.cpp b/src/V3Case.cpp index d469978e2..258f76e0d 100644 --- a/src/V3Case.cpp +++ b/src/V3Case.cpp @@ -45,6 +45,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + #define CASE_OVERLAP_WIDTH 16 // Maximum width we can check for overlaps in #define CASE_BARF 999999 // Magic width when non-constant #define CASE_ENCODER_GROUP_DEPTH 8 // Levels of priority to be ORed together in top IF tree @@ -57,7 +59,6 @@ private: = nullptr; // Under a CASE value node, if so the relevant case statement // METHODS - VL_DEBUG_FUNC; // Declare debug() void visit(AstNodeCase* nodep) override { if (VN_IS(nodep, Case) && VN_AS(nodep, Case)->casex()) { @@ -138,7 +139,6 @@ private: std::array m_valueItem; // METHODS - VL_DEBUG_FUNC; // Declare debug() bool isCaseTreeFast(AstCase* nodep) { int width = 0; @@ -533,7 +533,7 @@ public: void V3Case::caseAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { CaseVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("case", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("case", 0, dumpTree() >= 3); } void V3Case::caseLint(AstNodeCase* nodep) { UINFO(4, __FUNCTION__ << ": " << endl); diff --git a/src/V3Cast.cpp b/src/V3Cast.cpp index c0add7658..8f7c303e3 100644 --- a/src/V3Cast.cpp +++ b/src/V3Cast.cpp @@ -47,6 +47,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Cast state, as a visitor of each AstNode @@ -60,7 +62,6 @@ private: // STATE // METHODS - VL_DEBUG_FUNC; // Declare debug() void insertCast(AstNode* nodep, int needsize) { // We'll insert ABOVE passed node UINFO(4, " NeedCast " << nodep << endl); @@ -207,5 +208,5 @@ public: void V3Cast::castAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { CastVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("cast", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("cast", 0, dumpTree() >= 3); } diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp index 0fe808ab3..163a34002 100644 --- a/src/V3Cdc.cpp +++ b/src/V3Cdc.cpp @@ -38,13 +38,14 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + constexpr int CDC_WEIGHT_ASYNC = 0x1000; // Weight for edges that feed async logic //###################################################################### class CdcBaseVisitor VL_NOT_FINAL : public VNVisitor { public: - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### @@ -323,13 +324,11 @@ private: void analyze() { UINFO(3, __FUNCTION__ << ": " << endl); - // if (debug() > 6) m_graph.dump(); - if (debug() > 6) m_graph.dumpDotFilePrefixed("cdc_pre"); + if (dumpGraph() > 6) m_graph.dumpDotFilePrefixed("cdc_pre"); + // This will MAX across edge weights + m_graph.removeRedundantEdges(&V3GraphEdge::followAlwaysTrue); // - m_graph.removeRedundantEdges( - &V3GraphEdge::followAlwaysTrue); // This will MAX across edge weights - // - m_graph.dumpDotFilePrefixed("cdc_simp"); + if (dumpGraph() >= 3) m_graph.dumpDotFilePrefixed("cdc_simp"); // analyzeReset(); } diff --git a/src/V3Class.cpp b/src/V3Class.cpp index f89be682d..810fe95d7 100644 --- a/src/V3Class.cpp +++ b/src/V3Class.cpp @@ -28,6 +28,8 @@ #include "V3Ast.h" #include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class ClassVisitor final : public VNVisitor { @@ -47,7 +49,6 @@ private: std::vector> m_toPackageMoves; // METHODS - VL_DEBUG_FUNC; // Declare debug() void visit(AstClass* nodep) override { if (nodep->user1SetOnce()) return; @@ -207,5 +208,5 @@ public: void V3Class::classAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ClassVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("class", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("class", 0, dumpTree() >= 3); } diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp index 7817304a2..cd9c96d7d 100644 --- a/src/V3Clean.cpp +++ b/src/V3Clean.cpp @@ -33,6 +33,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Clean state, as a visitor of each AstNode @@ -54,7 +56,6 @@ private: const AstNodeModule* m_modp = nullptr; // METHODS - VL_DEBUG_FUNC; // Declare debug() // Width resetting int cppWidth(AstNode* nodep) { @@ -317,5 +318,5 @@ public: void V3Clean::cleanAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { CleanVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("clean", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("clean", 0, dumpTree() >= 3); } diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp index f0682852c..31661a277 100644 --- a/src/V3Clock.cpp +++ b/src/V3Clock.cpp @@ -38,6 +38,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Convert every WRITE AstVarRef to a READ ref @@ -79,7 +81,6 @@ private: bool m_inSampled = false; // True inside a sampled expression // METHODS - VL_DEBUG_FUNC; // Declare debug() AstNode* createSenseEquation(AstSenItem* nodesp) { AstNode* senEqnp = nullptr; @@ -221,5 +222,5 @@ public: void V3Clock::clockAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ClockVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("clock", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("clock", 0, dumpTree() >= 3); } diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp index e372629d0..7d61aae35 100644 --- a/src/V3Combine.cpp +++ b/src/V3Combine.cpp @@ -33,6 +33,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + class CombineVisitor final : VNVisitor { // NODE STATE // AstNodeModule::user1() List of AstCFuncs in this module (via m_cfuncs) @@ -57,7 +59,6 @@ class CombineVisitor final : VNVisitor { VDouble0 m_cfuncsCombined; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() void removeEmptyFunctions(std::list& funcps) { for (funcit_t it = funcps.begin(), nit; it != funcps.end(); it = nit) { @@ -235,5 +236,5 @@ public: void V3Combine::combineAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); CombineVisitor::apply(nodep); - V3Global::dumpCheckGlobalTree("combine", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("combine", 0, dumpTree() >= 3); } diff --git a/src/V3Common.cpp b/src/V3Common.cpp index f64018c5b..9961585b9 100644 --- a/src/V3Common.cpp +++ b/src/V3Common.cpp @@ -29,6 +29,8 @@ #include "V3EmitCBase.h" #include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Common component builders @@ -117,5 +119,5 @@ void V3Common::commonAll() { makeToStringMiddle(classp); } } - V3Global::dumpCheckGlobalTree("common", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("common", 0, dumpTree() >= 3); } diff --git a/src/V3Config.cpp b/src/V3Config.cpp index 5c6d77acf..abfd4f295 100644 --- a/src/V3Config.cpp +++ b/src/V3Config.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Resolve wildcards in files, modules, ftasks or variables diff --git a/src/V3Const.cpp b/src/V3Const.cpp index 74e4a0b59..cf90d2156 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -37,6 +37,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Utilities @@ -350,7 +352,6 @@ class ConstBitOpTreeVisitor final : public VNVisitor { std::vector> m_varInfos; // VarInfo for each variable, [0] is nullptr // METHODS - VL_DEBUG_FUNC; // Declare debug() bool isAndTree() const { return VN_IS(m_rootp, And); } bool isOrTree() const { return VN_IS(m_rootp, Or); } @@ -893,7 +894,6 @@ private: V3UniqueNames m_concswapNames; // For generating unique temporary variable names // METHODS - VL_DEBUG_FUNC; // Declare debug() bool operandConst(AstNode* nodep) { return VN_IS(nodep, Const); } bool operandAsvConst(const AstNode* nodep) { @@ -3680,7 +3680,7 @@ void V3Const::constifyAllLint(AstNetlist* nodep) { ConstVisitor visitor{ConstVisitor::PROC_V_WARN, /* globalPass: */ true}; (void)visitor.mainAcceptEdit(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("const", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("const", 0, dumpTree() >= 3); } void V3Const::constifyCpp(AstNetlist* nodep) { @@ -3689,7 +3689,7 @@ void V3Const::constifyCpp(AstNetlist* nodep) { ConstVisitor visitor{ConstVisitor::PROC_CPP, /* globalPass: */ true}; (void)visitor.mainAcceptEdit(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("const_cpp", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("const_cpp", 0, dumpTree() >= 3); } AstNode* V3Const::constifyEdit(AstNode* nodep) { @@ -3713,7 +3713,7 @@ void V3Const::constifyAllLive(AstNetlist* nodep) { ConstVisitor visitor{ConstVisitor::PROC_LIVE, /* globalPass: */ true}; (void)visitor.mainAcceptEdit(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("const", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("const", 0, dumpTree() >= 3); } void V3Const::constifyAll(AstNetlist* nodep) { @@ -3723,7 +3723,7 @@ void V3Const::constifyAll(AstNetlist* nodep) { ConstVisitor visitor{ConstVisitor::PROC_V_EXPENSIVE, /* globalPass: */ true}; (void)visitor.mainAcceptEdit(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("const", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("const", 0, dumpTree() >= 3); } AstNode* V3Const::constifyExpensiveEdit(AstNode* nodep) { diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp index 1a87bb02f..324e6f7a4 100644 --- a/src/V3Coverage.cpp +++ b/src/V3Coverage.cpp @@ -35,6 +35,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Coverage state, as a visitor of each AstNode @@ -86,7 +88,6 @@ private: m_handleLines; // All line numbers for a given m_stateHandle // METHODS - VL_DEBUG_FUNC; // Declare debug() const char* varIgnoreToggle(AstVar* nodep) { // Return true if this shouldn't be traced @@ -546,5 +547,5 @@ public: void V3Coverage::coverage(AstNetlist* rootp) { UINFO(2, __FUNCTION__ << ": " << endl); { CoverageVisitor{rootp}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("coverage", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("coverage", 0, dumpTree() >= 3); } diff --git a/src/V3CoverageJoin.cpp b/src/V3CoverageJoin.cpp index b0d081a1d..d5571a7a7 100644 --- a/src/V3CoverageJoin.cpp +++ b/src/V3CoverageJoin.cpp @@ -28,6 +28,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // CoverageJoin state, as a visitor of each AstNode @@ -42,7 +44,6 @@ private: VDouble0 m_statToggleJoins; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() void detectDuplicates() { UINFO(9, "Finding duplicates\n"); @@ -116,5 +117,5 @@ public: void V3CoverageJoin::coverageJoin(AstNetlist* rootp) { UINFO(2, __FUNCTION__ << ": " << endl); { CoverageJoinVisitor{rootp}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("coveragejoin", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("coveragejoin", 0, dumpTree() >= 3); } diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp index ca79c18f5..d82d84797 100644 --- a/src/V3Dead.cpp +++ b/src/V3Dead.cpp @@ -44,6 +44,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Dead state, as a visitor of each AstNode @@ -78,7 +80,6 @@ private: bool m_sideEffect = false; // Side effects discovered in assign RHS // METHODS - VL_DEBUG_FUNC; // Declare debug() void checkAll(AstNode* nodep) { if (nodep != nodep->dtypep()) { // NodeDTypes reference themselves @@ -461,30 +462,29 @@ public: void V3Dead::deadifyModules(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DeadVisitor{nodep, false, false, false, false}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deadModules", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("deadModules", 0, dumpTree() >= 6); } void V3Dead::deadifyDTypes(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DeadVisitor{nodep, false, true, false, false}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deadDtypes", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("deadDtypes", 0, dumpTree() >= 3); } void V3Dead::deadifyDTypesScoped(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DeadVisitor{nodep, false, true, true, false}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deadDtypesScoped", 0, - v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("deadDtypesScoped", 0, dumpTree() >= 3); } void V3Dead::deadifyAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DeadVisitor{nodep, true, true, false, true}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deadAll", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("deadAll", 0, dumpTree() >= 3); } void V3Dead::deadifyAllScoped(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DeadVisitor{nodep, true, true, true, true}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deadAllScoped", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("deadAllScoped", 0, dumpTree() >= 3); } diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp index a060c216a..dbff9c7dc 100644 --- a/src/V3Delayed.cpp +++ b/src/V3Delayed.cpp @@ -61,6 +61,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Delayed state, as a visitor of each AstNode @@ -106,7 +108,6 @@ private: std::unordered_map m_scopeVecMap; // Next var number for each scope // METHODS - VL_DEBUG_FUNC; // Declare debug() void markVarUsage(AstNodeVarRef* nodep, bool blocking) { // Ignore if warning is disabled on this reference (used by V3Force). @@ -623,5 +624,5 @@ public: void V3Delayed::delayedAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DelayedVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("delayed", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("delayed", 0, dumpTree() >= 3); } diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp index f370c6d09..489d36b7d 100644 --- a/src/V3Depth.cpp +++ b/src/V3Depth.cpp @@ -34,6 +34,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class DepthVisitor final : public VNVisitor { @@ -49,7 +51,6 @@ private: V3UniqueNames m_tempNames; // For generating unique temporary variable names // METHODS - VL_DEBUG_FUNC; // Declare debug() void createDeepTemp(AstNode* nodep) { UINFO(6, " Deep " << nodep << endl); @@ -171,5 +172,5 @@ public: void V3Depth::depthAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DepthVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("depth", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("depth", 0, dumpTree() >= 6); } diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp index 89bd99669..9399e78e0 100644 --- a/src/V3DepthBlock.cpp +++ b/src/V3DepthBlock.cpp @@ -31,6 +31,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class DepthBlockVisitor final : public VNVisitor { @@ -44,7 +46,6 @@ private: int m_deepNum = 0; // How many functions made // METHODS - VL_DEBUG_FUNC; // Declare debug() AstCFunc* createDeepFunc(AstNode* nodep) { VNRelinker relinkHandle; @@ -131,5 +132,5 @@ public: void V3DepthBlock::depthBlockAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DepthBlockVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("deepblock", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("deepblock", 0, dumpTree() >= 3); } diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp index e1ad31fdc..10ab9b2ff 100644 --- a/src/V3Descope.cpp +++ b/src/V3Descope.cpp @@ -33,6 +33,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class DescopeVisitor final : public VNVisitor { @@ -53,7 +55,6 @@ private: FuncMmap m_modFuncs; // Name of public functions added // METHODS - VL_DEBUG_FUNC; // Declare debug() static bool modIsSingleton(AstNodeModule* modp) { // True iff there's exactly one instance of this module in the design (including top). @@ -279,5 +280,5 @@ public: void V3Descope::descopeAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { DescopeVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("descope", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("descope", 0, dumpTree() >= 3); } diff --git a/src/V3DupFinder.cpp b/src/V3DupFinder.cpp index 17c498646..70647a1d1 100644 --- a/src/V3DupFinder.cpp +++ b/src/V3DupFinder.cpp @@ -28,6 +28,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // V3DupFinder class functions @@ -98,7 +100,5 @@ void V3DupFinder::dumpFile(const string& filename, bool tree) { } void V3DupFinder::dumpFilePrefixed(const string& nameComment, bool tree) { - if (v3Global.opt.dumpTree()) { // - dumpFile(v3Global.debugFilename(nameComment) + ".hash", tree); - } + if (dump()) dumpFile(v3Global.debugFilename(nameComment) + ".hash", tree); } diff --git a/src/V3DupFinder.h b/src/V3DupFinder.h index 3853fa35f..9bc8df81b 100644 --- a/src/V3DupFinder.h +++ b/src/V3DupFinder.h @@ -59,7 +59,6 @@ public: } // METHODS - VL_DEBUG_FUNC; // Declare debug() // Expose minimal set of superclass interface using Super::begin; diff --git a/src/V3EmitCConstInit.h b/src/V3EmitCConstInit.h index 9c0960180..fbcac4c16 100644 --- a/src/V3EmitCConstInit.h +++ b/src/V3EmitCConstInit.h @@ -32,7 +32,6 @@ class EmitCConstInit VL_NOT_FINAL : public EmitCBaseVisitor { uint32_t m_unpackedWord = 0; // METHODS - VL_DEBUG_FUNC; // Declare debug() uint32_t tabModulus(AstNodeDType* dtypep) { const uint32_t elemBytes = dtypep->widthTotalBytes(); diff --git a/src/V3EmitCConstPool.cpp b/src/V3EmitCConstPool.cpp index d813fc955..672d2cabb 100644 --- a/src/V3EmitCConstPool.cpp +++ b/src/V3EmitCConstPool.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Const pool emitter @@ -38,7 +40,6 @@ class EmitCConstPool final : public EmitCConstInit { VDouble0 m_constsEmitted; // METHODS - VL_DEBUG_FUNC; // Declare debug() V3OutCFile* newOutCFile() const { const string fileName = v3Global.opt.makeDir() + "/" + topClassName() + "__ConstPool_" diff --git a/src/V3EmitCFunc.h b/src/V3EmitCFunc.h index 26d502c8e..e9b63f591 100644 --- a/src/V3EmitCFunc.h +++ b/src/V3EmitCFunc.h @@ -90,8 +90,6 @@ class EmitCLazyDecls final : public VNVisitor { void visit(AstNode* nodep) override { iterateChildrenConst(nodep); } - VL_DEBUG_FUNC; - public: explicit EmitCLazyDecls(EmitCBaseVisitor& emitter) : m_emitter(emitter) {} @@ -153,7 +151,6 @@ protected: public: // METHODS - VL_DEBUG_FUNC; // Declare debug() // ACCESSORS void splitSizeInc(int count) { m_splitSize += count; } diff --git a/src/V3EmitCHeaders.cpp b/src/V3EmitCHeaders.cpp index c4032b1f1..f03598b58 100644 --- a/src/V3EmitCHeaders.cpp +++ b/src/V3EmitCHeaders.cpp @@ -24,12 +24,13 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Internal EmitC implementation class EmitCHeader final : public EmitCConstInit { // METHODS - VL_DEBUG_FUNC; // Declare debug() void decorateFirst(bool& first, const string& str) { if (first) { diff --git a/src/V3EmitCImp.cpp b/src/V3EmitCImp.cpp index 43671b3c9..5e9c3367f 100644 --- a/src/V3EmitCImp.cpp +++ b/src/V3EmitCImp.cpp @@ -28,6 +28,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Visitor that gathers the headers required by an AstCFunc diff --git a/src/V3EmitCInlines.cpp b/src/V3EmitCInlines.cpp index 36b92ffec..24556fd5f 100644 --- a/src/V3EmitCInlines.cpp +++ b/src/V3EmitCInlines.cpp @@ -24,6 +24,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class EmitCInlines final : EmitCBaseVisitor { diff --git a/src/V3EmitCMain.cpp b/src/V3EmitCMain.cpp index ce744b4a6..87fd518ad 100644 --- a/src/V3EmitCMain.cpp +++ b/src/V3EmitCMain.cpp @@ -25,6 +25,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class EmitCMain final : EmitCBaseVisitor { diff --git a/src/V3EmitCMake.cpp b/src/V3EmitCMake.cpp index 48d0e628f..cf7b17563 100644 --- a/src/V3EmitCMake.cpp +++ b/src/V3EmitCMake.cpp @@ -26,13 +26,14 @@ #include -//###################################################################### -// Emit statements +VL_DEFINE_DEBUG_FUNCTIONS; + +// ###################################################################### +// Emit statements class CMakeEmitter final { // METHODS - VL_DEBUG_FUNC; // Declare debug() // STATIC FUNCTIONS diff --git a/src/V3EmitCModel.cpp b/src/V3EmitCModel.cpp index 90d44cc3c..5430337d2 100644 --- a/src/V3EmitCModel.cpp +++ b/src/V3EmitCModel.cpp @@ -26,6 +26,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + class EmitCModel final : public EmitCFunc { // TYPES using CFuncVector = std::vector; @@ -34,8 +36,6 @@ class EmitCModel final : public EmitCFunc { V3UniqueNames m_uniqueNames; // For generating unique file names // METHODS - VL_DEBUG_FUNC; - CFuncVector findFuncps(std::function cb) { CFuncVector funcps; for (AstNode* nodep = m_modp->stmtsp(); nodep; nodep = nodep->nextp()) { diff --git a/src/V3EmitCSyms.cpp b/src/V3EmitCSyms.cpp index 97edeafbe..62f2ba8b4 100644 --- a/src/V3EmitCSyms.cpp +++ b/src/V3EmitCSyms.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Symbol table emitting diff --git a/src/V3EmitMk.cpp b/src/V3EmitMk.cpp index 2c2d021d5..2d00e01a9 100644 --- a/src/V3EmitMk.cpp +++ b/src/V3EmitMk.cpp @@ -24,13 +24,14 @@ #include "V3HierBlock.h" #include "V3Os.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Emit statements and math operators class EmitMk final { public: // METHODS - VL_DEBUG_FUNC; // Declare debug() void putMakeClassEntry(V3OutMkFile& of, const string& name) { of.puts("\t" + V3Os::filenameNonDirExt(name) + " \\\n"); @@ -404,7 +405,6 @@ public: V3OutMkFile of(m_makefile); emit(of); } - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index fe4316d1f..ce76d6135 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -26,6 +26,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Emit statements and math operators @@ -36,7 +38,6 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor { AstSenTree* m_sensesp; // Domain for printing one a ALWAYS under a ACTIVE // METHODS - VL_DEBUG_FUNC; // Declare debug() virtual void puts(const string& str) = 0; virtual void putbs(const string& str) = 0; diff --git a/src/V3EmitXml.cpp b/src/V3EmitXml.cpp index a791bfde9..7d1df2878 100644 --- a/src/V3EmitXml.cpp +++ b/src/V3EmitXml.cpp @@ -26,6 +26,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Emit statements and math operators @@ -39,7 +41,6 @@ class EmitXmlFileVisitor final : public VNVisitor { uint64_t m_id = 0; // METHODS - VL_DEBUG_FUNC; // Declare debug() // Outfile methods V3OutFile* ofp() const { return m_ofp; } @@ -329,7 +330,6 @@ private: std::deque m_nodeModules; // METHODS - VL_DEBUG_FUNC; // Declare debug() // VISITORS void visit(AstNetlist* nodep) override { @@ -377,7 +377,6 @@ private: bool m_hasChildren = false; // METHODS - VL_DEBUG_FUNC; // Declare debug() // VISITORS void visit(AstConstPool*) override {} diff --git a/src/V3Error.cpp b/src/V3Error.cpp index 4912e67b4..54b61132d 100644 --- a/src/V3Error.cpp +++ b/src/V3Error.cpp @@ -20,6 +20,7 @@ # include "V3Ast.h" # include "V3Global.h" # include "V3Stats.h" +VL_DEFINE_DEBUG_FUNCTIONS; #endif // clang-format on @@ -275,8 +276,10 @@ void V3Error::v3errorEnd(std::ostringstream& sstr, const string& extra) { s_tellManual = 2; } #ifndef V3ERROR_NO_GLOBAL_ - if (debug()) { + if (dumpTree()) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("final.tree", 990)); + } + if (debug()) { if (s_errorExitCb) s_errorExitCb(); V3Stats::statsFinalAll(v3Global.rootp()); V3Stats::statsReport(); diff --git a/src/V3Error.h b/src/V3Error.h index 22d156ac0..4cbdf3094 100644 --- a/src/V3Error.h +++ b/src/V3Error.h @@ -26,6 +26,7 @@ #include #include #include +#include #include #include #include @@ -325,7 +326,6 @@ public: }; // Global versions, so that if the class doesn't define a operator, we get the functions anyways. -inline int debug() { return V3Error::debugDefault(); } inline void v3errorEnd(std::ostringstream& sstr) { V3Error::v3errorEnd(sstr); } inline void v3errorEndFatal(std::ostringstream& sstr) { V3Error::v3errorEnd(sstr); @@ -420,19 +420,47 @@ inline void v3errorEndFatal(std::ostringstream& sstr) { V3ERROR_NA; \ return value -/// Declare a convenience debug() routine that may be added to any class in -/// Verilator so that --debugi- will work to control UINFOs in -/// that class: -#define VL_DEBUG_FUNC \ - static int debug() { \ +// Helper macros for VL_DEFINE_DEBUG_FUNCTIONS +#define VL_DEFINE_DEBUG(name) \ + VL_ATTR_UNUSED static int debug##name() { \ static int level = -1; \ if (VL_UNLIKELY(level < 0)) { \ - const int debugSrcLevel = v3Global.opt.debugSrcLevel(__FILE__); \ - if (!v3Global.opt.available()) return debugSrcLevel; \ - level = debugSrcLevel; \ + std::string tag{VL_STRINGIFY(name)}; \ + tag[0] = std::tolower(tag[0]); \ + const unsigned debugTag = v3Global.opt.debugLevel(tag); \ + const unsigned debugSrc = v3Global.opt.debugSrcLevel(__FILE__); \ + const unsigned debugLevel = debugTag >= debugSrc ? debugTag : debugSrc; \ + if (!v3Global.opt.available()) return static_cast(debugLevel); \ + level = static_cast(debugLevel); \ } \ return level; \ - } + } \ + static_assert(true, "") + +#define VL_DEFINE_DUMP(name) \ + VL_ATTR_UNUSED static int dump##name() { \ + static int level = -1; \ + if (VL_UNLIKELY(level < 0)) { \ + std::string tag{VL_STRINGIFY(name)}; \ + tag[0] = std::tolower(tag[0]); \ + const unsigned dumpTag = v3Global.opt.dumpLevel(tag); \ + const unsigned dumpSrc = v3Global.opt.dumpSrcLevel(__FILE__); \ + const unsigned dumpLevel = dumpTag >= dumpSrc ? dumpTag : dumpSrc; \ + if (!v3Global.opt.available()) return static_cast(dumpLevel); \ + level = static_cast(dumpLevel); \ + } \ + return level; \ + } \ + static_assert(true, "") + +// Define debug*() and dump*() routines. This needs to be added to every compilation unit so that +// --debugi- and --dumpi- can be used to control debug prints and dumping +#define VL_DEFINE_DEBUG_FUNCTIONS \ + VL_DEFINE_DEBUG(); /* Define 'int debug()' */ \ + VL_DEFINE_DUMP(); /* Define 'int dump()' */ \ + VL_DEFINE_DUMP(Graph); /* Define 'int dumpGraph()' */ \ + VL_DEFINE_DUMP(Tree); /* Define 'int dumpTree()' */ \ + static_assert(true, "") //---------------------------------------------------------------------- diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp index 9eea581ae..7bba5f825 100644 --- a/src/V3Expand.cpp +++ b/src/V3Expand.cpp @@ -37,6 +37,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Expand state, as a visitor of each AstNode @@ -53,7 +55,6 @@ private: VDouble0 m_statWideLimited; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() bool doExpand(AstNode* nodep) { ++m_statWides; @@ -898,5 +899,5 @@ public: void V3Expand::expandAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ExpandVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("expand", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("expand", 0, dumpTree() >= 3); } diff --git a/src/V3File.cpp b/src/V3File.cpp index 96386cbc4..a8e23182a 100644 --- a/src/V3File.cpp +++ b/src/V3File.cpp @@ -56,6 +56,8 @@ #endif // clang-format on +VL_DEFINE_DEBUG_FUNCTIONS; + // If change this code, run a test with the below size set very small // #define INFILTER_IPC_BUFSIZ 16 constexpr int INFILTER_IPC_BUFSIZ = (64 * 1024); // For debug, try this as a small number @@ -346,7 +348,6 @@ class VInFilterImp final { private: // METHODS - VL_DEBUG_FUNC; // Declare debug() bool readContents(const string& filename, StrList& outl) { if (m_pid) { diff --git a/src/V3FileLine.cpp b/src/V3FileLine.cpp index 4201e77d5..a703cf4c6 100644 --- a/src/V3FileLine.cpp +++ b/src/V3FileLine.cpp @@ -33,6 +33,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // FileLineSingleton class functions @@ -83,12 +85,6 @@ void FileLineSingleton::fileNameNumMapDumpXml(std::ostream& os) { //###################################################################### // VFileContents class functions -int VFileContent::debug() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__); - return level; -} - void VFileContent::pushText(const string& text) { if (m_lines.size() == 0) { m_lines.emplace_back(""); // no such thing as line [0] diff --git a/src/V3FileLine.h b/src/V3FileLine.h index 106827dc6..08ec31d5c 100644 --- a/src/V3FileLine.h +++ b/src/V3FileLine.h @@ -77,7 +77,6 @@ public: void pushText(const string& text); // Add arbitrary text (need not be line-by-line) string getLine(int lineno) const; string ascii() const { return "ct" + cvtToStr(m_id); } - static int debug(); }; std::ostream& operator<<(std::ostream& os, VFileContent* contentp); diff --git a/src/V3Force.cpp b/src/V3Force.cpp index 446869208..bebf210ac 100644 --- a/src/V3Force.cpp +++ b/src/V3Force.cpp @@ -46,6 +46,8 @@ #include "V3Error.h" #include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Convert force/release statements and signals marked 'forceable' @@ -305,5 +307,5 @@ void V3Force::forceAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); if (!v3Global.hasForceableSignals()) return; ForceConvertVisitor::apply(nodep); - V3Global::dumpCheckGlobalTree("force", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("force", 0, dumpTree() >= 3); } diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp index d46d9874e..8a25f4513 100644 --- a/src/V3Gate.cpp +++ b/src/V3Gate.cpp @@ -39,6 +39,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + class GateDedupeVarVisitor; using GateVarRefList = std::list; @@ -47,13 +49,6 @@ constexpr int GATE_DEDUP_MAX_DEPTH = 20; //###################################################################### -class GateBaseVisitor VL_NOT_FINAL : public VNVisitor { -public: - VL_DEBUG_FUNC; // Declare debug() -}; - -//###################################################################### - class GateLogicVertex; class GateVarVertex; class GateGraphBaseVisitor VL_NOT_FINAL { @@ -64,7 +59,6 @@ public: virtual ~GateGraphBaseVisitor() = default; virtual VNUser visit(GateLogicVertex* vertexp, VNUser vu = VNUser{0}) = 0; virtual VNUser visit(GateVarVertex* vertexp, VNUser vu = VNUser{0}) = 0; - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### @@ -194,7 +188,7 @@ public: //###################################################################### // Is this a simple math expression with a single input and single output? -class GateOkVisitor final : public GateBaseVisitor { +class GateOkVisitor final : public VNVisitor { private: // RETURN STATE bool m_isSimple = true; // Set false when we know it isn't simple @@ -311,7 +305,7 @@ static void eliminate(AstNode* logicp, // ###################################################################### // Gate class functions -class GateVisitor final : public GateBaseVisitor { +class GateVisitor final : public VNVisitor { private: // NODE STATE // Entire netlist: @@ -423,13 +417,12 @@ private: // VISITORS void visit(AstNetlist* nodep) override { iterateChildren(nodep); - // if (debug() > 6) m_graph.dump(); - if (debug() > 6) m_graph.dumpDotFilePrefixed("gate_pre"); + if (dumpGraph() >= 3) m_graph.dumpDotFilePrefixed("gate_pre"); warnSignals(); // Before loss of sync/async pointers // Decompose clock vectors -- need to do this before removing redundant edges decomposeClkVectors(); m_graph.removeRedundantEdgesSum(&V3GraphEdge::followAlwaysTrue); - m_graph.dumpDotFilePrefixed("gate_simp"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("gate_simp"); // Find gate interconnect and optimize m_graph.userClearVertices(); // vertex->user(): bool. Indicates we've set it as consumed // Get rid of buffers first, @@ -441,15 +434,15 @@ private: // Remove redundant logic if (v3Global.opt.fDedupe()) { dedupe(); - if (debug() >= 6) m_graph.dumpDotFilePrefixed("gate_dedup"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("gate_dedup"); } if (v3Global.opt.fAssemble()) { mergeAssigns(); - if (debug() >= 6) m_graph.dumpDotFilePrefixed("gate_assm"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("gate_assm"); } // Consumption warnings consumedMark(); - m_graph.dumpDotFilePrefixed("gate_opt"); + if (dumpGraph() >= 3) m_graph.dumpDotFilePrefixed("gate_opt"); // Rewrite assignments consumedMove(); } @@ -791,8 +784,6 @@ private: V3DupFinder m_dupFinder; // Duplicate finder for rhs of assigns std::unordered_set m_nodeDeleteds; // Any node in this hash was deleted - VL_DEBUG_FUNC; // Declare debug() - bool same(AstNode* node1p, AstNode* node2p) { // Regarding the complexity of this funcition 'same': // Applying this comparison function to a a set of n trees pairwise is O(n^2) in the @@ -897,7 +888,7 @@ public: //###################################################################### // Have we seen the rhs of this assign before? -class GateDedupeVarVisitor final : public GateBaseVisitor { +class GateDedupeVarVisitor final : public VNVisitor { // Given a node, it is visited to try to find the AstNodeAssign under // it that can used for dedupe. // Right now, only the following node trees are supported for dedupe. @@ -1081,7 +1072,6 @@ private: const GateLogicVertex* const consumeVertexp = static_cast(outedgep->top()); AstNode* const consumerp = consumeVertexp->nodep(); - // if (debug() >= 9) m_graphp->dumpDotFilePrefixed("gate_preelim"); UINFO(9, "elim src vtx" << lvertexp << " node " << lvertexp->nodep() << endl); UINFO(9, @@ -1297,7 +1287,7 @@ void GateVisitor::mergeAssigns() { //###################################################################### // Find a var's offset in a concatenation -class GateConcatVisitor final : public GateBaseVisitor { +class GateConcatVisitor final : public VNVisitor { private: // STATE const AstVarScope* m_vscp = nullptr; // Varscope we're trying to find @@ -1493,5 +1483,5 @@ void GateVisitor::decomposeClkVectors() { void V3Gate::gateAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { const GateVisitor visitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("gate", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("gate", 0, dumpTree() >= 3); } diff --git a/src/V3Graph.cpp b/src/V3Graph.cpp index fe0be1cf6..faffb7b41 100644 --- a/src/V3Graph.cpp +++ b/src/V3Graph.cpp @@ -28,8 +28,7 @@ #include #include -int V3Graph::s_debug = 0; -int V3Graph::debug() { return std::max(V3Error::debugDefault(), s_debug); } +VL_DEFINE_DEBUG_FUNCTIONS; //###################################################################### //###################################################################### @@ -312,9 +311,7 @@ void V3Graph::dumpEdge(std::ostream& os, V3GraphVertex* vertexp, V3GraphEdge* ed } void V3Graph::dumpDotFilePrefixed(const string& nameComment, bool colorAsSubgraph) const { - if (v3Global.opt.dumpTree()) { - dumpDotFile(v3Global.debugFilename(nameComment) + ".dot", colorAsSubgraph); - } + dumpDotFile(v3Global.debugFilename(nameComment) + ".dot", colorAsSubgraph); } //! Variant of dumpDotFilePrefixed without --dump option check diff --git a/src/V3Graph.h b/src/V3Graph.h index 9d6b9ea06..8190e946e 100644 --- a/src/V3Graph.h +++ b/src/V3Graph.h @@ -81,7 +81,6 @@ class V3Graph VL_NOT_FINAL { private: // MEMBERS V3List m_vertices; // All vertices - static int s_debug; protected: friend class V3GraphVertex; @@ -92,12 +91,10 @@ protected: void dumpEdge(std::ostream& os, V3GraphVertex* vertexp, V3GraphEdge* edgep); void verticesUnlink() { m_vertices.reset(); } // ACCESSORS - static int debug(); public: V3Graph(); virtual ~V3Graph(); - static void debug(int level) { s_debug = level; } virtual string dotRankDir() const { return "TB"; } // rankdir for dot plotting // METHODS diff --git a/src/V3GraphAcyc.cpp b/src/V3GraphAcyc.cpp index 8860a5479..016c6930b 100644 --- a/src/V3GraphAcyc.cpp +++ b/src/V3GraphAcyc.cpp @@ -24,6 +24,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### //###################################################################### // Algorithms - acyclic @@ -104,8 +106,6 @@ private: m_origEdgeFuncp; // Function that says we follow this edge (in original graph) uint32_t m_placeStep = 0; // Number that user() must be equal to to indicate processing - static int debug() { return V3Graph::debug(); } - // METHODS void buildGraph(V3Graph* origGraphp); void buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* avertexp); @@ -544,28 +544,28 @@ void GraphAcyc::main() { // edges (and thus can't represent loops - if we did the unbreakable // marking right, anyways) buildGraph(m_origGraphp); - if (debug() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_pre"); + if (dumpGraph() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_pre"); // Perform simple optimizations before any cuttings simplify(false); - if (debug() >= 5) m_breakGraph.dumpDotFilePrefixed("acyc_simp"); + if (dumpGraph() >= 5) m_breakGraph.dumpDotFilePrefixed("acyc_simp"); UINFO(4, " Cutting trivial loops\n"); simplify(true); - if (debug() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_mid"); + if (dumpGraph() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_mid"); UINFO(4, " Ranking\n"); m_breakGraph.rank(&V3GraphEdge::followNotCutable); - if (debug() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_rank"); + if (dumpGraph() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_rank"); UINFO(4, " Placement\n"); place(); - if (debug() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_place"); + if (dumpGraph() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_place"); UINFO(4, " Final Ranking\n"); // Only needed to assert there are no loops in completed graph m_breakGraph.rank(&V3GraphEdge::followAlwaysTrue); - if (debug() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_done"); + if (dumpGraph() >= 6) m_breakGraph.dumpDotFilePrefixed("acyc_done"); } void V3Graph::acyclic(V3EdgeFuncP edgeFuncp) { diff --git a/src/V3GraphAlg.cpp b/src/V3GraphAlg.cpp index c5e7dcec9..0e5042b5a 100644 --- a/src/V3GraphAlg.cpp +++ b/src/V3GraphAlg.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### //###################################################################### // Algorithms - weakly connected components @@ -120,7 +122,6 @@ public: } private: - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(GraphAlgRemoveTransitiveEdges); }; diff --git a/src/V3GraphPathChecker.h b/src/V3GraphPathChecker.h index 06be17d4f..b919c7869 100644 --- a/src/V3GraphPathChecker.h +++ b/src/V3GraphPathChecker.h @@ -56,7 +56,6 @@ private: void initHalfCriticalPaths(GraphWay way, bool checkOnly); void incGeneration() { ++m_generation; } - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(GraphPathChecker); }; diff --git a/src/V3GraphTest.cpp b/src/V3GraphTest.cpp index 40f847e0e..3fdb8dfe7 100644 --- a/src/V3GraphTest.cpp +++ b/src/V3GraphTest.cpp @@ -20,6 +20,8 @@ #include "V3Global.h" #include "V3Graph.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### //###################################################################### // Test class @@ -34,14 +36,14 @@ protected: virtual string name() = 0; // Name of the test // Utilities - void dump() { - if (debug() >= 9) m_graph.dumpDotFilePrefixed("v3graphtest_" + name()); + void dumpSelf() { + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed("v3graphtest_" + name()); } public: V3GraphTest() = default; virtual ~V3GraphTest() = default; - VL_DEBUG_FUNC; // Declare debug() + void run() { runTest(); } }; @@ -101,7 +103,7 @@ public: new V3GraphEdge(gp, g3, q, 2, true); gp->stronglyConnected(&V3GraphEdge::followAlwaysTrue); - dump(); + dumpSelf(); UASSERT(i->color() != a->color() && a->color() != g2->color() && g2->color() != q->color(), "SelfTest: Separate colors not assigned"); @@ -136,7 +138,7 @@ public: gp->acyclic(&V3GraphEdge::followAlwaysTrue); gp->order(); - dump(); + dumpSelf(); } }; @@ -253,7 +255,7 @@ public: gp->acyclic(&V3GraphEdge::followAlwaysTrue); gp->order(); - dump(); + dumpSelf(); } }; @@ -272,11 +274,11 @@ public: void runTest() override { V3Graph* const gp = &m_graph; dotImport(); - dump(); + dumpSelf(); gp->acyclic(&V3GraphEdge::followAlwaysTrue); - dump(); + dumpSelf(); gp->rank(&V3GraphEdge::followAlwaysTrue); - dump(); + dumpSelf(); } }; diff --git a/src/V3Hasher.cpp b/src/V3Hasher.cpp index d27bd64b8..681c68c92 100644 --- a/src/V3Hasher.cpp +++ b/src/V3Hasher.cpp @@ -21,6 +21,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Visitor that computes node hashes @@ -35,7 +37,6 @@ private: const bool m_cacheInUser4; // Use user4 to cache each V3Hash? // METHODS - VL_DEBUG_FUNC; // Declare debug() V3Hash hashNodeAndIterate(AstNode* nodep, bool hashDType, bool hashChildren, std::function&& f) { diff --git a/src/V3Hasher.h b/src/V3Hasher.h index 9944f84b1..823a1a074 100644 --- a/src/V3Hasher.h +++ b/src/V3Hasher.h @@ -40,7 +40,6 @@ public: ~V3Hasher() = default; // METHODS - VL_DEBUG_FUNC; // Declare debug() // Compute hash of node. This method caches the hash in the node's user4(). V3Hash operator()(AstNode* nodep) const; diff --git a/src/V3HierBlock.cpp b/src/V3HierBlock.cpp index 7a1b07057..a5f2fa38a 100644 --- a/src/V3HierBlock.cpp +++ b/src/V3HierBlock.cpp @@ -86,6 +86,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + static string V3HierCommandArgsFileName(const string& prefix, bool forCMake) { return v3Global.opt.makeDir() + "/" + prefix + (forCMake ? "_hierCMakeArgs.f" : "_hierMkArgs.f"); @@ -302,7 +304,6 @@ public: : m_planp{planp} { iterateChildren(netlist); } - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### diff --git a/src/V3HierBlock.h b/src/V3HierBlock.h index b4fe14374..7526423d5 100644 --- a/src/V3HierBlock.h +++ b/src/V3HierBlock.h @@ -67,7 +67,6 @@ public: : m_modp{modp} , m_gparams{gparams} {} ~V3HierBlock(); - VL_DEBUG_FUNC; // Declare debug() void addParent(V3HierBlock* parentp) { m_parents.insert(parentp); } void addChild(V3HierBlock* childp) { m_children.insert(childp); } @@ -107,7 +106,6 @@ public: using iterator = HierMap::iterator; using const_iterator = HierMap::const_iterator; using HierVector = std::vector; - VL_DEBUG_FUNC; // Declare debug() void add(const AstNodeModule* modp, const std::vector& gparams); void registerUsage(const AstNodeModule* parentp, const AstNodeModule* childp); diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp index cacca2901..cad404fbc 100644 --- a/src/V3Inline.cpp +++ b/src/V3Inline.cpp @@ -40,6 +40,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + // CONFIG static const int INLINE_MODS_SMALLER = 100; // If a mod is < this # nodes, can always inline it @@ -95,7 +97,6 @@ private: std::unordered_map m_instances; // METHODS - VL_DEBUG_FUNC; // Declare debug() void cantInline(const char* reason, bool hard) { if (hard) { if (m_modp->user2() != CIL_NOTHARD) { @@ -256,9 +257,6 @@ private: AstNodeModule* const m_modp; // Current module const AstCell* const m_cellp; // Cell being cloned - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITORS void visit(AstCellInline* nodep) override { // Inlined cell under the inline cell, need to move to avoid conflicts @@ -478,8 +476,6 @@ private: VDouble0 m_statCells; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() - void inlineCell(AstCell* nodep) { UINFO(5, " Inline CELL " << nodep << endl); @@ -635,9 +631,6 @@ private: string m_scope; // Scope name - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITORS void visit(AstNetlist* nodep) override { iterateChildren(nodep->topModulep()); } void visit(AstCell* nodep) override { @@ -734,5 +727,5 @@ void V3Inline::inlineAll(AstNetlist* nodep) { } { InlineIntfRefVisitor{nodep}; } - V3Global::dumpCheckGlobalTree("inline", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("inline", 0, dumpTree() >= 3); } diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp index adca8b9da..328318dc5 100644 --- a/src/V3Inst.cpp +++ b/src/V3Inst.cpp @@ -32,6 +32,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Inst state, as a visitor of each AstNode @@ -45,9 +47,6 @@ private: // STATE AstCell* m_cellp = nullptr; // Current cell - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITORS void visit(AstCell* nodep) override { UINFO(4, " CELL " << nodep << endl); @@ -146,8 +145,6 @@ private: // STATE std::map m_modVarNameMap; // Per module, name of cloned variables - VL_DEBUG_FUNC; // Declare debug() - // VISITORS void visit(AstVar* nodep) override { if (VN_IS(nodep->dtypep(), IfaceRefDType)) { @@ -200,8 +197,6 @@ private: int m_instSelNum = 0; // Current instantiation count 0..N-1 InstDeModVarVisitor m_deModVars; // State of variables for current cell module - VL_DEBUG_FUNC; // Declare debug() - // VISITORS void visit(AstVar* nodep) override { if (VN_IS(nodep->dtypep(), UnpackArrayDType) @@ -492,7 +487,6 @@ public: class InstStatic final { private: - VL_DEBUG_FUNC; // Declare debug() InstStatic() = default; // Static class static AstNode* extendOrSel(FileLine* fl, AstNode* rhsp, AstNode* cmpWidthp) { @@ -622,11 +616,11 @@ void V3Inst::checkOutputShort(AstPin* nodep) { void V3Inst::instAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { InstVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("inst", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("inst", 0, dumpTree() >= 3); } void V3Inst::dearrayAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { InstDeVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("dearray", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("dearray", 0, dumpTree() >= 6); } diff --git a/src/V3InstrCount.cpp b/src/V3InstrCount.cpp index 534ce403d..7aff91d73 100644 --- a/src/V3InstrCount.cpp +++ b/src/V3InstrCount.cpp @@ -24,6 +24,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + /// Estimate the instruction cost for executing all logic within and below /// a given AST node. Note this estimates the number of instructions we'll /// execute, not the number we'll generate. That is, for conditionals, @@ -290,7 +292,6 @@ private: iterateChildren(nodep); } - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(InstrCountVisitor); }; @@ -326,7 +327,7 @@ private: } --m_depth; } - VL_DEBUG_FUNC; // Declare debug() + VL_UNCOPYABLE(InstrCountDumpVisitor); }; diff --git a/src/V3Life.cpp b/src/V3Life.cpp index edd9b8d5f..48d765b8a 100644 --- a/src/V3Life.cpp +++ b/src/V3Life.cpp @@ -36,6 +36,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Structure for global state @@ -129,8 +131,6 @@ class LifeBlock final { LifeBlock* const m_aboveLifep; // Upper life, or nullptr LifeState* const m_statep; // Current global state - VL_DEBUG_FUNC; // Declare debug() - public: LifeBlock(LifeBlock* aboveLifep, LifeState* statep) : m_aboveLifep{aboveLifep} // Null if top @@ -284,7 +284,6 @@ private: LifeBlock* m_lifep; // Current active lifetime map for current scope // METHODS - VL_DEBUG_FUNC; // Declare debug() void setNoopt() { m_noopt = true; m_lifep->clear(); @@ -512,5 +511,5 @@ void V3Life::lifeAll(AstNetlist* nodep) { LifeState state; LifeTopVisitor{nodep, &state}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("life", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("life", 0, dumpTree() >= 3); } diff --git a/src/V3LifePost.cpp b/src/V3LifePost.cpp index faa13a32f..6ad15bad7 100644 --- a/src/V3LifePost.cpp +++ b/src/V3LifePost.cpp @@ -38,6 +38,8 @@ #include // for std::unique_ptr -> auto_ptr or unique_ptr #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // LifePost class functions @@ -50,8 +52,6 @@ private: // AstVarScope::user4p() -> AstVarScope*, If set, replace this // varscope with specified new one // STATE - // METHODS - VL_DEBUG_FUNC; // Declare debug() // VISITORS void visit(AstVarRef* nodep) override { @@ -160,8 +160,6 @@ private: bool m_inEvalNba = false; // Traversing under _eval__nba // METHODS - VL_DEBUG_FUNC; // Declare debug() - bool before(const LifeLocation& a, const LifeLocation& b) { if (a.mtaskp == b.mtaskp) return a.sequence < b.sequence; return m_checker->pathExistsFrom(a.mtaskp, b.mtaskp); @@ -371,5 +369,5 @@ void V3LifePost::lifepostAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); // Mark redundant AssignPost { LifePostDlyVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("life_post", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("life_post", 0, dumpTree() >= 3); } diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp index 5057a4090..c92a41a10 100644 --- a/src/V3LinkCells.cpp +++ b/src/V3LinkCells.cpp @@ -39,6 +39,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Graph subclasses @@ -118,8 +120,6 @@ private: std::unordered_set m_declfnWarned; // Files we issued DECLFILENAME on string m_origTopModuleName; // original name of the top module - VL_DEBUG_FUNC; // Declare debug() - // METHODS V3GraphVertex* vertex(AstNodeModule* nodep) { // Return corresponding vertex for this module @@ -167,7 +167,7 @@ private: iterateChildren(nodep); // Find levels in graph m_graph.removeRedundantEdges(&V3GraphEdge::followAlwaysTrue); - m_graph.dumpDotFilePrefixed("linkcells"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed("linkcells"); m_graph.rank(); for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp = itp->verticesNextp()) { if (const LinkCellsVertex* const vvertexp = dynamic_cast(itp)) { diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index 57f9fca83..75681218f 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -76,8 +76,10 @@ #include #include -//###################################################################### -// Matcher classes (for suggestion matching) +VL_DEFINE_DEBUG_FUNCTIONS; + +// ###################################################################### +// Matcher classes (for suggestion matching) class LinkNodeMatcherClass final : public VNodeMatcher { public: @@ -162,14 +164,14 @@ private: public: // METHODS - VL_DEBUG_FUNC; // Declare debug() - void dump(const string& nameComment = "linkdot", bool force = false) { - if (debug() >= 6 || force) { + + void dumpSelf(const string& nameComment = "linkdot", bool force = false) { + if (dump() >= 6 || force) { const string filename = v3Global.debugFilename(nameComment) + ".txt"; const std::unique_ptr logp{V3File::new_ofstream(filename)}; if (logp->fail()) v3fatal("Can't write " << filename); std::ostream& os = *logp; - m_syms.dump(os); + m_syms.dumpSelf(os); bool first = true; for (int samn = 0; samn < SAMN__MAX; ++samn) { if (!m_scopeAliasMap[samn].empty()) { @@ -191,9 +193,9 @@ public: } void preErrorDump() { static bool diddump = false; - if (!diddump && v3Global.opt.dumpTree()) { + if (!diddump && dumpTree()) { diddump = true; - dump("linkdot-preerr", true); + dumpSelf("linkdot-preerr", true); v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("linkdot-preerr.tree")); } } @@ -726,8 +728,6 @@ class LinkDotFindVisitor final : public VNVisitor { int m_modWithNum = 0; // With block number, 0=none seen // METHODS - static int debug() { return LinkDotState::debug(); } - void makeImplicitNew(AstClass* nodep) { AstFunc* const newp = new AstFunc(nodep->fileline(), "new", nullptr, nullptr); newp->isConstructor(true); @@ -1400,8 +1400,6 @@ private: LinkDotState* const m_statep; // State to pass between visitors, including symbol table AstNodeModule* m_modp = nullptr; // Current module - static int debug() { return LinkDotState::debug(); } - void pinImplicitExprRecurse(AstNode* nodep) { // Under a pin, Check interconnect expression for a pin reference or a concat. // Create implicit variable as needed @@ -1591,8 +1589,6 @@ class LinkDotScopeVisitor final : public VNVisitor { const AstScope* m_scopep = nullptr; // The current scope VSymEnt* m_modSymp = nullptr; // Symbol entry for current module - static int debug() { return LinkDotState::debug(); } - // VISITs void visit(AstNetlist* nodep) override { // Recurse..., backward as must do packages before using packages @@ -1756,9 +1752,6 @@ class LinkDotIfaceVisitor final : public VNVisitor { LinkDotState* const m_statep; // State to pass between visitors, including symbol table VSymEnt* m_curSymp; // Symbol Entry for current table, where to lookup/insert - // METHODS - static int debug() { return LinkDotState::debug(); } - // VISITs void visit(AstModport* nodep) override { // Modport: Remember its name for later resolution @@ -1906,8 +1899,6 @@ private: } } m_ds; // State to preserve across recursions - static int debug() { return LinkDotState::debug(); } - // METHODS - Variables void createImplicitVar(VSymEnt* /*lookupSymp*/, AstVarRef* nodep, AstNodeModule* modp, VSymEnt* moduleSymp, bool noWarn) { @@ -3176,21 +3167,19 @@ public: //###################################################################### // Link class functions -int V3LinkDot::debug() { return LinkDotState::debug(); } - void V3LinkDot::linkDotGuts(AstNetlist* rootp, VLinkDotStep step) { - if (LinkDotState::debug() >= 5 || v3Global.opt.dumpTree() >= 9) { + if (debug() >= 5 || dumpTree() >= 9) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("prelinkdot.tree")); } LinkDotState state(rootp, step); const LinkDotFindVisitor visitor{rootp, &state}; - if (LinkDotState::debug() >= 5 || v3Global.opt.dumpTree() >= 9) { + if (debug() >= 5 || dumpTree() >= 9) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("prelinkdot-find.tree")); } if (step == LDS_PRIMARY || step == LDS_PARAMED) { // Initial link stage, resolve parameters const LinkDotParamVisitor visitors{rootp, &state}; - if (LinkDotState::debug() >= 5 || v3Global.opt.dumpTree() >= 9) { + if (debug() >= 5 || dumpTree() >= 9) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("prelinkdot-param.tree")); } } else if (step == LDS_ARRAYED) { @@ -3199,16 +3188,40 @@ void V3LinkDot::linkDotGuts(AstNetlist* rootp, VLinkDotStep step) { // process AstScope's. This needs to be separate pass after whole hierarchy graph created. const LinkDotScopeVisitor visitors{rootp, &state}; v3Global.assertScoped(true); - if (LinkDotState::debug() >= 5 || v3Global.opt.dumpTree() >= 9) { + if (debug() >= 5 || dumpTree() >= 9) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("prelinkdot-scoped.tree")); } } else { v3fatalSrc("Bad case"); } - state.dump(); + state.dumpSelf(); state.computeIfaceModSyms(); state.computeIfaceVarSyms(); state.computeScopeAliases(); - state.dump(); + state.dumpSelf(); { LinkDotResolveVisitor{rootp, &state}; } } + +void V3LinkDot::linkDotPrimary(AstNetlist* nodep) { + UINFO(2, __FUNCTION__ << ": " << endl); + linkDotGuts(nodep, LDS_PRIMARY); + V3Global::dumpCheckGlobalTree("linkdot", 0, dumpTree() >= 6); +} + +void V3LinkDot::linkDotParamed(AstNetlist* nodep) { + UINFO(2, __FUNCTION__ << ": " << endl); + linkDotGuts(nodep, LDS_PARAMED); + V3Global::dumpCheckGlobalTree("linkdotparam", 0, dumpTree() >= 3); +} + +void V3LinkDot::linkDotArrayed(AstNetlist* nodep) { + UINFO(2, __FUNCTION__ << ": " << endl); + linkDotGuts(nodep, LDS_ARRAYED); + V3Global::dumpCheckGlobalTree("linkdot", 0, dumpTree() >= 6); +} + +void V3LinkDot::linkDotScope(AstNetlist* nodep) { + UINFO(2, __FUNCTION__ << ": " << endl); + linkDotGuts(nodep, LDS_SCOPED); + V3Global::dumpCheckGlobalTree("linkdot", 0, dumpTree() >= 3); +} diff --git a/src/V3LinkDot.h b/src/V3LinkDot.h index 260c8cbcf..428f18904 100644 --- a/src/V3LinkDot.h +++ b/src/V3LinkDot.h @@ -28,32 +28,13 @@ enum VLinkDotStep : uint8_t { LDS_PRIMARY, LDS_PARAMED, LDS_ARRAYED, LDS_SCOPED }; class V3LinkDot final { -private: - static int debug(); static void linkDotGuts(AstNetlist* rootp, VLinkDotStep step); public: - static void linkDotPrimary(AstNetlist* nodep) { - UINFO(2, __FUNCTION__ << ": " << endl); - linkDotGuts(nodep, LDS_PRIMARY); - V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); - } - static void linkDotParamed(AstNetlist* nodep) { - UINFO(2, __FUNCTION__ << ": " << endl); - linkDotGuts(nodep, LDS_PARAMED); - V3Global::dumpCheckGlobalTree("linkdotparam", 0, - v3Global.opt.dumpTreeLevel(__FILE__) >= 3); - } - static void linkDotArrayed(AstNetlist* nodep) { - UINFO(2, __FUNCTION__ << ": " << endl); - linkDotGuts(nodep, LDS_ARRAYED); - V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); - } - static void linkDotScope(AstNetlist* nodep) { - UINFO(2, __FUNCTION__ << ": " << endl); - linkDotGuts(nodep, LDS_SCOPED); - V3Global::dumpCheckGlobalTree("linkdot", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); - } + static void linkDotPrimary(AstNetlist* nodep); + static void linkDotParamed(AstNetlist* nodep); + static void linkDotArrayed(AstNetlist* nodep); + static void linkDotScope(AstNetlist* nodep); }; #endif // Guard diff --git a/src/V3LinkInc.cpp b/src/V3LinkInc.cpp index 6726b8668..452105dd6 100644 --- a/src/V3LinkInc.cpp +++ b/src/V3LinkInc.cpp @@ -46,6 +46,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class LinkIncVisitor final : public VNVisitor { @@ -64,8 +66,6 @@ private: bool m_unsupportedHere = false; // Used to detect where it's not supported yet // METHODS - VL_DEBUG_FUNC; // Declare debug() - void insertBeforeStmt(AstNode* nodep, AstNode* newp) { // Return node that must be visited, if any // See also AstNode::addBeforeStmt; this predates that function @@ -295,5 +295,5 @@ public: void V3LinkInc::linkIncrements(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { LinkIncVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("linkinc", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("linkinc", 0, dumpTree() >= 3); } diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index 4bf20ebdc..e42e37987 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -40,6 +40,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class LinkJumpVisitor final : public VNVisitor { @@ -54,8 +56,6 @@ private: std::vector m_blockStack; // All begin blocks above current node // METHODS - VL_DEBUG_FUNC; // Declare debug() - AstJumpLabel* findAddLabel(AstNode* nodep, bool endOfIter) { // Put label under given node, and if WHILE optionally at end of iteration UINFO(4, "Create label for " << nodep << endl); @@ -292,5 +292,5 @@ public: void V3LinkJump::linkJump(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { LinkJumpVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("linkjump", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("linkjump", 0, dumpTree() >= 3); } diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp index 0baf289c8..b58b6f476 100644 --- a/src/V3LinkLValue.cpp +++ b/src/V3LinkLValue.cpp @@ -28,6 +28,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Link state, as a visitor of each AstNode @@ -41,9 +43,6 @@ private: VAccess m_setRefLvalue; // Set VarRefs to lvalues for pin assignments AstNodeFTask* m_ftaskp = nullptr; // Function or task we're inside - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITs // Result handing void visit(AstNodeVarRef* nodep) override { @@ -345,7 +344,7 @@ public: void V3LinkLValue::linkLValue(AstNetlist* nodep) { UINFO(4, __FUNCTION__ << ": " << endl); { LinkLValueVisitor{nodep, VAccess::NOCHANGE}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("linklvalue", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("linklvalue", 0, dumpTree() >= 6); } void V3LinkLValue::linkLValueSet(AstNode* nodep) { // Called by later link functions when it is known a node needs diff --git a/src/V3LinkLevel.cpp b/src/V3LinkLevel.cpp index 9c88973f6..cdb9b19c8 100644 --- a/src/V3LinkLevel.cpp +++ b/src/V3LinkLevel.cpp @@ -31,6 +31,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Levelizing class functions @@ -78,7 +80,7 @@ void V3LinkLevel::modSortByLevel() { UASSERT_OBJ(!v3Global.rootp()->modulesp(), v3Global.rootp(), "Unlink didn't work"); for (AstNodeModule* nodep : mods) v3Global.rootp()->addModulesp(nodep); UINFO(9, "modSortByLevel() done\n"); // Comment required for gcc4.6.3 / bug666 - V3Global::dumpCheckGlobalTree("cells", false, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("cells", false, dumpTree() >= 3); } void V3LinkLevel::timescaling(const ModVec& mods) { @@ -174,7 +176,7 @@ void V3LinkLevel::wrapTop(AstNetlist* rootp) { } } - V3Global::dumpCheckGlobalTree("wraptop", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("wraptop", 0, dumpTree() >= 6); } void V3LinkLevel::wrapTopCell(AstNetlist* rootp) { diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index 8dd4d8863..dcaf0a913 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -32,6 +32,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Link state, as a visitor of each AstNode @@ -62,8 +64,6 @@ private: VLifetime m_lifetime = VLifetime::STATIC; // Propagating lifetime // METHODS - VL_DEBUG_FUNC; // Declare debug() - void cleanFileline(AstNode* nodep) { if (!nodep->user2SetOnce()) { // Process once // We make all filelines unique per AstNode. This allows us to @@ -617,5 +617,5 @@ public: void V3LinkParse::linkParse(AstNetlist* rootp) { UINFO(4, __FUNCTION__ << ": " << endl); { LinkParseVisitor{rootp}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("linkparse", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("linkparse", 0, dumpTree() >= 6); } diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp index 38da0ea3f..03cb0abf0 100644 --- a/src/V3LinkResolve.cpp +++ b/src/V3LinkResolve.cpp @@ -36,6 +36,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Link state, as a visitor of each AstNode @@ -55,9 +57,6 @@ private: int m_senitemCvtNum = 0; // Temporary signal counter bool m_underGenerate = false; // Under GenFor/GenIf - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITs // TODO: Most of these visitors are here for historical reasons. // TODO: ExpectDecriptor can move to data type resolution, and the rest @@ -483,9 +482,6 @@ private: // STATE AstNodeModule* m_modp = nullptr; // Current module - // METHODS - VL_DEBUG_FUNC; // Declare debug() - // VISITs void visit(AstNetlist* nodep) override { // Iterate modules backwards, in bottom-up order. @@ -521,5 +517,5 @@ void V3LinkResolve::linkResolve(AstNetlist* rootp) { const LinkResolveVisitor visitor{rootp}; LinkBotupVisitor{rootp}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("linkresolve", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("linkresolve", 0, dumpTree() >= 6); } diff --git a/src/V3Localize.cpp b/src/V3Localize.cpp index 9a9bf51db..0d5977dcc 100644 --- a/src/V3Localize.cpp +++ b/src/V3Localize.cpp @@ -34,6 +34,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // LocalizeVisitor @@ -62,8 +64,6 @@ private: std::vector m_varScopeps; // List of variables to consider for localization // METHODS - VL_DEBUG_FUNC; // Declare debug() - bool isOptimizable(AstVarScope* nodep) { return !nodep->user1() || // Not marked as not optimizable, or ... (nodep->varp()->varType() == VVarType::BLOCKTEMP @@ -221,5 +221,5 @@ public: void V3Localize::localizeAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { LocalizeVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("localize", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("localize", 0, dumpTree() >= 6); } diff --git a/src/V3MergeCond.cpp b/src/V3MergeCond.cpp index 1f99e4570..6103c62b1 100644 --- a/src/V3MergeCond.cpp +++ b/src/V3MergeCond.cpp @@ -87,6 +87,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + namespace { //###################################################################### @@ -455,7 +457,6 @@ private: StmtPropertiesAllocator* m_stmtPropertiesp = nullptr; // METHODS - VL_DEBUG_FUNC; // Declare debug() // Function that processes a whole sub-tree void process(AstNode* nodep) { @@ -883,5 +884,5 @@ public: void V3MergeCond::mergeAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { MergeCondVisitor{nodep}; } - V3Global::dumpCheckGlobalTree("merge_cond", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("merge_cond", 0, dumpTree() >= 6); } diff --git a/src/V3Name.cpp b/src/V3Name.cpp index ca8fde8f1..8cb27838d 100644 --- a/src/V3Name.cpp +++ b/src/V3Name.cpp @@ -28,6 +28,8 @@ #include "V3Global.h" #include "V3LanguageWords.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Name state, as a visitor of each AstNode @@ -44,8 +46,6 @@ private: const AstNodeModule* m_modp = nullptr; // METHODS - VL_DEBUG_FUNC; // Declare debug() - void rename(AstNode* nodep, bool addPvt) { if (!nodep->user1()) { // Not already done if (addPvt) { @@ -144,5 +144,5 @@ public: void V3Name::nameAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { NameVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("name", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("name", 0, dumpTree() >= 6); } diff --git a/src/V3Number.cpp b/src/V3Number.cpp index 7459ce773..3dcfc88e2 100644 --- a/src/V3Number.cpp +++ b/src/V3Number.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + constexpr int MAX_SPRINTF_DOUBLE_SIZE = 1100; // Maximum characters with a sprintf %e/%f/%g (really 1079) diff --git a/src/V3Options.cpp b/src/V3Options.cpp index 53a0e37e1..c662cc59a 100644 --- a/src/V3Options.cpp +++ b/src/V3Options.cpp @@ -43,6 +43,7 @@ #include #include #include +#include #include "config_rev.h" @@ -51,6 +52,8 @@ #endif // clang-format on +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // V3 Internal state @@ -1069,7 +1072,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char DECL_OPTION("-debug", CbCall, [this]() { setDebugMode(3); }); DECL_OPTION("-debugi", CbVal, [this](int v) { setDebugMode(v); }); DECL_OPTION("-debugi-", CbPartialMatchVal, [this](const char* optp, const char* valp) { - setDebugSrcLevel(optp, std::atoi(valp)); + m_debugLevel[optp] = std::atoi(valp); }); DECL_OPTION("-debug-abort", CbCall, V3Error::vlAbort) @@ -1090,15 +1093,11 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char DECL_OPTION("-debug-sigsegv", CbCall, throwSigsegv).undocumented(); // See also --debug-abort DECL_OPTION("-decoration", OnOff, &m_decoration); DECL_OPTION("-dpi-hdr-only", OnOff, &m_dpiHdrOnly); - DECL_OPTION("-dump-defines", OnOff, &m_dumpDefines); - DECL_OPTION("-dump-tree", CbOnOff, - [this](bool flag) { m_dumpTree = flag ? 3 : 0; }); // Also see --dump-treei - DECL_OPTION("-dump-tree-addrids", OnOff, &m_dumpTreeAddrids); - DECL_OPTION("-dump-treei", Set, &m_dumpTree); - DECL_OPTION("-dump-treei-", CbPartialMatchVal, [this](const char* optp, const char* valp) { - setDumpTreeLevel(optp, std::atoi(valp)); + DECL_OPTION("-dump-", CbPartialMatch, [this](const char* optp) { m_dumpLevel[optp] = 3; }); + DECL_OPTION("-no-dump-", CbPartialMatch, [this](const char* optp) { m_dumpLevel[optp] = 0; }); + DECL_OPTION("-dumpi-", CbPartialMatchVal, [this](const char* optp, const char* valp) { + m_dumpLevel[optp] = std::atoi(valp); }); - DECL_OPTION("-E", Set, &m_preprocOnly); DECL_OPTION("-error-limit", CbVal, static_cast(&V3Error::errorLimit)); DECL_OPTION("-exe", OnOff, &m_exe); @@ -1807,52 +1806,42 @@ V3Options::~V3Options() { VL_DO_CLEAR(delete m_impp, m_impp = nullptr); } void V3Options::setDebugMode(int level) { V3Error::debugDefault(level); - if (!m_dumpTree) m_dumpTree = 3; // Don't override if already set. + if (!m_dumpLevel.count("tree")) m_dumpLevel["tree"] = 3; // Don't override if already set. m_stats = true; m_debugCheck = true; cout << "Starting " << version() << endl; } -void V3Options::setDebugSrcLevel(const string& srcfile, int level) { - const auto iter = m_debugSrcs.find(srcfile); - if (iter != m_debugSrcs.end()) { - iter->second = level; - } else { - m_debugSrcs.emplace(srcfile, level); - } +unsigned V3Options::debugLevel(const string& tag) const { + const auto iter = m_debugLevel.find(tag); + return iter != m_debugLevel.end() ? iter->second : V3Error::debugDefault(); } -int V3Options::debugSrcLevel(const string& srcfile_path, int default_level) { +unsigned V3Options::debugSrcLevel(const string& srcfile_path) const { // For simplicity, calling functions can just use __FILE__ for srcfile. - // That means though we need to cleanup the filename from ../Foo.cpp -> Foo - const string srcfile = V3Os::filenameNonDirExt(srcfile_path); - const auto iter = m_debugSrcs.find(srcfile); - if (iter != m_debugSrcs.end()) { - return iter->second; - } else { - return default_level; - } + // That means we need to strip the filenames: ../Foo.cpp -> Foo + return debugLevel(V3Os::filenameNonDirExt(srcfile_path)); } -void V3Options::setDumpTreeLevel(const string& srcfile, int level) { - const auto iter = m_dumpTrees.find(srcfile); - if (iter != m_dumpTrees.end()) { - iter->second = level; - } else { - m_dumpTrees.emplace(srcfile, level); - } +unsigned V3Options::dumpLevel(const string& tag) const { + const auto iter = m_dumpLevel.find(tag); + return iter != m_dumpLevel.end() ? iter->second : 0; } -int V3Options::dumpTreeLevel(const string& srcfile_path) { +unsigned V3Options::dumpSrcLevel(const string& srcfile_path) const { // For simplicity, calling functions can just use __FILE__ for srcfile. - // That means though we need to cleanup the filename from ../Foo.cpp -> Foo - const string srcfile = V3Os::filenameNonDirExt(srcfile_path); - const auto iter = m_dumpTrees.find(srcfile); - if (iter != m_dumpTrees.end()) { - return iter->second; - } else { - return m_dumpTree; + // That means we need to strip the filenames: ../Foo.cpp -> Foo + return dumpLevel(V3Os::filenameNonDirExt(srcfile_path)); +} + +bool V3Options::dumpTreeAddrids() const { + static int level = -1; + if (VL_UNLIKELY(level < 0)) { + const unsigned value = dumpLevel("tree-addrids"); + if (!available()) return value > 0; + level = static_cast(value); } + return level > 0; } void V3Options::optimize(int level) { diff --git a/src/V3Options.h b/src/V3Options.h index ec6e6203b..6f1cf1eae 100644 --- a/src/V3Options.h +++ b/src/V3Options.h @@ -188,7 +188,7 @@ class V3Options final { public: private: // TYPES - using DebugSrcMap = std::map; + using DebugLevelMap = std::map; // MEMBERS (general options) V3OptionsImp* m_impp; // Slow hidden options @@ -206,8 +206,8 @@ private: V3StringSet m_noClockers; // argument: Verilog -noclk signals V3StringList m_vFiles; // argument: Verilog files to read V3StringList m_forceIncs; // argument: -FI - DebugSrcMap m_debugSrcs; // argument: --debugi-= - DebugSrcMap m_dumpTrees; // argument: --dump-treei-= + DebugLevelMap m_debugLevel; // argument: --debugi- + DebugLevelMap m_dumpLevel; // argument: --dumpi- std::map m_parameters; // Parameters std::map m_hierBlocks; // main switch: --hierarchical-block @@ -238,8 +238,6 @@ private: bool m_debugSelfTest = false; // main switch: --debug-self-test bool m_decoration = true; // main switch: --decoration bool m_dpiHdrOnly = false; // main switch: --dpi-hdr-only - bool m_dumpDefines = false; // main switch: --dump-defines - bool m_dumpTreeAddrids = false; // main switch: --dump-tree-addrids bool m_exe = false; // main switch: --exe bool m_flatten = false; // main switch: --flatten bool m_hierarchical = false; // main switch: --hierarchical @@ -286,7 +284,6 @@ private: int m_buildJobs = -1; // main switch: --build-jobs, -j int m_convergeLimit = 100; // main switch: --converge-limit int m_coverageMaxWidth = 256; // main switch: --coverage-max-width - int m_dumpTree = 0; // main switch: --dump-tree int m_expandLimit = 64; // main switch: --expand-limit int m_gateStmts = 100; // main switch: --gate-stmts int m_hierChild = 0; // main switch: --hierarchical-child @@ -395,10 +392,10 @@ public: V3Options(); ~V3Options(); void setDebugMode(int level); - void setDebugSrcLevel(const string& srcfile, int level); - int debugSrcLevel(const string& srcfile_path, int default_level = V3Error::debugDefault()); - void setDumpTreeLevel(const string& srcfile, int level); - int dumpTreeLevel(const string& srcfile_path); + unsigned debugLevel(const string& tag) const; + unsigned debugSrcLevel(const string& srcfile_path) const; + unsigned dumpLevel(const string& tag) const; + unsigned dumpSrcLevel(const string& srcfile_path) const; // METHODS void addCppFile(const string& filename); @@ -452,7 +449,7 @@ public: bool debugSelfTest() const { return m_debugSelfTest; } bool decoration() const { return m_decoration; } bool dpiHdrOnly() const { return m_dpiHdrOnly; } - bool dumpDefines() const { return m_dumpDefines; } + bool dumpDefines() const { return m_dumpLevel.count("defines") && m_dumpLevel.at("defines"); } bool exe() const { return m_exe; } bool flatten() const { return m_flatten; } bool gmake() const { return m_gmake; } @@ -493,8 +490,7 @@ public: int buildJobs() const { return m_buildJobs; } int convergeLimit() const { return m_convergeLimit; } int coverageMaxWidth() const { return m_coverageMaxWidth; } - int dumpTree() const { return m_dumpTree; } - bool dumpTreeAddrids() const { return m_dumpTreeAddrids; } + bool dumpTreeAddrids() const; int expandLimit() const { return m_expandLimit; } int gateStmts() const { return m_gateStmts; } int ifDepth() const { return m_ifDepth; } diff --git a/src/V3Order.cpp b/src/V3Order.cpp index 0c8be135e..0a28b981f 100644 --- a/src/V3Order.cpp +++ b/src/V3Order.cpp @@ -103,6 +103,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Order information stored under each AstNode::user1p()... @@ -183,7 +185,6 @@ class OrderBuildVisitor final : public VNVisitor { std::function m_readTriggersCombLogic; // METHODS - VL_DEBUG_FUNC; // Declare debug() void iterateLogic(AstNode* nodep) { UASSERT_OBJ(!m_logicVxp, nodep, "Should not nest"); @@ -454,11 +455,7 @@ class OrderBuildVisitor final : public VNVisitor { OrderBuildVisitor(AstNetlist* /*nodep*/, const std::vector& coll, const std::unordered_map& trigToSen) : m_trigToSen{trigToSen} { - - // Enable debugging (3 is default if global debug; we want acyc debugging) - if (debug()) m_graphp->debug(5); - - // Build the rest of the graph + // Build the graph for (const V3Sched::LogicByScope* const lbsp : coll) { for (const auto& pair : *lbsp) { m_scopep = pair.first; @@ -845,7 +842,6 @@ class OrderProcess final : VNDeleter { std::map, unsigned> m_funcNums; // Function ordinals // METHODS - VL_DEBUG_FUNC; // Declare debug() void process(bool multiThreaded); void processDomains(); @@ -1432,7 +1428,7 @@ void OrderProcess::processMTasks() { void OrderProcess::process(bool multiThreaded) { // Dump data - m_graph.dumpDotFilePrefixed(m_tag + "_orderg_pre"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed(m_tag + "_orderg_pre"); // Break cycles. Each strongly connected subgraph (including cutable // edges) will have its own color, and corresponds to a loop in the @@ -1440,29 +1436,27 @@ void OrderProcess::process(bool multiThreaded) { // edges are actually still there, just with weight 0). UINFO(2, " Acyclic & Order...\n"); m_graph.acyclic(&V3GraphEdge::followAlwaysTrue); - m_graph.dumpDotFilePrefixed(m_tag + "_orderg_acyc"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed(m_tag + "_orderg_acyc"); // Assign ranks so we know what to follow // Then, sort vertices and edges by that ordering m_graph.order(); - m_graph.dumpDotFilePrefixed(m_tag + "_orderg_order"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed(m_tag + "_orderg_order"); // Assign logic vertices to new domains UINFO(2, " Domains...\n"); processDomains(); - m_graph.dumpDotFilePrefixed(m_tag + "_orderg_domain"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed(m_tag + "_orderg_domain"); - if (debug() && v3Global.opt.dumpTree()) processEdgeReport(); + if (dump()) processEdgeReport(); if (!multiThreaded) { UINFO(2, " Construct Move Graph...\n"); processMoveBuildGraph(); - if (debug() >= 4) { - // Different prefix (ordermv) as it's not the same graph - m_pomGraph.dumpDotFilePrefixed(m_tag + "_ordermv_start"); - } + // Different prefix (ordermv) as it's not the same graph + if (dumpGraph() >= 4) m_pomGraph.dumpDotFilePrefixed(m_tag + "_ordermv_start"); m_pomGraph.removeRedundantEdges(&V3GraphEdge::followAlwaysTrue); - if (debug() >= 4) m_pomGraph.dumpDotFilePrefixed(m_tag + "_ordermv_simpl"); + if (dumpGraph() >= 4) m_pomGraph.dumpDotFilePrefixed(m_tag + "_ordermv_simpl"); UINFO(2, " Move...\n"); processMove(); @@ -1472,7 +1466,7 @@ void OrderProcess::process(bool multiThreaded) { } // Dump data - m_graph.dumpDotFilePrefixed(m_tag + "_orderg_done"); + if (dumpGraph()) m_graph.dumpDotFilePrefixed(m_tag + "_orderg_done"); } //###################################################################### diff --git a/src/V3Os.cpp b/src/V3Os.cpp index 2abc200c0..32d78f09c 100644 --- a/src/V3Os.cpp +++ b/src/V3Os.cpp @@ -29,8 +29,13 @@ #include "verilatedos.h" // Limited V3 headers here - this is a base class for Vlc etc -#include "V3String.h" #include "V3Os.h" +#include "V3String.h" + +#ifndef V3ERROR_NO_GLOBAL_ +#include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; +#endif #include #include // PATH_MAX (especially on FreeBSD) @@ -38,6 +43,7 @@ #include #include #include + #include #include diff --git a/src/V3Param.cpp b/src/V3Param.cpp index 4c372895e..e4719d3f3 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -65,6 +65,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Hierarchical block and parameter db (modules without parameter is also handled) @@ -88,7 +90,6 @@ class ParameterizedHierBlocks final { m_modParams; // Parameter variables of hierarchical blocks // METHODS - VL_DEBUG_FUNC; // Declare debug() public: ParameterizedHierBlocks(const V3HierBlockOptSet& hierOpts, AstNetlist* nodep) { @@ -270,7 +271,6 @@ class ParamProcessor final { std::map m_defaultParameterValues; // METHODS - VL_DEBUG_FUNC; // Declare debug() static void makeSmallNames(AstNodeModule* modp) { std::vector usedLetter; @@ -888,7 +888,6 @@ class ParamVisitor final : public VNVisitor { std::unordered_map> m_parentps; // METHODS - VL_DEBUG_FUNC; // Declare debug() void visitCells(AstNodeModule* nodep) { UASSERT_OBJ(!m_iterateModule, nodep, "Should not nest"); @@ -1280,5 +1279,5 @@ public: void V3Param::param(AstNetlist* rootp) { UINFO(2, __FUNCTION__ << ": " << endl); { ParamVisitor{rootp}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("param", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("param", 0, dumpTree() >= 6); } diff --git a/src/V3ParseGrammar.cpp b/src/V3ParseGrammar.cpp index 5655a1d96..984544d82 100644 --- a/src/V3ParseGrammar.cpp +++ b/src/V3ParseGrammar.cpp @@ -18,6 +18,8 @@ #include "V3Ast.h" // This must be before V3ParseBison.cpp, as we don't want #defines to conflict +VL_DEFINE_DEBUG_FUNCTIONS; + //====================================================================== // The guts come from bison output diff --git a/src/V3ParseImp.cpp b/src/V3ParseImp.cpp index db0a0f422..cb26c7026 100644 --- a/src/V3ParseImp.cpp +++ b/src/V3ParseImp.cpp @@ -38,6 +38,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //====================================================================== // Globals @@ -58,7 +60,7 @@ V3ParseImp::~V3ParseImp() { if (debug() >= 9) { UINFO(0, "~V3ParseImp\n"); - symp()->dump(cout, "-vpi: "); + symp()->dumpSelf(cout, "-vpi: "); } } @@ -497,7 +499,7 @@ void V3ParseImp::tokenPipelineSym() { const VSymEnt* foundp; if (const VSymEnt* const look_underp = V3ParseImp::parsep()->symp()->nextId()) { UINFO(7, " tokenPipelineSym: next id lookup forced under " << look_underp << endl); - // if (debug() >= 7) V3ParseImp::parsep()->symp()->dump(cout, " -symtree: "); + // if (debug() >= 7) V3ParseImp::parsep()->symp()->dumpSelf(cout, " -symtree: "); foundp = look_underp->findIdFallback(*(yylval.strp)); // "consume" it. Must set again if want another token under temp scope V3ParseImp::parsep()->symp()->nextId(nullptr); @@ -505,7 +507,7 @@ void V3ParseImp::tokenPipelineSym() { UINFO(7, " tokenPipelineSym: find upward " << V3ParseImp::parsep()->symp()->symCurrentp() << " for '" << *(yylval.strp) << "'" << endl); - // if (debug()>=9) V3ParseImp::parsep()->symp()->symCurrentp()->dump(cout, + // if (debug()>=9) V3ParseImp::parsep()->symp()->symCurrentp()->dumpSelf(cout, // " -findtree: ", true); foundp = V3ParseImp::parsep()->symp()->symCurrentp()->findIdFallback(*(yylval.strp)); } diff --git a/src/V3ParseImp.h b/src/V3ParseImp.h index 54a241365..54c4ab080 100644 --- a/src/V3ParseImp.h +++ b/src/V3ParseImp.h @@ -161,25 +161,10 @@ class V3ParseImp final { VTimescale m_timeLastUnit; // Last `timescale's unit public: + VL_DEFINE_DEBUG_FUNCTIONS; // Note these are an exception to using the filename as the debug type - static int debugBison() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel("bison"); - return level; - } - static int debugFlex() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel("flex"); - return level; - } - static int debug() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) { - level = std::max(std::max(debugBison(), debugFlex()), - v3Global.opt.debugSrcLevel("V3ParseImp")); - } - return level; - } + VL_DEFINE_DEBUG(Bison); // Define 'unsigned debugBison()' + VL_DEFINE_DEBUG(Flex); // Define 'unsigned debugFlex()' // Functions called by lex rules: int yylexThis(); diff --git a/src/V3ParseSym.h b/src/V3ParseSym.h index 87edaef5a..b9e0d26e3 100644 --- a/src/V3ParseSym.h +++ b/src/V3ParseSym.h @@ -55,6 +55,9 @@ public: private: // METHODS + + VL_DEFINE_DEBUG_FUNCTIONS; + static VSymEnt* getTable(AstNode* nodep) { UASSERT_OBJ(nodep->user4p(), nodep, "Current symtable not found"); return nodep->user4u().toSymEnt(); @@ -115,7 +118,7 @@ public: if (VL_UNCOVERABLE(symCurrentp()->nodep() != nodep)) { // LCOV_EXCL_START if (debug()) { showUpward(); - dump(cout, "-mism: "); + dumpSelf(cout, "-mism: "); } nodep->v3fatalSrc("Symbols suggest ending " << symCurrentp()->nodep()->prettyTypeName() << " but parser thinks ending " @@ -133,7 +136,7 @@ public: } UINFO(1, "ParseSym Current: " << symCurrentp()->nodep() << endl); } // LCOV_EXCL_STOP - void dump(std::ostream& os, const string& indent = "") { m_syms.dump(os, indent); } + void dumpSelf(std::ostream& os, const string& indent = "") { m_syms.dumpSelf(os, indent); } AstNode* findEntUpward(const string& name) const { // Lookup the given string as an identifier, return type of the id, scanning upward VSymEnt* const foundp = symCurrentp()->findIdFallback(name); diff --git a/src/V3Partition.cpp b/src/V3Partition.cpp index 4eb861a51..348cbb4b9 100644 --- a/src/V3Partition.cpp +++ b/src/V3Partition.cpp @@ -41,6 +41,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + class LogicMTask; class MTaskEdge; class MergeCandidate; @@ -390,7 +392,6 @@ public: static void dumpCpFilePrefixed(const V3Graph* graphp, const string& nameComment); private: - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(LogicMTask); }; @@ -809,7 +810,6 @@ public: } private: - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(PartParallelismEst); }; @@ -1053,7 +1053,6 @@ public: } private: - VL_DEBUG_FUNC; VL_UNCOPYABLE(PartPropagateCp); }; @@ -1823,7 +1822,6 @@ public: } private: - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(PartContraction); }; @@ -1837,8 +1835,6 @@ private: bool m_hasDpiHazard = false; // Found a DPI import call. bool m_tracingCall = false; // Iterating into a CCall to a CFunc // METHODS - VL_DEBUG_FUNC; - void visit(AstCFunc* nodep) override { if (!m_tracingCall) return; m_tracingCall = false; @@ -2150,7 +2146,6 @@ public: private: VL_UNCOPYABLE(PartFixDataHazards); - VL_DEBUG_FUNC; }; //###################################################################### @@ -2472,7 +2467,7 @@ public: } } - if (debug() >= 4) schedule.dumpDotFilePrefixedAlways(mtaskGraph, "schedule"); + if (dumpGraph() >= 4) schedule.dumpDotFilePrefixedAlways(mtaskGraph, "schedule"); return schedule; } @@ -2530,7 +2525,6 @@ public: } private: - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(PartPackMTasks); }; @@ -2538,7 +2532,7 @@ private: // V3Partition implementation void V3Partition::debugMTaskGraphStats(const V3Graph* graphp, const string& stage) { - if (!debug()) return; + if (!debug() && !dump() && !dumpGraph()) return; UINFO(4, "\n"); UINFO(4, " Stats for " << stage << endl); @@ -2575,7 +2569,7 @@ void V3Partition::debugMTaskGraphStats(const V3Graph* graphp, const string& stag if (mtaskCount < 1000) { string filePrefix("ordermv_"); filePrefix += stage; - if (debug() >= 4) graphp->dumpDotFilePrefixedAlways(filePrefix); + if (dumpGraph() >= 4) graphp->dumpDotFilePrefixedAlways(filePrefix); } // Look only at the cost of each mtask, neglect communication cost. @@ -2750,9 +2744,7 @@ void V3Partition::go(V3Graph* mtasksp) { // For debug: print out the longest critical path. This allows us to // verify that the costs look reasonable, that we aren't combining // nodes that should probably be split, etc. - if (v3Global.opt.dumpTreeLevel(__FILE__) >= 3) { - LogicMTask::dumpCpFilePrefixed(mtasksp, "cp"); - } + if (dump() >= 3) LogicMTask::dumpCpFilePrefixed(mtasksp, "cp"); // Merge nodes that could present data hazards; see comment within. { diff --git a/src/V3Partition.h b/src/V3Partition.h index 460965ae5..72a9ed43f 100644 --- a/src/V3Partition.h +++ b/src/V3Partition.h @@ -70,7 +70,6 @@ public: private: uint32_t setupMTaskDeps(V3Graph* mtasksp); - VL_DEBUG_FUNC; // Declare debug() VL_UNCOPYABLE(V3Partition); }; diff --git a/src/V3PreLex.h b/src/V3PreLex.h index 8ce783957..4389c506d 100644 --- a/src/V3PreLex.h +++ b/src/V3PreLex.h @@ -225,9 +225,8 @@ public: // Used only by V3PreLex.cpp and V3PreProc.cpp // Called by VPreStream void streamDepthAdd(int delta) { m_streamDepth += delta; } int streamDepth() const { return m_streamDepth; } - /// Utility - static int debug(); - static void debug(int level); + // Utility + static void setYYDebug(bool on); static string cleanDbgStrg(const string& in); private: diff --git a/src/V3PreLex.l b/src/V3PreLex.l index a83a55db9..bc1dda03d 100644 --- a/src/V3PreLex.l +++ b/src/V3PreLex.l @@ -462,11 +462,8 @@ void V3PreLex::pushStateIncFilename() { yymore(); } -void V3PreLex::debug(int level) { - yy_flex_debug = level; // Use --debugi-V3PreShell, if level<5 this level is 0 -} -int V3PreLex::debug() { - return yy_flex_debug; } +void V3PreLex::setYYDebug(bool on) { + yy_flex_debug = static_cast(on); } int V3PreLex::lex() { V3PreLex::s_currentLexp = this; // Tell parser where to get/put data diff --git a/src/V3PreProc.cpp b/src/V3PreProc.cpp index 684733a6e..6aadb69f7 100644 --- a/src/V3PreProc.cpp +++ b/src/V3PreProc.cpp @@ -33,6 +33,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //====================================================================== // Build in LEX script @@ -112,8 +114,6 @@ public: using DefinesMap = std::map; using StrList = VInFilter::StrList; - // debug() -> see V3PreShellImp::debug; use --debugi-V3PreShell - // Defines list DefinesMap m_defines; ///< Map of defines @@ -259,10 +259,7 @@ public: string removeDefines(const string& text) override; // Remove defines in a text string // CONSTRUCTORS - V3PreProcImp() { - m_debug = 0; - m_states.push(ps_TOP); - } + V3PreProcImp() { m_states.push(ps_TOP); } void configure(FileLine* filelinep) { // configure() separate from constructor to avoid calling abstract functions m_preprocp = this; // Silly, but to make code more similar to Verilog-Perl @@ -273,7 +270,6 @@ public: m_lexp->m_keepComments = keepComments(); m_lexp->m_keepWhitespace = keepWhitespace(); m_lexp->m_pedantic = pedantic(); - debug(debug()); // Set lexer debug via V3PreProc::debug() method } ~V3PreProcImp() override { if (m_lexp) VL_DO_CLEAR(delete m_lexp, m_lexp = nullptr); @@ -490,12 +486,6 @@ void V3PreProcImp::comment(const string& text) { //************************************************************************* // VPreProc Methods. -void V3PreProc::debug(int level) { - m_debug = level; - V3PreProcImp* idatap = static_cast(this); - if (idatap->m_lexp) idatap->m_lexp->debug(debug() >= 5 ? debug() : 0); -} - FileLine* V3PreProc::fileline() { const V3PreProcImp* idatap = static_cast(this); return idatap->m_lexp->m_tokFilelinep; @@ -777,6 +767,7 @@ string V3PreProcImp::defineSubst(VDefineRef* refp) { void V3PreProcImp::openFile(FileLine*, VInFilter* filterp, const string& filename) { // Open a new file, possibly overriding the current one which is active. if (m_incError) return; + m_lexp->setYYDebug(debug() >= 5); V3File::addSrcDepend(filename); // Read a list with the whole file. diff --git a/src/V3PreProc.h b/src/V3PreProc.h index f446a4f35..a14562a32 100644 --- a/src/V3PreProc.h +++ b/src/V3PreProc.h @@ -39,8 +39,7 @@ class V3PreProc VL_NOT_FINAL { // After creating, call open(), then getline() in a loop. The class will to the rest... protected: - // STATE - int m_debug; // Debugging + VL_DEFINE_DEBUG_FUNCTIONS; public: // CONSTANTS @@ -61,9 +60,6 @@ public: virtual bool isEof() const = 0; // Return true on EOF. virtual void insertUnreadback(const string& text) = 0; - int debug() const { return m_debug; } - void debug(int level); - FileLine* fileline(); ///< File/Line number for last getline call // CONTROL METHODS @@ -99,7 +95,7 @@ public: protected: // CONSTRUCTORS - V3PreProc() { m_debug = 0; } + V3PreProc() {} void configure(FileLine* fl); public: diff --git a/src/V3PreShell.cpp b/src/V3PreShell.cpp index f6e325f29..0502535af 100644 --- a/src/V3PreShell.cpp +++ b/src/V3PreShell.cpp @@ -28,6 +28,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class V3PreShellImp final { @@ -41,21 +43,11 @@ protected: //--------------------------------------- // METHODS - static int debug(bool reset = false) { - static int level = -1; - if (VL_UNLIKELY(level < 0) || reset) { - level = v3Global.opt.debugSrcLevel(__FILE__); - if (s_preprocp) s_preprocp->debug(debug()); - } - return level; - } - void boot() { // Create the implementation pointer if (!s_preprocp) { FileLine* const cmdfl = new FileLine(FileLine::commandLineFilename()); s_preprocp = V3PreProc::createPreProc(cmdfl); - s_preprocp->debug(debug()); // Default defines FileLine* const prefl = new FileLine(FileLine::builtInFilename()); s_preprocp->defineCmdLine(prefl, "VERILATOR", "1"); // LEAK_OK @@ -88,8 +80,6 @@ protected: bool preproc(FileLine* fl, const string& modname, VInFilter* filterp, V3ParseImp* parsep, const string& errmsg) { // "" for no error - debug(true); // Recheck if debug on - first check was before command line passed - // Preprocess the given module, putting output in vppFilename UINFONL(1, " Preprocessing " << modname << endl); diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp index 54b1324c4..48f8c5c31 100644 --- a/src/V3Premit.cpp +++ b/src/V3Premit.cpp @@ -36,6 +36,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + constexpr int STATIC_CONST_MIN_WIDTH = 256; // Minimum size to extract to static constant //###################################################################### @@ -62,8 +64,6 @@ private: VDouble0 m_extractedToConstPool; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() - bool assignNoTemp(AstNodeAssign* nodep) { return (VN_IS(nodep->lhsp(), VarRef) && !AstVar::scVarRecurse(nodep->lhsp()) && VN_IS(nodep->rhsp(), Const)); @@ -394,5 +394,5 @@ public: void V3Premit::premitAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { PremitVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("premit", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("premit", 0, dumpTree() >= 3); } diff --git a/src/V3ProtectLib.cpp b/src/V3ProtectLib.cpp index 734695c2f..7d04a1fc8 100644 --- a/src/V3ProtectLib.cpp +++ b/src/V3ProtectLib.cpp @@ -26,6 +26,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // ProtectLib top-level visitor diff --git a/src/V3Randomize.cpp b/src/V3Randomize.cpp index 7efc30c0f..3677a1071 100644 --- a/src/V3Randomize.cpp +++ b/src/V3Randomize.cpp @@ -31,6 +31,8 @@ #include "V3Ast.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Visitor that marks classes needing a randomize() method @@ -47,8 +49,6 @@ private: BaseToDerivedMap m_baseToDerivedMap; // Mapping from base classes to classes that extend them // METHODS - VL_DEBUG_FUNC; - void markMembers(AstClass* nodep) { for (auto* classp = nodep; classp; classp = classp->extendsp() ? classp->extendsp()->classp() : nullptr) { @@ -127,8 +127,6 @@ private: size_t m_enumValueTabCount = 0; // Number of tables with enum values created // METHODS - VL_DEBUG_FUNC; - AstVar* enumValueTabp(AstEnumDType* nodep) { if (nodep->user2p()) return VN_AS(nodep->user2p(), Var); UINFO(9, "Construct Venumvaltab " << nodep << endl); @@ -258,7 +256,7 @@ void V3Randomize::randomizeNetlist(AstNetlist* nodep) { const RandomizeMarkVisitor markVisitor{nodep}; RandomizeVisitor{nodep}; } - V3Global::dumpCheckGlobalTree("randomize", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("randomize", 0, dumpTree() >= 3); } AstFunc* V3Randomize::newRandomizeFunc(AstClass* nodep) { diff --git a/src/V3Reloop.cpp b/src/V3Reloop.cpp index 4e8690b3e..db48e6b2e 100644 --- a/src/V3Reloop.cpp +++ b/src/V3Reloop.cpp @@ -40,6 +40,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class ReloopVisitor final : public VNVisitor { @@ -66,7 +68,6 @@ private: uint32_t m_mgIndexHi = 0; // Merge range // METHODS - VL_DEBUG_FUNC; // Declare debug() static AstVar* findCreateVarTemp(FileLine* fl, AstCFunc* cfuncp) { AstVar* varp = VN_AS(cfuncp->user1p(), Var); @@ -269,5 +270,5 @@ public: void V3Reloop::reloopAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ReloopVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("reloop", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("reloop", 0, dumpTree() >= 6); } diff --git a/src/V3Sched.cpp b/src/V3Sched.cpp index df3e5f0a4..dc3ac1c2c 100644 --- a/src/V3Sched.cpp +++ b/src/V3Sched.cpp @@ -47,7 +47,7 @@ #include "V3SenExprBuilder.h" #include "V3Stats.h" -#include +VL_DEFINE_DEBUG_FUNCTIONS; namespace V3Sched { @@ -1035,7 +1035,7 @@ void schedule(AstNetlist* netlistp) { netlistp->dpiExportTriggerp(nullptr); - V3Global::dumpCheckGlobalTree("sched", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("sched", 0, dumpTree() >= 3); } } // namespace V3Sched diff --git a/src/V3SchedAcyclic.cpp b/src/V3SchedAcyclic.cpp index ddce7539e..6818761a5 100644 --- a/src/V3SchedAcyclic.cpp +++ b/src/V3SchedAcyclic.cpp @@ -50,12 +50,14 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + namespace V3Sched { namespace { -//############################################################################## -// Data structures (graph types) +// ############################################################################## +// Data structures (graph types) class LogicVertex final : public V3GraphVertex { AstNode* const m_logicp; // The logic node this vertex represents @@ -396,7 +398,7 @@ LogicByScope breakCycles(AstNetlist* netlistp, LogicByScope& combinationalLogic) if (graphp->empty()) return LogicByScope{}; // Dump for debug - if (debug() > 6) graphp->dumpDotFilePrefixed("sched-comb-cycles"); + if (dumpGraph() >= 6) graphp->dumpDotFilePrefixed("sched-comb-cycles"); // Make graph acyclic by cutting some edges. Note: This also colors strongly connected // components which reportCycles uses to print each SCCs separately. diff --git a/src/V3SchedPartition.cpp b/src/V3SchedPartition.cpp index fe0a08a6a..573a89993 100644 --- a/src/V3SchedPartition.cpp +++ b/src/V3SchedPartition.cpp @@ -48,6 +48,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + namespace V3Sched { namespace { @@ -133,8 +135,6 @@ class SchedGraphBuilder final : public VNVisitor { // The DPI export trigger variable, if any AstVarScope* const m_dpiExportTriggerp = v3Global.rootp()->dpiExportTriggerp(); - VL_DEBUG_FUNC; - SchedVarVertex* getVarVertex(AstVarScope* vscp) const { if (!vscp->user1p()) { SchedVarVertex* const vtxp = new SchedVarVertex{m_graphp, vscp}; @@ -341,11 +341,11 @@ LogicRegions partition(LogicByScope& clockedLogic, LogicByScope& combinationalLo // Build the graph const std::unique_ptr graphp = SchedGraphBuilder::build(clockedLogic, combinationalLogic, hybridLogic); - if (debug() > 6) graphp->dumpDotFilePrefixed("sched"); + if (dumpGraph() >= 6) graphp->dumpDotFilePrefixed("sched"); // Partition into Active and NBA regions colorActiveRegion(*(graphp.get())); - if (debug() > 6) graphp->dumpDotFilePrefixed("sched-partitioned", true); + if (dumpGraph() >= 6) graphp->dumpDotFilePrefixed("sched-partitioned", true); LogicRegions result; diff --git a/src/V3SchedReplicate.cpp b/src/V3SchedReplicate.cpp index 347cc6a66..81a1ff1fb 100644 --- a/src/V3SchedReplicate.cpp +++ b/src/V3SchedReplicate.cpp @@ -42,7 +42,7 @@ #include "V3Graph.h" #include "V3Sched.h" -#include +VL_DEFINE_DEBUG_FUNCTIONS; namespace V3Sched { @@ -261,13 +261,13 @@ LogicReplicas replicateLogic(LogicRegions& logicRegionsRegions) { // Build the dataflow (dependency) graph const std::unique_ptr graphp = buildGraph(logicRegionsRegions); // Dump for debug - graphp->dumpDotFilePrefixed("sched-replicate"); + if (dumpGraph() >= 6) graphp->dumpDotFilePrefixed("sched-replicate"); // Propagate driving region flags for (V3GraphVertex* vtxp = graphp->verticesBeginp(); vtxp; vtxp = vtxp->verticesNextp()) { propagateDrivingRegions(static_cast(vtxp)); } // Dump for debug - graphp->dumpDotFilePrefixed("sched-replicate-propagated"); + if (dumpGraph() >= 6) graphp->dumpDotFilePrefixed("sched-replicate-propagated"); // Replicate the necessary logic return replicate(graphp.get()); } diff --git a/src/V3SchedTiming.cpp b/src/V3SchedTiming.cpp index 93f27062d..cc426ddd2 100644 --- a/src/V3SchedTiming.cpp +++ b/src/V3SchedTiming.cpp @@ -28,10 +28,13 @@ #include "verilatedos.h" #include "V3EmitCBase.h" +#include "V3Error.h" #include "V3Sched.h" #include +VL_DEFINE_DEBUG_FUNCTIONS; + namespace V3Sched { //============================================================================ @@ -371,7 +374,7 @@ void transformForks(AstNetlist* const netlistp) { ~ForkVisitor() override = default; }; ForkVisitor{netlistp}; - V3Global::dumpCheckGlobalTree("sched_forks", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("sched_forks", 0, dumpTree() >= 6); } } // namespace V3Sched diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp index 8077d2959..c0694e2ab 100644 --- a/src/V3Scope.cpp +++ b/src/V3Scope.cpp @@ -34,6 +34,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Scope class functions @@ -62,7 +64,6 @@ private: m_varRefScopes; // Varrefs-in-scopes needing fixup when done // METHODS - VL_DEBUG_FUNC; // Declare debug() void cleanupVarRefs() { for (const auto& itr : m_varRefScopes) { @@ -327,7 +328,6 @@ private: AstScope* m_scopep = nullptr; // Current scope we are building // METHODS - VL_DEBUG_FUNC; // Declare debug() // VISITORS void visit(AstScope* nodep) override { @@ -405,5 +405,5 @@ void V3Scope::scopeAll(AstNetlist* nodep) { const ScopeVisitor visitor{nodep}; ScopeCleanupVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("scope", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("scope", 0, dumpTree() >= 3); } diff --git a/src/V3Simulate.h b/src/V3Simulate.h index ee4b23caf..7c70e4ba1 100644 --- a/src/V3Simulate.h +++ b/src/V3Simulate.h @@ -115,7 +115,7 @@ private: std::vector m_reclaimValuesp; // List of allocated string numbers // Note level 8&9 include debugging each simulation value - VL_DEBUG_FUNC; // Declare debug() + VL_DEFINE_DEBUG_FUNCTIONS; // Potentially very slow, intended for debugging string prettyNumber(const V3Number* nump, AstNodeDType* dtypep) { diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp index cd977626f..57cca7785 100644 --- a/src/V3Slice.cpp +++ b/src/V3Slice.cpp @@ -43,6 +43,8 @@ #include "V3Ast.h" #include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //************************************************************************* class SliceVisitor final : public VNVisitor { @@ -58,8 +60,6 @@ class SliceVisitor final : public VNVisitor { bool m_assignError = false; // True if the current assign already has an error // METHODS - VL_DEBUG_FUNC; // Declare debug() - AstNode* cloneAndSel(AstNode* nodep, int elements, int offset) { // Insert an ArraySel, except for a few special cases const AstUnpackArrayDType* const arrayp @@ -240,5 +240,5 @@ public: void V3Slice::sliceAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { SliceVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("slice", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("slice", 0, dumpTree() >= 3); } diff --git a/src/V3Split.cpp b/src/V3Split.cpp index f2f2fe03a..f5828b111 100644 --- a/src/V3Split.cpp +++ b/src/V3Split.cpp @@ -93,6 +93,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Support classes @@ -261,8 +263,6 @@ public: // METHODS protected: - VL_DEBUG_FUNC; // Declare debug() - void scoreboardClear() { // VV***** We reset user1p() and user2p on each block!!! m_inDly = false; @@ -454,10 +454,7 @@ protected: UINFO(5, "ReorderBlock " << nodep << endl); m_graph.removeRedundantEdges(&V3GraphEdge::followAlwaysTrue); - if (debug() >= 9) { - m_graph.dumpDotFilePrefixed("reorderg_nodup", false); - // m_graph.dump(); cout<= 9) m_graph.dumpDotFilePrefixed("reorderg_nodup", false); // Mark all the logic for this step // Vertex::m_user begin: true indicates logic for this step @@ -514,10 +511,10 @@ protected: // And a real ordering to get the statements into something reasonable // We don't care if there's cutable violations here... // Non-cutable violations should be impossible; as those edges are program-order - if (debug() >= 9) m_graph.dumpDotFilePrefixed(string("splitg_preo"), false); + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed(string("splitg_preo"), false); m_graph.acyclic(&SplitEdge::followCyclic); m_graph.rank(&SplitEdge::followCyclic); // Or order(), but that's more expensive - if (debug() >= 9) m_graph.dumpDotFilePrefixed(string("splitg_opt"), false); + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed(string("splitg_opt"), false); } void reorderBlock(AstNode* nodep) { @@ -676,7 +673,6 @@ protected: iterateChildren(nodep); } - VL_DEBUG_FUNC; // Declare debug() private: VL_UNCOPYABLE(IfColorVisitor); }; @@ -728,8 +724,6 @@ public: } protected: - VL_DEBUG_FUNC; // Declare debug() - AstSplitPlaceholder* makePlaceholderp() { return new AstSplitPlaceholder(m_origAlwaysp->fileline()); } @@ -946,14 +940,14 @@ protected: } } - if (debug() >= 9) m_graph.dumpDotFilePrefixed("splitg_nodup", false); + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed("splitg_nodup", false); // Weak coloring to determine what needs to remain grouped // in a single always. This follows all edges excluding: // - those we pruned above // - PostEdges, which are done later m_graph.weaklyConnected(&SplitEdge::followScoreboard); - if (debug() >= 9) m_graph.dumpDotFilePrefixed("splitg_colored", false); + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed("splitg_colored", false); } void visit(AstAlways* nodep) override { @@ -1007,10 +1001,10 @@ private: void V3Split::splitReorderAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { ReorderVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("reorder", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("reorder", 0, dumpTree() >= 3); } void V3Split::splitAlwaysAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { SplitVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("split", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("split", 0, dumpTree() >= 3); } diff --git a/src/V3SplitAs.cpp b/src/V3SplitAs.cpp index d22429f93..1d7b4d86d 100644 --- a/src/V3SplitAs.cpp +++ b/src/V3SplitAs.cpp @@ -32,12 +32,13 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class SplitAsBaseVisitor VL_NOT_FINAL : public VNVisitor { public: // METHODS - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### @@ -196,5 +197,5 @@ public: void V3SplitAs::splitAsAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { SplitAsVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("splitas", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("splitas", 0, dumpTree() >= 3); } diff --git a/src/V3SplitVar.cpp b/src/V3SplitVar.cpp index 502058e37..7b82c3f46 100644 --- a/src/V3SplitVar.cpp +++ b/src/V3SplitVar.cpp @@ -125,6 +125,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + struct SplitVarImpl { // NODE STATE // AstNodeModule::user1() -> Block number counter for generating unique names @@ -782,7 +784,6 @@ public: V3Stats::addStat("SplitVar, Split unpacked arrays", m_numSplit); } const SplitVarRefsMap& getPackedVarRefs() const { return m_refsForPackedSplit; } - VL_DEBUG_FUNC; // Declare debug() // Check if the passed variable can be split. // Even if this function returns true, the variable may not be split @@ -1243,7 +1244,6 @@ public: } return reason; } - VL_DEBUG_FUNC; // Declare debug() }; const char* SplitVarImpl::cannotSplitPackedVarReason(const AstVar* varp) { @@ -1260,9 +1260,9 @@ void V3SplitVar::splitVariable(AstNetlist* nodep) { const SplitUnpackedVarVisitor visitor{nodep}; refs = visitor.getPackedVarRefs(); } - V3Global::dumpCheckGlobalTree("split_var", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 9); + V3Global::dumpCheckGlobalTree("split_var", 0, dumpTree() >= 9); { SplitPackedVarVisitor{nodep, refs}; } - V3Global::dumpCheckGlobalTree("split_var", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 9); + V3Global::dumpCheckGlobalTree("split_var", 0, dumpTree() >= 9); } bool V3SplitVar::canSplitVar(const AstVar* varp) { diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp index 5ec58dfdc..bda08d003 100644 --- a/src/V3Stats.cpp +++ b/src/V3Stats.cpp @@ -28,6 +28,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Stats class functions @@ -61,7 +63,6 @@ private: VDouble0 m_statVarScpBytes; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() void allNodes(AstNode* nodep) { m_instrs += nodep->instrCount(); diff --git a/src/V3StatsReport.cpp b/src/V3StatsReport.cpp index 85860e43e..03be5d71c 100644 --- a/src/V3StatsReport.cpp +++ b/src/V3StatsReport.cpp @@ -27,6 +27,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Stats dumping diff --git a/src/V3String.cpp b/src/V3String.cpp index 54fcfac07..6f4aa473b 100644 --- a/src/V3String.cpp +++ b/src/V3String.cpp @@ -17,10 +17,15 @@ #include "config_build.h" #include "verilatedos.h" -// Limited V3 headers here - this is a base class for Vlc etc -#include "V3Error.h" #include "V3String.h" +#include "V3Error.h" + +#ifndef V3ERROR_NO_GLOBAL_ +#include "V3Global.h" +VL_DEFINE_DEBUG_FUNCTIONS; +#endif + #include size_t VName::s_minLength = 32; diff --git a/src/V3Subst.cpp b/src/V3Subst.cpp index d671e23f3..60a664786 100644 --- a/src/V3Subst.cpp +++ b/src/V3Subst.cpp @@ -34,13 +34,7 @@ #include #include -//###################################################################### -// Common debugging baseclass - -class SubstBaseVisitor VL_NOT_FINAL : public VNVisitor { -public: - VL_DEBUG_FUNC; // Declare debug() -}; +VL_DEFINE_DEBUG_FUNCTIONS; //###################################################################### // Class for each word of a multi-word variable @@ -72,7 +66,6 @@ class SubstVarEntry final { bool m_wordUse = false; // True if any individual word usage SubstVarWord m_whole; // Data for whole vector used at once std::vector m_words; // Data for every word, if multi word variable - static int debug() { return SubstBaseVisitor::debug(); } public: // CONSTRUCTORS @@ -175,7 +168,7 @@ public: // See if any variables have changed value since we determined subst value, // as a visitor of each AstNode -class SubstUseVisitor final : public SubstBaseVisitor { +class SubstUseVisitor final : public VNVisitor { private: // NODE STATE // See SubstVisitor @@ -222,7 +215,7 @@ public: //###################################################################### // Subst state, as a visitor of each AstNode -class SubstVisitor final : public SubstBaseVisitor { +class SubstVisitor final : public VNVisitor { private: // NODE STATE // Passed to SubstUseVisitor @@ -390,5 +383,5 @@ public: void V3Subst::substituteAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { SubstVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("subst", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("subst", 0, dumpTree() >= 3); } diff --git a/src/V3SymTable.h b/src/V3SymTable.h index c1607f5f4..879c898e9 100644 --- a/src/V3SymTable.h +++ b/src/V3SymTable.h @@ -53,11 +53,7 @@ class VSymEnt final { bool m_exported; // Allow importing bool m_imported; // Was imported #ifdef VL_DEBUG - static int debug() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel("V3LinkDot.cpp"); - return level; - } + VL_DEFINE_DEBUG_FUNCTIONS; #else static constexpr int debug() { return 0; } // NOT runtime, too hot of a function #endif @@ -88,7 +84,7 @@ public: } } } - void dump(std::ostream& os, const string& indent = "", int numLevels = 1) const { + void dumpSelf(std::ostream& os, const string& indent = "", int numLevels = 1) const { VSymConstMap doneSyms; dumpIterate(os, doneSyms, indent, numLevels, "TOP"); } @@ -127,7 +123,7 @@ public: << " " << entp->nodep() << endl); if (name != "" && m_idNameMap.find(name) != m_idNameMap.end()) { if (!V3Error::errorCount()) { // Else may have just reported warning - if (debug() >= 9 || V3Error::debugDefault()) dump(cout, "- err-dump: ", 1); + if (debug() >= 9 || V3Error::debugDefault()) dumpSelf(cout, "- err-dump: ", 1); entp->nodep()->v3fatalSrc("Inserting two symbols with same name: " << name); } } else { @@ -272,7 +268,7 @@ public: if (scopes == "") scopes = ""; std::cerr << V3Error::warnMore() << "... Known scopes under '" << prettyName << "': " << scopes << endl; - if (debug()) dump(std::cerr, " KnownScope: ", 1); + if (debug()) dumpSelf(std::cerr, " KnownScope: ", 1); } }; @@ -291,6 +287,8 @@ class VSymGraph final { // CONSTRUCTORS VL_UNCOPYABLE(VSymGraph); + VL_DEFINE_DEBUG_FUNCTIONS; + public: explicit VSymGraph(AstNetlist* nodep) { m_symRootp = new VSymEnt(this, nodep); } ~VSymGraph() { @@ -300,7 +298,7 @@ public: // METHODS VSymEnt* rootp() const { return m_symRootp; } // Debug - void dump(std::ostream& os, const string& indent = "") { + void dumpSelf(std::ostream& os, const string& indent = "") { VSymConstMap doneSyms; os << "SymEnt Dump:\n"; m_symRootp->dumpIterate(os, doneSyms, indent, 9999, "$root"); @@ -316,12 +314,12 @@ public: } } void dumpFilePrefixed(const string& nameComment) { - if (v3Global.opt.dumpTree()) { + if (dumpTree()) { const string filename = v3Global.debugFilename(nameComment) + ".txt"; UINFO(2, "Dumping " << filename << endl); const std::unique_ptr logp{V3File::new_ofstream(filename)}; if (logp->fail()) v3fatal("Can't write " << filename); - dump(*logp, ""); + dumpSelf(*logp, ""); } } diff --git a/src/V3TSP.cpp b/src/V3TSP.cpp index 26055725d..0e488ca45 100644 --- a/src/V3TSP.cpp +++ b/src/V3TSP.cpp @@ -39,6 +39,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Support classes @@ -47,8 +49,6 @@ static uint32_t edgeIdNext = 0; static void selfTestStates(); static void selfTestString(); - -VL_DEBUG_FUNC; // Declare debug() } // namespace V3TSP // Vertex that tracks a per-vertex key @@ -396,7 +396,7 @@ public: } } void dumpGraphFilePrefixed(const string& nameComment) const { - if (v3Global.opt.dumpTree()) { + if (::dump()) { const string filename = v3Global.debugFilename(nameComment) + ".txt"; const std::unique_ptr logp{V3File::new_ofstream(filename)}; if (logp->fail()) v3fatal("Can't write " << filename); @@ -406,7 +406,7 @@ public: void findEulerTour(std::vector* sortedOutp) { UASSERT(sortedOutp->empty(), "Output graph must start empty"); - if (debug() >= 6) dumpDotFilePrefixed("findEulerTour"); + if (::dumpGraph() >= 6) dumpDotFilePrefixed("findEulerTour"); std::unordered_set markedEdges; // Pick a start node Vertex* const start_vertexp = castVertexp(verticesBeginp()); @@ -464,12 +464,12 @@ void V3TSP::tspSort(const V3TSP::StateVec& states, V3TSP::StateVec* resultp) { // Create the minimum spanning tree Graph minGraph; graph.makeMinSpanningTree(&minGraph); - if (debug() >= 6) minGraph.dumpGraphFilePrefixed("minGraph"); + if (dumpGraph() >= 6) minGraph.dumpGraphFilePrefixed("minGraph"); const std::vector oddDegree = minGraph.getOddDegreeKeys(); Graph matching; graph.perfectMatching(oddDegree, &matching); - if (debug() >= 6) matching.dumpGraphFilePrefixed("matching"); + if (dumpGraph() >= 6) matching.dumpGraphFilePrefixed("matching"); // Adds edges to minGraph, the resulting graph will have even number of // edge counts at every vertex: @@ -672,12 +672,12 @@ void V3TSP::selfTestString() { Graph minGraph; graph.makeMinSpanningTree(&minGraph); - if (debug() >= 6) minGraph.dumpGraphFilePrefixed("minGraph"); + if (dumpGraph() >= 6) minGraph.dumpGraphFilePrefixed("minGraph"); const std::vector oddDegree = minGraph.getOddDegreeKeys(); Graph matching; graph.perfectMatching(oddDegree, &matching); - if (debug() >= 6) matching.dumpGraphFilePrefixed("matching"); + if (dumpGraph() >= 6) matching.dumpGraphFilePrefixed("matching"); minGraph.combineGraph(matching); diff --git a/src/V3Table.cpp b/src/V3Table.cpp index 1e829f32e..8ace9f4f3 100644 --- a/src/V3Table.cpp +++ b/src/V3Table.cpp @@ -34,6 +34,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Table class functions @@ -169,7 +171,6 @@ private: std::vector m_outVarps; // Output variable list // METHODS - VL_DEBUG_FUNC; // Declare debug() public: void simulateVarRefCb(AstVarRef* nodep) { @@ -430,5 +431,5 @@ void TableSimulateVisitor::varRefCb(AstVarRef* nodep) { void V3Table::tableAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { TableVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("table", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("table", 0, dumpTree() >= 3); } diff --git a/src/V3Task.cpp b/src/V3Task.cpp index 91ab55ce2..9a2bd2b53 100644 --- a/src/V3Task.cpp +++ b/src/V3Task.cpp @@ -38,6 +38,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Graph subclasses @@ -281,7 +283,7 @@ public: iterate(nodep); // m_callGraph.removeRedundantEdgesSum(&TaskEdge::followAlwaysTrue); - m_callGraph.dumpDotFilePrefixed("task_call"); + if (dumpGraph()) m_callGraph.dumpDotFilePrefixed("task_call"); } ~TaskStateVisitor() override = default; VL_UNCOPYABLE(TaskStateVisitor); @@ -365,7 +367,6 @@ private: DpiCFuncs m_dpiNames; // Map of all created DPI functions // METHODS - VL_DEBUG_FUNC; // Declare debug() AstVarScope* createFuncVar(AstCFunc* funcp, const string& name, AstVar* examplep) { AstVar* const newvarp = new AstVar(funcp->fileline(), VVarType::BLOCKTEMP, name, examplep); @@ -1812,5 +1813,5 @@ void V3Task::taskAll(AstNetlist* nodep) { TaskStateVisitor visitors{nodep}; const TaskVisitor visitor{nodep, &visitors}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("task", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("task", 0, dumpTree() >= 3); } diff --git a/src/V3Timing.cpp b/src/V3Timing.cpp index 9a54c91b9..8e5661ef9 100644 --- a/src/V3Timing.cpp +++ b/src/V3Timing.cpp @@ -53,8 +53,10 @@ #include "V3SenTree.h" #include "V3UniqueNames.h" -//###################################################################### -// Transform nodes affected by timing +VL_DEFINE_DEBUG_FUNCTIONS; + +// ###################################################################### +// Transform nodes affected by timing class TimingVisitor final : public VNVisitor { private: @@ -127,7 +129,6 @@ private: SenTreeFinder m_finder{m_netlistp}; // Sentree finder and uniquifier // METHODS - VL_DEBUG_FUNC; // Declare debug() // Get or create the dependency vertex for the given node DependencyVertex* getDependencyVertex(AstNode* const nodep) { if (!nodep->user3p()) nodep->user3p(new DependencyVertex{&m_depGraph, nodep}); @@ -635,7 +636,7 @@ public: explicit TimingVisitor(AstNetlist* nodep) : m_netlistp{nodep} { iterate(nodep); - if (debug() >= 6) m_depGraph.dumpDotFilePrefixed("timing_deps"); + if (dumpGraph() >= 6) m_depGraph.dumpDotFilePrefixed("timing_deps"); } ~TimingVisitor() override = default; }; @@ -646,5 +647,5 @@ public: void V3Timing::timingAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); TimingVisitor{nodep}; - V3Global::dumpCheckGlobalTree("timing", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("timing", 0, dumpTree() >= 3); } diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp index faa409b1d..10243983d 100644 --- a/src/V3Trace.cpp +++ b/src/V3Trace.cpp @@ -50,6 +50,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Graph vertexes @@ -194,7 +196,6 @@ private: using TraceVec = std::multimap; // METHODS - VL_DEBUG_FUNC; // Declare debug() void detectDuplicates() { UINFO(9, "Finding duplicates\n"); @@ -724,11 +725,11 @@ private: detectDuplicates(); // Simplify & optimize the graph - if (debug() >= 6) m_graph.dumpDotFilePrefixed("trace_pre"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("trace_pre"); graphSimplify(true); - if (debug() >= 6) m_graph.dumpDotFilePrefixed("trace_simplified"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("trace_simplified"); graphOptimize(); - if (debug() >= 6) m_graph.dumpDotFilePrefixed("trace_optimized"); + if (dumpGraph() >= 6) m_graph.dumpDotFilePrefixed("trace_optimized"); // Create the fine grained activity flags createActivityFlags(); @@ -910,5 +911,5 @@ public: void V3Trace::traceAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { TraceVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("trace", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("trace", 0, dumpTree() >= 3); } diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index 9df50a158..41db6e5ab 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -37,6 +37,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Utility class to emit path adjustments @@ -133,7 +135,6 @@ private: VDouble0 m_statIgnSigs; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() const char* vscIgnoreTrace(const AstVarScope* nodep) { // Return true if this shouldn't be traced @@ -525,5 +526,5 @@ public: void V3TraceDecl::traceDeclAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { TraceDeclVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("tracedecl", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("tracedecl", 0, dumpTree() >= 3); } diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp index 613983a02..aafbc0f47 100644 --- a/src/V3Tristate.cpp +++ b/src/V3Tristate.cpp @@ -106,12 +106,13 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class TristateBaseVisitor VL_NOT_FINAL : public VNVisitor { public: // METHODS - VL_DEBUG_FUNC; // Declare debug() }; //###################################################################### @@ -176,7 +177,6 @@ public: private: // METHODS - VL_DEBUG_FUNC; // Declare debug() TristateVertex* makeVertex(AstNode* nodep) { TristateVertex* vertexp = reinterpret_cast(nodep->user5p()); @@ -264,7 +264,6 @@ public: AstNode::user5ClearTree(); // Wipe all node user5p's that point to vertexes } void graphWalk(AstNodeModule* nodep) { - // if (debug() >= 9) m_graph.dumpDotFilePrefixed("tri_pre__" + nodep->name()); UINFO(9, " Walking " << nodep << endl); for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp = itp->verticesNextp()) { graphWalkRecurseFwd(static_cast(itp), 0); @@ -272,7 +271,7 @@ public: for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp = itp->verticesNextp()) { graphWalkRecurseBack(static_cast(itp), 0); } - if (debug() >= 9) m_graph.dumpDotFilePrefixed("tri_pos__" + nodep->name()); + if (dumpGraph() >= 9) m_graph.dumpDotFilePrefixed("tri_pos__" + nodep->name()); } void associate(AstNode* fromp, AstNode* top) { new V3GraphEdge(&m_graph, makeVertex(fromp), makeVertex(top), 1); @@ -1643,5 +1642,5 @@ public: void V3Tristate::tristateAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { TristateVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("tristate", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("tristate", 0, dumpTree() >= 3); } diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp index 1cf0f125d..716005892 100644 --- a/src/V3Undriven.cpp +++ b/src/V3Undriven.cpp @@ -36,6 +36,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Class for every variable we may process @@ -47,8 +49,6 @@ class UndrivenVarEntry final { enum : uint8_t { FLAG_USED = 0, FLAG_DRIVEN = 1, FLAGS_PER_BIT = 2 }; - VL_DEBUG_FUNC; // Declare debug() - public: // CONSTRUCTORS explicit UndrivenVarEntry(AstVar* varp) @@ -257,7 +257,6 @@ private: const AstAlways* m_alwaysCombp = nullptr; // Current always if combo, otherwise nullptr // METHODS - VL_DEBUG_FUNC; // Declare debug() UndrivenVarEntry* getEntryp(AstVar* nodep, int which_user) { if (!(which_user == 1 ? nodep->user1p() : nodep->user2p())) { diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp index 708c1c1d7..abd550ea5 100644 --- a/src/V3Unknown.cpp +++ b/src/V3Unknown.cpp @@ -41,6 +41,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### class UnknownVisitor final : public VNVisitor { @@ -65,7 +67,6 @@ private: V3UniqueNames m_xrandNames; // For generating unique temporary variable names // METHODS - VL_DEBUG_FUNC; // Declare debug() void replaceBoundLvalue(AstNode* nodep, AstNode* condp) { // Spec says a out-of-range LHS SEL results in a NOP. @@ -516,5 +517,5 @@ public: void V3Unknown::unknownAll(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { UnknownVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("unknown", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("unknown", 0, dumpTree() >= 3); } diff --git a/src/V3Unroll.cpp b/src/V3Unroll.cpp index 2ffef6176..4629f16a5 100644 --- a/src/V3Unroll.cpp +++ b/src/V3Unroll.cpp @@ -37,6 +37,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Unroll state, as a visitor of each AstNode @@ -57,7 +59,6 @@ private: VDouble0 m_statIters; // Statistic tracking // METHODS - VL_DEBUG_FUNC; // Declare debug() // VISITORS bool cantUnroll(AstNode* nodep, const char* reason) const { @@ -517,5 +518,5 @@ void V3Unroll::unrollAll(AstNetlist* nodep) { UnrollStateful unroller; unroller.unrollAll(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("unroll", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("unroll", 0, dumpTree() >= 3); } diff --git a/src/V3VariableOrder.cpp b/src/V3VariableOrder.cpp index ad98ec081..562bc7225 100644 --- a/src/V3VariableOrder.cpp +++ b/src/V3VariableOrder.cpp @@ -34,6 +34,8 @@ #include #include +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Establish mtask variable sort order in mtasks mode @@ -205,5 +207,5 @@ void V3VariableOrder::orderAll() { modp = VN_AS(modp->nextp(), NodeModule)) { VariableOrder::processModule(modp); } - V3Global::dumpCheckGlobalTree("variableorder", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("variableorder", 0, dumpTree() >= 3); } diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 7087b9bc2..eb249b88e 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -81,6 +81,8 @@ #define VERILATOR_V3WIDTH_CPP_ #include "V3WidthCommit.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### enum Stage : uint8_t { @@ -236,9 +238,6 @@ private: EXTEND_OFF // No extension }; - // METHODS - static int debug() { return V3Width::debug(); } - // VISITORS // Naming: width_O{outputtype}_L{lhstype}_R{rhstype}_W{widthing}_S{signing} // Where type: @@ -6831,12 +6830,6 @@ public: //###################################################################### // Width class functions -int V3Width::debug() { - static int level = -1; - if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__); - return level; -} - void V3Width::width(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { @@ -6847,7 +6840,7 @@ void V3Width::width(AstNetlist* nodep) { WidthRemoveVisitor rvisitor; (void)rvisitor.mainAcceptEdit(nodep); } // Destruct before checking - V3Global::dumpCheckGlobalTree("width", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("width", 0, dumpTree() >= 3); } //! Single node parameter propagation @@ -6883,5 +6876,5 @@ AstNode* V3Width::widthGenerateParamsEdit( void V3Width::widthCommit(AstNetlist* nodep) { UINFO(2, __FUNCTION__ << ": " << endl); { WidthCommitVisitor{nodep}; } // Destruct before checking - V3Global::dumpCheckGlobalTree("widthcommit", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6); + V3Global::dumpCheckGlobalTree("widthcommit", 0, dumpTree() >= 6); } diff --git a/src/V3Width.h b/src/V3Width.h index 2d6cfb9d7..6a0261d9e 100644 --- a/src/V3Width.h +++ b/src/V3Width.h @@ -27,7 +27,6 @@ class AstNode; class V3Width final { public: - static int debug(); static void width(AstNetlist* nodep); static AstNode* widthParamsEdit(AstNode* nodep); static AstNode* widthGenerateParamsEdit(AstNode* nodep); diff --git a/src/V3WidthCommit.h b/src/V3WidthCommit.h index fb883a256..ca2f9a584 100644 --- a/src/V3WidthCommit.h +++ b/src/V3WidthCommit.h @@ -35,8 +35,9 @@ /// This step is only called on real V3Width, not intermediate e.g. widthParams class WidthRemoveVisitor final : public VNVisitor { -private: // METHODS + VL_DEFINE_DEBUG_FUNCTIONS; + void replaceWithSignedVersion(AstNode* nodep, AstNode* newp) { UINFO(6, " Replace " << nodep << " w/ " << newp << endl); nodep->replaceWith(newp); @@ -74,6 +75,8 @@ class WidthCommitVisitor final : public VNVisitor { public: // METHODS + VL_DEFINE_DEBUG_FUNCTIONS; + static AstConst* newIfConstCommitSize(AstConst* nodep) { if (((nodep->dtypep()->width() != nodep->num().width()) || !nodep->num().sized()) && !nodep->num().isString()) { // Need to force the number from unsized to sized diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp index 222f69c5b..174d01a36 100644 --- a/src/V3WidthSel.cpp +++ b/src/V3WidthSel.cpp @@ -34,6 +34,8 @@ #include "V3Global.h" #include "V3Width.h" +VL_DEFINE_DEBUG_FUNCTIONS; + //###################################################################### // Width state, as a visitor of each AstNode @@ -47,7 +49,6 @@ private: #define iterateChildren DO_NOT_iterateChildern_IN_V3WidthSel // METHODS - VL_DEBUG_FUNC; // Declare debug() void checkConstantOrReplace(AstNode* nodep, const string& message) { // See also V3Width::checkConstantOrReplace diff --git a/src/Verilator.cpp b/src/Verilator.cpp index 4060a6dc3..eedc41193 100644 --- a/src/Verilator.cpp +++ b/src/Verilator.cpp @@ -102,6 +102,8 @@ #include +VL_DEFINE_DEBUG_FUNCTIONS; + V3Global v3Global; static void reportStatsIfEnabled() { @@ -609,7 +611,7 @@ static void verilate(const string& argString) { } // Final steps - V3Global::dumpCheckGlobalTree("final", 990, v3Global.opt.dumpTreeLevel(__FILE__) >= 3); + V3Global::dumpCheckGlobalTree("final", 990, dumpTree() >= 3); V3Error::abortIfErrors(); diff --git a/src/VlcMain.cpp b/src/VlcMain.cpp index f4f6717ca..5f1b01ec5 100644 --- a/src/VlcMain.cpp +++ b/src/VlcMain.cpp @@ -23,14 +23,18 @@ #include "verilatedos.h" -// Cheat for speed and compile .cpp files into one object +// Cheat for speed and compile .cpp files into one object TODO: Reconsider #define V3ERROR_NO_GLOBAL_ +#include "V3Error.h" +static int debug() { return V3Error::debugDefault(); } #include "V3Error.cpp" #include "V3String.cpp" #define V3OPTION_PARSER_NO_VOPTION_BOOL +// clang-format off #include "V3OptionParser.cpp" #include "V3Os.cpp" #include "VlcTop.cpp" +// clanf-format on #include "VlcOptions.h" #include "VlcTop.h" diff --git a/src/VlcPoint.h b/src/VlcPoint.h index b5c9598fc..1b59b39f2 100644 --- a/src/VlcPoint.h +++ b/src/VlcPoint.h @@ -102,6 +102,8 @@ private: std::vector m_points; //< List of all points uint64_t m_numPoints = 0; //< Total unique points + static int debug() { return V3Error::debugDefault(); } + public: // ITERATORS using ByName = NameMap; diff --git a/src/VlcTest.h b/src/VlcTest.h index 2c85950dc..0ceb7d340 100644 --- a/src/VlcTest.h +++ b/src/VlcTest.h @@ -93,6 +93,8 @@ private: // MEMBERS ByName m_tests; //< List of all tests + static int debug() { return V3Error::debugDefault(); } + public: // ITERATORS using iterator = ByName::iterator; diff --git a/src/astgen b/src/astgen index 56956768d..c1d571ecd 100755 --- a/src/astgen +++ b/src/astgen @@ -904,6 +904,89 @@ def write_macros(filename): fh.write("\n") +def write_op_checks(filename): + with open_file(filename) as fh: + + indent = "" + + def emitBlock(pattern, **fmt): + fh.write( + textwrap.indent(textwrap.dedent(pattern), + indent).format(**fmt)) + + for node in SortedNodes: + if not node.isLeaf: + continue + + emitBlock('''\ + case VNType::at{nodeName}: {{ + const Ast{nodeName}* const currp = static_cast(this); + ''', + nodeName=node.name) + indent = " " + for n in range(1, 5): + op = node.getOp(n) + emitBlock("// Checking op{n}p\n", n=n) + if op: + name, monad, kind = op + if not monad: + emitBlock('''\ + UASSERT_OBJ(currp->{opName}(), currp, "Ast{nodeName} must have non nullptr {opName}()"); + UASSERT_OBJ(!currp->{opName}()->nextp(), currp, "Ast{nodeName}::{opName}() cannot have a non nullptr nextp()"); + currp->{opName}()->checkTreeIter(currp); + ''', + n=n, + nodeName=node.name, + opName=name) + elif monad == "Optional": + emitBlock('''\ + if (Ast{kind}* const opp = currp->{opName}()) {{ + UASSERT_OBJ(!currp->{opName}()->nextp(), currp, "Ast{nodeName}::{opName}() cannot have a non nullptr nextp()"); + opp->checkTreeIter(currp); + }} + ''', + n=n, + nodeName=node.name, + opName=name, + kind=kind) + elif monad == "List": + emitBlock('''\ + if (const Ast{kind}* const headp = currp->{opName}()) {{ + const AstNode* backp = currp; + const Ast{kind}* tailp = headp; + const Ast{kind}* opp = headp; + do {{ + opp->checkTreeIter(backp); + UASSERT_OBJ(opp == headp || !opp->nextp() || !opp->m_headtailp, opp, "Headtailp should be null in middle of lists"); + backp = tailp = opp; + opp = {next}; + }} while (opp); + UASSERT_OBJ(headp->m_headtailp == tailp, headp, "Tail in headtailp is inconsistent"); + UASSERT_OBJ(tailp->m_headtailp == headp, tailp, "Head in headtailp is inconsistent"); + }} + ''', + n=n, + nodeName=node.name, + opName=name, + kind=kind, + next="VN_AS(opp->nextp(), {kind})".format( + kind=kind) + if kind != "Node" else "opp->nextp()") + else: + sys.exit("Unknown operand type") + else: + emitBlock('''\ + UASSERT_OBJ(!currp->op{n}p(), currp, "Ast{nodeName} does not use op{n}p()"); + ''', + n=n, + nodeName=node.name) + indent = "" + emitBlock('''\ + break; + }} + ''') + + ###################################################################### # main @@ -1005,6 +1088,7 @@ if Args.classes: write_types("V3Ast__gen_types.h") write_yystype("V3Ast__gen_yystype.h") write_macros("V3Ast__gen_macros.h") + write_op_checks("V3Ast__gen_op_checks.h") for cpt in Args.infiles: if not re.search(r'.cpp$', cpt): diff --git a/test_regress/driver.pl b/test_regress/driver.pl index 720d44008..3d71ef7dc 100755 --- a/test_regress/driver.pl +++ b/test_regress/driver.pl @@ -235,7 +235,7 @@ sub parameter { elsif ($param =~ /\.pl/) { push @opt_tests, $param; } - elsif ($param =~ /^-?(-debugi|-dump-treei)/) { + elsif ($param =~ /^-?(-debugi|-dumpi)/) { push @Opt_Driver_Verilator_Flags, $param; $_Parameter_Next_Level = $param; } diff --git a/test_regress/t/t_debug_emitv.pl b/test_regress/t/t_debug_emitv.pl index 863c22c75..91be564c7 100755 --- a/test_regress/t/t_debug_emitv.pl +++ b/test_regress/t/t_debug_emitv.pl @@ -13,7 +13,7 @@ scenarios(vlt => 1); lint( # We also have dump-tree turned on, so hit a lot of AstNode*::dump() functions # Likewise XML - v_flags => ["--lint-only --dump-treei 9 --dump-treei-V3EmitV 9 --debug-emitv"], + v_flags => ["--lint-only --dumpi-tree 9 --dumpi-V3EmitV 9 --debug-emitv"], ); files_identical(glob_one("$Self->{obj_dir}/$Self->{VM_PREFIX}_*_width.tree.v"), $Self->{golden_filename}); diff --git a/test_regress/t/t_debug_emitv_addrids.pl b/test_regress/t/t_debug_emitv_addrids.pl index 40070d6e5..183f2dd13 100755 --- a/test_regress/t/t_debug_emitv_addrids.pl +++ b/test_regress/t/t_debug_emitv_addrids.pl @@ -15,7 +15,7 @@ top_filename("t/t_debug_emitv.v"); lint( # We also have dump-tree turned on, so hit a lot of AstNode*::dump() functions # Likewise XML - v_flags => ["--lint-only --dump-treei 9 --dump-tree-addrids"], + v_flags => ["--lint-only --dumpi-tree 9 --dump-tree-addrids"], ); ok(1); diff --git a/test_regress/t/t_dotfiles.pl b/test_regress/t/t_dotfiles.pl index a9b52715e..9df77e2ca 100755 --- a/test_regress/t/t_dotfiles.pl +++ b/test_regress/t/t_dotfiles.pl @@ -14,7 +14,7 @@ scenarios(vltmt => 1); top_filename("t/t_gen_alw.v"); compile( - v_flags2 => ["--debug --debugi 5"], + v_flags2 => ["--dumpi-graph 6"], threads => 2 );