From 965d99f1bc68eb1d785f7cbea842fe871df1e11d Mon Sep 17 00:00:00 2001 From: Geza Lore Date: Tue, 4 Oct 2022 11:03:41 +0100 Subject: [PATCH] DFG: Make implementation more similar to AST Use the same style, and reuse the bulk of astgen to generate DfgVertex related code. In particular allow for easier definition of custom DfgVertex sub-types that do not directly correspond to an AstNode sub-type. Also introduces specific names for the fixed arity vertices. No functional change intended. --- docs/internals.rst | 6 +- src/Makefile_obj.in | 22 +- src/V3Ast.h | 8 +- src/V3AstNodeDType.h | 52 ++-- src/V3AstNodeMath.h | 388 ++++++++++++++-------------- src/V3AstNodeOther.h | 374 +++++++++++++-------------- src/V3Dfg.cpp | 48 ++-- src/V3Dfg.h | 589 +++++++++++++++--------------------------- src/V3DfgAstToDfg.cpp | 20 +- src/V3DfgDfgToAst.cpp | 26 +- src/V3DfgPasses.cpp | 2 +- src/V3DfgPeephole.cpp | 22 +- src/V3DfgVertices.h | 229 ++++++++++++++++ src/astgen | 562 ++++++++++++++++++++++++---------------- 14 files changed, 1263 insertions(+), 1085 deletions(-) create mode 100644 src/V3DfgVertices.h diff --git a/docs/internals.rst b/docs/internals.rst index d2424c403..c2031c857 100644 --- a/docs/internals.rst +++ b/docs/internals.rst @@ -1047,9 +1047,9 @@ Generating ``AstNode`` members Some of the member s of ``AstNode`` sub-classes are generated by ``astgen``. These are emitted as pre-processor macro definitions, which then need to be added to the ``AstNode`` sub-classes they correspond to. Specifically ``class -AstFoo`` should contain an instance of ``ASTGEN_MEMBERS_Foo;`` at class scope. -The ``astgen`` script checks and errors if this is not present. The method -generated depends on whether the class is a concrete final class, or an +AstFoo`` should contain an instance of ``ASTGEN_MEMBERS_AstFoo;`` at class +scope. The ``astgen`` script checks and errors if this is not present. The +method generated depends on whether the class is a concrete final class, or an abstract ``AstNode*`` base-class, and on ``@astgen`` directives present in comment sections in the body of the ``AstNode`` sub-class definitions. diff --git a/src/Makefile_obj.in b/src/Makefile_obj.in index a6430e10c..503fb540f 100644 --- a/src/Makefile_obj.in +++ b/src/Makefile_obj.in @@ -289,6 +289,7 @@ NON_STANDALONE_HEADERS = \ V3AstNodeDType.h \ V3AstNodeMath.h \ V3AstNodeOther.h \ + V3DfgVertices.h \ V3WidthCommit.h \ AST_DEFS := \ @@ -296,10 +297,19 @@ AST_DEFS := \ V3AstNodeMath.h \ V3AstNodeOther.h \ +DFG_DEFS := \ + V3DfgVertices.h + +#### astgen common flags + +ASTGENFLAGS = -I $(srcdir) +ASTGENFLAGS += $(foreach f,$(AST_DEFS),--astdef $f) +ASTGENFLAGS += $(foreach f,$(DFG_DEFS),--dfgdef $f) + #### Linking ifeq ($(VL_VLCOV),) -PREDEP_H = V3Ast__gen_classes.h +PREDEP_H = V3Ast__gen_forward_class_decls.h OBJS += $(RAW_OBJS) $(NC_OBJS) else PREDEP_H = @@ -318,8 +328,8 @@ V3Number_test: V3Number_test.o #### Modules -%__gen.cpp: %.cpp $(ASTGEN) $(AST_DEFS) - $(PYTHON3) $(ASTGEN) -I $(srcdir) $(foreach f,$(AST_DEFS),--astdef $f) $*.cpp +%__gen.cpp: %.cpp $(ASTGEN) $(AST_DEFS) $(DFG_DEFS) + $(PYTHON3) $(ASTGEN) $(ASTGENFLAGS) $*.cpp %.o: %.cpp $(OBJCACHE) ${CXX} ${CXXFLAGS} ${CPPFLAGSWALL} -c $< -o $@ @@ -341,7 +351,7 @@ V3PreProc.o: V3PreProc.cpp V3PreLex.yy.cpp #### Generated files # Target rule called before parallel build to make generated files -serial:: V3Ast__gen_classes.h V3ParseBison.c +serial:: V3Ast__gen_forward_class_decls.h V3ParseBison.c serial_vlcov:: vlcovgen.d @@ -349,8 +359,8 @@ vlcovgen.d: $(VLCOVGEN) $(srcdir)/../include/verilated_cov_key.h $(PYTHON3) $(VLCOVGEN) --srcdir $(srcdir) touch $@ -V3Ast__gen_classes.h : $(ASTGEN) $(AST_DEFS) - $(PYTHON3) $(ASTGEN) -I $(srcdir) $(foreach f,$(AST_DEFS),--astdef $f) --classes +V3Ast__gen_forward_class_decls.h: $(ASTGEN) $(AST_DEFS) $(DFG_DEFS) + $(PYTHON3) $(ASTGEN) $(ASTGENFLAGS) --classes V3ParseBison.h: V3ParseBison.c diff --git a/src/V3Ast.h b/src/V3Ast.h index 71a86943c..fa33caca9 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -26,7 +26,7 @@ #include "V3Global.h" #include "V3Number.h" -#include "V3Ast__gen_classes.h" // From ./astgen +#include "V3Ast__gen_forward_class_decls.h" // From ./astgen #include #include @@ -87,7 +87,7 @@ using MTaskIdSet = std::set; // Set of mtaskIds for Var sorting class VNType final { public: -#include "V3Ast__gen_types.h" // From ./astgen +#include "V3Ast__gen_type_enum.h" // From ./astgen // Above include has: // enum en {...}; // const char* ascii() const {...}; @@ -2179,7 +2179,7 @@ void AstNode::addPrev(AstNode* newp) { } // Specialisations of privateTypeTest -#include "V3Ast__gen_impl.h" // From ./astgen +#include "V3Ast__gen_type_tests.h" // From ./astgen // Specializations of AstNode::mayBeUnder template <> @@ -2478,7 +2478,7 @@ AstNode* VNVisitor::iterateSubtreeReturnEdits(AstNode* nodep) { return nodep->iterateSubtreeReturnEdits(*this); } -// Include macros generated by 'astgen'. These include ASTGEN_MEMBERS_ +// Include macros generated by 'astgen'. These include ASTGEN_MEMBERS_Ast // for each AstNode sub-type, and ASTGEN_SUPER_ for concrete final // AstNode sub-types. The generated members include boilerplate methods related // to cloning, visitor dispatch, and other functionality. ASTGEN_SUPER_ diff --git a/src/V3AstNodeDType.h b/src/V3AstNodeDType.h index c30a18abf..c3f4d096e 100644 --- a/src/V3AstNodeDType.h +++ b/src/V3AstNodeDType.h @@ -50,7 +50,7 @@ protected: : AstNode{t, fl} {} public: - ASTGEN_MEMBERS_NodeDType; + ASTGEN_MEMBERS_AstNodeDType; // ACCESSORS void dump(std::ostream& str) const override; virtual void dumpSmall(std::ostream& str) const; @@ -144,7 +144,7 @@ protected: : AstNodeDType{t, fl} {} public: - ASTGEN_MEMBERS_NodeArrayDType; + ASTGEN_MEMBERS_AstNodeArrayDType; void dump(std::ostream& str) const override; void dumpSmall(std::ostream& str) const override; const char* broken() const override { @@ -212,7 +212,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeUOrStructDType; + ASTGEN_MEMBERS_AstNodeUOrStructDType; int uniqueNum() const { return m_uniqueNum; } const char* broken() const override; void dump(std::ostream& str) const override; @@ -270,7 +270,7 @@ public: this->rangep(rangep); this->valuep(valuep); } - ASTGEN_MEMBERS_EnumItem; + ASTGEN_MEMBERS_AstEnumItem; string name() const override { return m_name; } bool maybePointedTo() const override { return true; } bool hasDType() const override { return true; } @@ -300,7 +300,7 @@ public: keyDTypep(keyDtp); dtypep(dtp); } - ASTGEN_MEMBERS_AssocArrayDType; + ASTGEN_MEMBERS_AstAssocArrayDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -385,7 +385,7 @@ private: AstRange* rangep); public: - ASTGEN_MEMBERS_BasicDType; + ASTGEN_MEMBERS_AstBasicDType; void dump(std::ostream& str) const override; // width/widthMin/numeric compared elsewhere bool same(const AstNode* samep) const override { @@ -467,7 +467,7 @@ public: this->childDTypep(childDTypep); this->elementsp(elementsp); } - ASTGEN_MEMBERS_BracketArrayDType; + ASTGEN_MEMBERS_AstBracketArrayDType; bool similarDType(AstNodeDType* samep) const override { V3ERROR_NA_RETURN(false); } AstNodeDType* subDTypep() const override { return childDTypep(); } // METHODS @@ -495,7 +495,7 @@ public: this->dtypep(this); this->addParamsp(paramsp); } - ASTGEN_MEMBERS_ClassRefDType; + ASTGEN_MEMBERS_AstClassRefDType; // METHODS const char* broken() const override; void cloneRelink() override; @@ -539,7 +539,7 @@ public: dtypep(nullptr); // V3Width will resolve widthFromSub(subDTypep()); } - ASTGEN_MEMBERS_ConstDType; + ASTGEN_MEMBERS_AstConstDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -593,7 +593,7 @@ public: childDTypep(dtp); // Only for parser dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_DefImplicitDType; + ASTGEN_MEMBERS_AstDefImplicitDType; int uniqueNum() const { return m_uniqueNum; } bool same(const AstNode* samep) const override { const AstDefImplicitDType* const sp = static_cast(samep); @@ -635,7 +635,7 @@ public: refDTypep(dtp); dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_DynArrayDType; + ASTGEN_MEMBERS_AstDynArrayDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -677,7 +677,7 @@ public: : ASTGEN_SUPER_EmptyQueueDType(fl) { dtypep(this); } - ASTGEN_MEMBERS_EmptyQueueDType; + ASTGEN_MEMBERS_AstEmptyQueueDType; void dumpSmall(std::ostream& str) const override; bool hasDType() const override { return true; } bool maybePointedTo() const override { return true; } @@ -716,7 +716,7 @@ public: dtypep(nullptr); // V3Width will resolve widthFromSub(subDTypep()); } - ASTGEN_MEMBERS_EnumDType; + ASTGEN_MEMBERS_AstEnumDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -777,7 +777,7 @@ public: , m_cellName{cellName} , m_ifaceName{ifaceName} , m_modportName{modport} {} - ASTGEN_MEMBERS_IfaceRefDType; + ASTGEN_MEMBERS_AstIfaceRefDType; // METHODS const char* broken() const override; void dump(std::ostream& str = std::cout) const override; @@ -832,7 +832,7 @@ public: dtypep(this); widthFromSub(subDTypep()); } - ASTGEN_MEMBERS_MemberDType; + ASTGEN_MEMBERS_AstMemberDType; string name() const override { return m_name; } // * = Var name bool hasDType() const override { return true; } bool maybePointedTo() const override { return true; } @@ -889,7 +889,7 @@ public: childDTypep(dtp); // Only for parser dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_ParamTypeDType; + ASTGEN_MEMBERS_AstParamTypeDType; AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* subDTypep() const override { return dtypep() ? dtypep() : childDTypep(); } AstBasicDType* basicp() const override { return subDTypep()->basicp(); } @@ -923,7 +923,7 @@ class AstParseTypeDType final : public AstNodeDType { public: explicit AstParseTypeDType(FileLine* fl) : ASTGEN_SUPER_ParseTypeDType(fl) {} - ASTGEN_MEMBERS_ParseTypeDType; + ASTGEN_MEMBERS_AstParseTypeDType; AstNodeDType* dtypep() const { return nullptr; } // METHODS bool similarDType(AstNodeDType* samep) const override { return this == samep; } @@ -960,7 +960,7 @@ public: refDTypep(dtp); dtypep(dtp); } - ASTGEN_MEMBERS_QueueDType; + ASTGEN_MEMBERS_AstQueueDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -1026,7 +1026,7 @@ public: : ASTGEN_SUPER_RefDType(fl) { this->typeofp(typeofp); } - ASTGEN_MEMBERS_RefDType; + ASTGEN_MEMBERS_AstRefDType; // METHODS const char* broken() const override; void cloneRelink() override; @@ -1101,7 +1101,7 @@ public: refDTypep(nullptr); dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_UnsizedArrayDType; + ASTGEN_MEMBERS_AstUnsizedArrayDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -1134,7 +1134,7 @@ public: : ASTGEN_SUPER_VoidDType(fl) { dtypep(this); } - ASTGEN_MEMBERS_VoidDType; + ASTGEN_MEMBERS_AstVoidDType; void dumpSmall(std::ostream& str) const override; bool hasDType() const override { return true; } bool maybePointedTo() const override { return true; } @@ -1166,7 +1166,7 @@ public: refDTypep(nullptr); dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_WildcardArrayDType; + ASTGEN_MEMBERS_AstWildcardArrayDType; const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); @@ -1199,7 +1199,7 @@ class AstPackArrayDType final : public AstNodeArrayDType { public: inline AstPackArrayDType(FileLine* fl, VFlagChildDType, AstNodeDType* dtp, AstRange* rangep); inline AstPackArrayDType(FileLine* fl, AstNodeDType* dtp, AstRange* rangep); - ASTGEN_MEMBERS_PackArrayDType; + ASTGEN_MEMBERS_AstPackArrayDType; string prettyDTypeName() const override; bool isCompound() const override { return false; } }; @@ -1226,7 +1226,7 @@ public: // width and signing from the subDType/base type widthFromSub(subDTypep()); } - ASTGEN_MEMBERS_UnpackArrayDType; + ASTGEN_MEMBERS_AstUnpackArrayDType; string prettyDTypeName() const override; bool same(const AstNode* samep) const override { const AstUnpackArrayDType* const sp = static_cast(samep); @@ -1244,7 +1244,7 @@ public: // VSigning below is mispurposed to indicate if packed or not AstStructDType(FileLine* fl, VSigning numericUnpack) : ASTGEN_SUPER_StructDType(fl, numericUnpack) {} - ASTGEN_MEMBERS_StructDType; + ASTGEN_MEMBERS_AstStructDType; string verilogKwd() const override { return "struct"; } }; class AstUnionDType final : public AstNodeUOrStructDType { @@ -1253,7 +1253,7 @@ public: // VSigning below is mispurposed to indicate if packed or not AstUnionDType(FileLine* fl, VSigning numericUnpack) : ASTGEN_SUPER_UnionDType(fl, numericUnpack) {} - ASTGEN_MEMBERS_UnionDType; + ASTGEN_MEMBERS_AstUnionDType; string verilogKwd() const override { return "union"; } }; diff --git a/src/V3AstNodeMath.h b/src/V3AstNodeMath.h index 977a49b96..dc2d6f8ad 100644 --- a/src/V3AstNodeMath.h +++ b/src/V3AstNodeMath.h @@ -44,7 +44,7 @@ protected: : AstNode{t, fl} {} public: - ASTGEN_MEMBERS_NodeMath; + ASTGEN_MEMBERS_AstNodeMath; // METHODS void dump(std::ostream& str) const override; bool hasDType() const override { return true; } @@ -70,7 +70,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeBiop; + ASTGEN_MEMBERS_AstNodeBiop; // Clone single node, just get same type back. virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) = 0; // METHODS @@ -94,7 +94,7 @@ protected: : AstNodeBiop{t, fl, lhs, rhs} {} public: - ASTGEN_MEMBERS_NodeBiCom; + ASTGEN_MEMBERS_AstNodeBiCom; }; class AstNodeBiComAsv VL_NOT_FINAL : public AstNodeBiCom { // Binary math with commutative & associative properties @@ -103,7 +103,7 @@ protected: : AstNodeBiCom{t, fl, lhs, rhs} {} public: - ASTGEN_MEMBERS_NodeBiComAsv; + ASTGEN_MEMBERS_AstNodeBiComAsv; }; class AstNodeSel VL_NOT_FINAL : public AstNodeBiop { // Single bit range extraction, perhaps with non-constant selection or array selection @@ -114,7 +114,7 @@ protected: : AstNodeBiop{t, fl, fromp, bitp} {} public: - ASTGEN_MEMBERS_NodeSel; + ASTGEN_MEMBERS_AstNodeSel; int bitConst() const; bool hasDType() const override { return true; } }; @@ -127,7 +127,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeStream; + ASTGEN_MEMBERS_AstNodeStream; }; class AstNodeSystemBiop VL_NOT_FINAL : public AstNodeBiop { public: @@ -135,7 +135,7 @@ public: : AstNodeBiop(t, fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_NodeSystemBiop; + ASTGEN_MEMBERS_AstNodeSystemBiop; bool cleanOut() const override { return false; } bool cleanLhs() const override { return false; } bool cleanRhs() const override { return false; } @@ -161,7 +161,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeQuadop; + ASTGEN_MEMBERS_AstNodeQuadop; // METHODS // Set out to evaluation of a AstConst'ed virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, @@ -185,7 +185,7 @@ protected: : AstNodeMath{t, fl} {} public: - ASTGEN_MEMBERS_NodeTermop; + ASTGEN_MEMBERS_AstNodeTermop; // Know no children, and hot function, so skip iterator for speed // cppcheck-suppress functionConst void iterateChildren(VNVisitor& v) {} @@ -205,7 +205,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeTriop; + ASTGEN_MEMBERS_AstNodeTriop; // METHODS void dump(std::ostream& str) const override; // Set out to evaluation of a AstConst'ed @@ -236,7 +236,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeCond; + ASTGEN_MEMBERS_AstNodeCond; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override; string emitVerilog() override { return "%k(%l %f? %r %k: %t)"; } @@ -262,7 +262,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeUniop; + ASTGEN_MEMBERS_AstNodeUniop; // METHODS void dump(std::ostream& str) const override; // Set out to evaluation of a AstConst'ed lhs @@ -282,7 +282,7 @@ public: : AstNodeUniop(t, fl, lhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_NodeSystemUniop; + ASTGEN_MEMBERS_AstNodeSystemUniop; bool cleanOut() const override { return true; } bool cleanLhs() const override { return false; } bool sizeMattersLhs() const override { return false; } @@ -315,7 +315,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeVarRef; + ASTGEN_MEMBERS_AstNodeVarRef; void dump(std::ostream& str) const override; bool hasDType() const override { return true; } const char* broken() const override; @@ -358,7 +358,7 @@ public: } public: - ASTGEN_MEMBERS_AddrOfCFunc; + ASTGEN_MEMBERS_AstAddrOfCFunc; void cloneRelink() override; const char* broken() const override; string emitVerilog() override { V3ERROR_NA_RETURN(""); } @@ -381,7 +381,7 @@ public: dtypeFrom(exprsp); } inline AstCMath(FileLine* fl, const string& textStmt, int setwidth, bool cleanOut = true); - ASTGEN_MEMBERS_CMath; + ASTGEN_MEMBERS_AstCMath; bool isGateOptimizable() const override { return m_pure; } bool isPredictOptimizable() const override { return m_pure; } bool cleanOut() const override { return m_cleanOut; } @@ -399,7 +399,7 @@ public: : ASTGEN_SUPER_ConsAssoc(fl) { this->defaultp(defaultp); } - ASTGEN_MEMBERS_ConsAssoc; + ASTGEN_MEMBERS_AstConsAssoc; string emitVerilog() override { return "'{}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -417,7 +417,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_ConsDynArray; + ASTGEN_MEMBERS_AstConsDynArray; string emitVerilog() override { return "'{%l, %r}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -435,7 +435,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_ConsQueue; + ASTGEN_MEMBERS_AstConsQueue; string emitVerilog() override { return "'{%l, %r}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -451,7 +451,7 @@ public: : ASTGEN_SUPER_ConsWildcard(fl) { this->defaultp(defaultp); } - ASTGEN_MEMBERS_ConsWildcard; + ASTGEN_MEMBERS_AstConsWildcard; string emitVerilog() override { return "'{}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -572,7 +572,7 @@ public: dtypeSetBit(); // Events 1 bit, objects 64 bits, so autoExtend=1 and use bit here initWithNumber(); } - ASTGEN_MEMBERS_Const; + ASTGEN_MEMBERS_AstConst; string name() const override { return num().ascii(); } // * = Value const V3Number& num() const { return m_num; } // * = Value V3Number& num() { return m_num; } // * = Value @@ -597,7 +597,7 @@ class AstEmptyQueue final : public AstNodeMath { public: explicit AstEmptyQueue(FileLine* fl) : ASTGEN_SUPER_EmptyQueue(fl) {} - ASTGEN_MEMBERS_EmptyQueue; + ASTGEN_MEMBERS_AstEmptyQueue; string emitC() override { V3ERROR_NA_RETURN(""); } string emitVerilog() override { return "{}"; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -614,7 +614,7 @@ public: , m_classOrPackagep{classOrPackagep} { dtypeFrom(m_itemp); } - ASTGEN_MEMBERS_EnumItemRef; + ASTGEN_MEMBERS_AstEnumItemRef; void dump(std::ostream& str) const override; string name() const override { return itemp()->name(); } int instrCount() const override { return 0; } @@ -646,7 +646,7 @@ public: this->resultp(resultp); dtypeFrom(resultp); } - ASTGEN_MEMBERS_ExprStmt; + ASTGEN_MEMBERS_AstExprStmt; // METHODS string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -662,7 +662,7 @@ public: this->filep(filep); this->strp(strp); } - ASTGEN_MEMBERS_FError; + ASTGEN_MEMBERS_AstFError; string emitVerilog() override { return "%f$ferror(%l, %r)"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -685,7 +685,7 @@ public: this->startp(startp); this->countp(countp); } - ASTGEN_MEMBERS_FRead; + ASTGEN_MEMBERS_AstFRead; string verilogKwd() const override { return "$fread"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -704,7 +704,7 @@ public: : ASTGEN_SUPER_FRewind(fl) { this->filep(filep); } - ASTGEN_MEMBERS_FRewind; + ASTGEN_MEMBERS_AstFRewind; string verilogKwd() const override { return "$frewind"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -729,7 +729,7 @@ public: addExprsp(exprsp); this->filep(filep); } - ASTGEN_MEMBERS_FScanF; + ASTGEN_MEMBERS_AstFScanF; string name() const override { return m_text; } string verilogKwd() const override { return "$fscanf"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } @@ -756,7 +756,7 @@ public: this->offset(offset); this->operation(operation); } - ASTGEN_MEMBERS_FSeek; + ASTGEN_MEMBERS_AstFSeek; string verilogKwd() const override { return "$fseek"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -775,7 +775,7 @@ public: : ASTGEN_SUPER_FTell(fl) { this->filep(filep); } - ASTGEN_MEMBERS_FTell; + ASTGEN_MEMBERS_AstFTell; string verilogKwd() const override { return "$ftell"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -796,7 +796,7 @@ public: : ASTGEN_SUPER_Fell(fl) { this->exprp(exprp); } - ASTGEN_MEMBERS_Fell; + ASTGEN_MEMBERS_AstFell; string emitVerilog() override { return "$fell(%l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -814,7 +814,7 @@ public: this->exprp(exprp); this->rangep(rangep); } - ASTGEN_MEMBERS_GatePin; + ASTGEN_MEMBERS_AstGatePin; string emitVerilog() override { return "%l"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -830,7 +830,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_Implication; + ASTGEN_MEMBERS_AstImplication; string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -848,7 +848,7 @@ public: this->addItemsp(itemsp); dtypeSetBit(); } - ASTGEN_MEMBERS_Inside; + ASTGEN_MEMBERS_AstInside; string emitVerilog() override { return "%l inside { %r }"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return false; } // NA @@ -862,7 +862,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_InsideRange; + ASTGEN_MEMBERS_AstInsideRange; string emitVerilog() override { return "[%l:%r]"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return false; } // NA @@ -882,7 +882,7 @@ public: : ASTGEN_SUPER_LambdaArgRef(fl) , m_name{name} , m_index(index) {} - ASTGEN_MEMBERS_LambdaArgRef; + ASTGEN_MEMBERS_AstLambdaArgRef; bool same(const AstNode* /*samep*/) const override { return true; } string emitVerilog() override { return name(); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -913,7 +913,7 @@ public: this->fromp(fromp); dtypep(dtp); } - ASTGEN_MEMBERS_MemberSel; + ASTGEN_MEMBERS_AstMemberSel; void cloneRelink() override; const char* broken() const override; void dump(std::ostream& str) const override; @@ -936,7 +936,7 @@ public: dtypeFrom(rhsp); // otherwise V3Width will resolve this->rhsp(rhsp); } - ASTGEN_MEMBERS_NewCopy; + ASTGEN_MEMBERS_AstNewCopy; string emitVerilog() override { return "new"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -955,7 +955,7 @@ public: this->sizep(sizep); this->rhsp(rhsp); } - ASTGEN_MEMBERS_NewDynamic; + ASTGEN_MEMBERS_AstNewDynamic; string emitVerilog() override { return "new"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -973,7 +973,7 @@ public: this->exprp(exprp); this->ticksp(ticksp); } - ASTGEN_MEMBERS_Past; + ASTGEN_MEMBERS_AstPast; string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -999,7 +999,7 @@ public: this->keyp(keyp); this->repp(repp); } - ASTGEN_MEMBERS_PatMember; + ASTGEN_MEMBERS_AstPatMember; string emitVerilog() override { return lhssp() ? "%f{%r{%k%l}}" : "%l"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1020,7 +1020,7 @@ public: : ASTGEN_SUPER_Pattern(fl) { addItemsp(itemsp); } - ASTGEN_MEMBERS_Pattern; + ASTGEN_MEMBERS_AstPattern; string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1048,7 +1048,7 @@ public: , m_urandom{urandom} { this->seedp(seedp); } - ASTGEN_MEMBERS_Rand; + ASTGEN_MEMBERS_AstRand; string emitVerilog() override { return seedp() ? (m_urandom ? "%f$urandom(%l)" : "%f$random(%l)") : (m_urandom ? "%f$urandom()" : "%f$random()"); @@ -1081,7 +1081,7 @@ public: : ASTGEN_SUPER_Rose(fl) { this->exprp(exprp); } - ASTGEN_MEMBERS_Rose; + ASTGEN_MEMBERS_AstRose; string emitVerilog() override { return "$rose(%l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1102,7 +1102,7 @@ public: this->addExprsp(exprsp); this->fromp(fromp); } - ASTGEN_MEMBERS_SScanF; + ASTGEN_MEMBERS_AstSScanF; string name() const override { return m_text; } string verilogKwd() const override { return "$sscanf"; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } @@ -1126,7 +1126,7 @@ public: : ASTGEN_SUPER_Sampled(fl) { this->exprp(exprp); } - ASTGEN_MEMBERS_Sampled; + ASTGEN_MEMBERS_AstSampled; string emitVerilog() override { return "$sampled(%l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1152,7 +1152,7 @@ public: , m_forFormat{forFormat} { dtypeSetUInt64(); } - ASTGEN_MEMBERS_ScopeName; + ASTGEN_MEMBERS_AstScopeName; bool same(const AstNode* samep) const override { return (m_dpiExport == static_cast(samep)->m_dpiExport && m_forFormat == static_cast(samep)->m_forFormat); @@ -1190,7 +1190,7 @@ public: this->keyp(keyp); this->valuep(valuep); } - ASTGEN_MEMBERS_SetAssoc; + ASTGEN_MEMBERS_AstSetAssoc; string emitVerilog() override { return "'{}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1211,7 +1211,7 @@ public: this->keyp(keyp); this->valuep(valuep); } - ASTGEN_MEMBERS_SetWildcard; + ASTGEN_MEMBERS_AstSetWildcard; string emitVerilog() override { return "'{}"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1228,7 +1228,7 @@ public: : ASTGEN_SUPER_Stable(fl) { this->exprp(exprp); } - ASTGEN_MEMBERS_Stable; + ASTGEN_MEMBERS_AstStable; string emitVerilog() override { return "$stable(%l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } @@ -1244,7 +1244,7 @@ public: : ASTGEN_SUPER_SystemF(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_SystemF; + ASTGEN_MEMBERS_AstSystemF; string verilogKwd() const override { return "$system"; } string emitVerilog() override { return verilogKwd(); } string emitC() override { return "VL_SYSTEM_%nq(%lw, %P)"; } @@ -1264,7 +1264,7 @@ public: : ASTGEN_SUPER_TestPlusArgs(fl) { this->searchp(searchp); } - ASTGEN_MEMBERS_TestPlusArgs; + ASTGEN_MEMBERS_AstTestPlusArgs; string verilogKwd() const override { return "$test$plusargs"; } string emitVerilog() override { return verilogKwd(); } string emitC() override { return "VL_VALUEPLUSARGS_%nq(%lw, %P, nullptr)"; } @@ -1282,7 +1282,7 @@ public: : ASTGEN_SUPER_UCFunc(fl) { this->addExprsp(exprsp); } - ASTGEN_MEMBERS_UCFunc; + ASTGEN_MEMBERS_AstUCFunc; bool cleanOut() const override { return false; } string emitVerilog() override { V3ERROR_NA_RETURN(""); } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -1302,7 +1302,7 @@ public: : ASTGEN_SUPER_Unbounded(fl) { dtypeSetSigned32(); } - ASTGEN_MEMBERS_Unbounded; + ASTGEN_MEMBERS_AstUnbounded; string emitVerilog() override { return "$"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -1317,7 +1317,7 @@ public: this->searchp(searchp); this->outp(outp); } - ASTGEN_MEMBERS_ValuePlusArgs; + ASTGEN_MEMBERS_AstValuePlusArgs; string verilogKwd() const override { return "$value$plusargs"; } string emitVerilog() override { return "%f$value$plusargs(%l, %k%r)"; } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -1338,7 +1338,7 @@ public: : ASTGEN_SUPER_BufIf1(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_BufIf1; + ASTGEN_MEMBERS_AstBufIf1; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstBufIf1(this->fileline(), lhsp, rhsp); } @@ -1365,7 +1365,7 @@ class AstCastDynamic final : public AstNodeBiop { public: AstCastDynamic(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_CastDynamic(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_CastDynamic; + ASTGEN_MEMBERS_AstCastDynamic; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } @@ -1394,7 +1394,7 @@ public: , m_ignoreCase{ignoreCase} { dtypeSetUInt32(); } - ASTGEN_MEMBERS_CompareNN; + ASTGEN_MEMBERS_AstCompareNN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstCompareNN(this->fileline(), lhsp, rhsp, m_ignoreCase); } @@ -1425,7 +1425,7 @@ public: VSigning::UNSIGNED); } } - ASTGEN_MEMBERS_Concat; + ASTGEN_MEMBERS_AstConcat; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstConcat(this->fileline(), lhsp, rhsp); } @@ -1448,7 +1448,7 @@ public: : ASTGEN_SUPER_ConcatN(fl, lhsp, rhsp) { dtypeSetString(); } - ASTGEN_MEMBERS_ConcatN; + ASTGEN_MEMBERS_AstConcatN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstConcatN(this->fileline(), lhsp, rhsp); } @@ -1471,7 +1471,7 @@ public: : ASTGEN_SUPER_Div(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Div; + ASTGEN_MEMBERS_AstDiv; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDiv(this->fileline(), lhsp, rhsp); } @@ -1493,7 +1493,7 @@ public: : ASTGEN_SUPER_DivD(fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_DivD; + ASTGEN_MEMBERS_AstDivD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDivD(this->fileline(), lhsp, rhsp); } @@ -1517,7 +1517,7 @@ public: : ASTGEN_SUPER_DivS(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_DivS; + ASTGEN_MEMBERS_AstDivS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDivS(this->fileline(), lhsp, rhsp); } @@ -1541,7 +1541,7 @@ public: : ASTGEN_SUPER_EqWild(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_EqWild; + ASTGEN_MEMBERS_AstEqWild; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqWild(this->fileline(), lhsp, rhsp); } @@ -1563,7 +1563,7 @@ class AstFGetS final : public AstNodeBiop { public: AstFGetS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_FGetS(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_FGetS; + ASTGEN_MEMBERS_AstFGetS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstFGetS(this->fileline(), lhsp, rhsp); } @@ -1588,7 +1588,7 @@ class AstFUngetC final : public AstNodeBiop { public: AstFUngetC(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_FUngetC(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_FUngetC; + ASTGEN_MEMBERS_AstFUngetC; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } @@ -1617,7 +1617,7 @@ public: : ASTGEN_SUPER_GetcN(fl, lhsp, rhsp) { dtypeSetBitSized(8, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_GetcN; + ASTGEN_MEMBERS_AstGetcN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGetcN(this->fileline(), lhsp, rhsp); } @@ -1642,7 +1642,7 @@ public: : ASTGEN_SUPER_GetcRefN(fl, lhsp, rhsp) { dtypeSetBitSized(8, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_GetcRefN; + ASTGEN_MEMBERS_AstGetcRefN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGetcRefN(this->fileline(), lhsp, rhsp); } @@ -1664,7 +1664,7 @@ public: : ASTGEN_SUPER_Gt(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Gt; + ASTGEN_MEMBERS_AstGt; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGt(this->fileline(), lhsp, rhsp); } @@ -1686,7 +1686,7 @@ public: : ASTGEN_SUPER_GtD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GtD; + ASTGEN_MEMBERS_AstGtD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtD(this->fileline(), lhsp, rhsp); } @@ -1710,7 +1710,7 @@ public: : ASTGEN_SUPER_GtN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GtN; + ASTGEN_MEMBERS_AstGtN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtN(this->fileline(), lhsp, rhsp); } @@ -1734,7 +1734,7 @@ public: : ASTGEN_SUPER_GtS(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GtS; + ASTGEN_MEMBERS_AstGtS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtS(this->fileline(), lhsp, rhsp); } @@ -1757,7 +1757,7 @@ public: : ASTGEN_SUPER_Gte(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Gte; + ASTGEN_MEMBERS_AstGte; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGte(this->fileline(), lhsp, rhsp); } @@ -1779,7 +1779,7 @@ public: : ASTGEN_SUPER_GteD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GteD; + ASTGEN_MEMBERS_AstGteD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteD(this->fileline(), lhsp, rhsp); } @@ -1803,7 +1803,7 @@ public: : ASTGEN_SUPER_GteN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GteN; + ASTGEN_MEMBERS_AstGteN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteN(this->fileline(), lhsp, rhsp); } @@ -1827,7 +1827,7 @@ public: : ASTGEN_SUPER_GteS(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_GteS; + ASTGEN_MEMBERS_AstGteS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteS(this->fileline(), lhsp, rhsp); } @@ -1850,7 +1850,7 @@ public: : ASTGEN_SUPER_LogAnd(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LogAnd; + ASTGEN_MEMBERS_AstLogAnd; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogAnd(this->fileline(), lhsp, rhsp); } @@ -1873,7 +1873,7 @@ public: : ASTGEN_SUPER_LogIf(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LogIf; + ASTGEN_MEMBERS_AstLogIf; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogIf(this->fileline(), lhsp, rhsp); } @@ -1901,7 +1901,7 @@ public: : ASTGEN_SUPER_LogOr(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LogOr; + ASTGEN_MEMBERS_AstLogOr; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogOr(this->fileline(), lhsp, rhsp); } @@ -1932,7 +1932,7 @@ public: : ASTGEN_SUPER_Lt(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Lt; + ASTGEN_MEMBERS_AstLt; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLt(this->fileline(), lhsp, rhsp); } @@ -1954,7 +1954,7 @@ public: : ASTGEN_SUPER_LtD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LtD; + ASTGEN_MEMBERS_AstLtD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtD(this->fileline(), lhsp, rhsp); } @@ -1978,7 +1978,7 @@ public: : ASTGEN_SUPER_LtN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LtN; + ASTGEN_MEMBERS_AstLtN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtN(this->fileline(), lhsp, rhsp); } @@ -2002,7 +2002,7 @@ public: : ASTGEN_SUPER_LtS(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LtS; + ASTGEN_MEMBERS_AstLtS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtS(this->fileline(), lhsp, rhsp); } @@ -2025,7 +2025,7 @@ public: : ASTGEN_SUPER_Lte(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Lte; + ASTGEN_MEMBERS_AstLte; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLte(this->fileline(), lhsp, rhsp); } @@ -2047,7 +2047,7 @@ public: : ASTGEN_SUPER_LteD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LteD; + ASTGEN_MEMBERS_AstLteD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteD(this->fileline(), lhsp, rhsp); } @@ -2071,7 +2071,7 @@ public: : ASTGEN_SUPER_LteN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LteN; + ASTGEN_MEMBERS_AstLteN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteN(this->fileline(), lhsp, rhsp); } @@ -2095,7 +2095,7 @@ public: : ASTGEN_SUPER_LteS(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LteS; + ASTGEN_MEMBERS_AstLteS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteS(this->fileline(), lhsp, rhsp); } @@ -2118,7 +2118,7 @@ public: : ASTGEN_SUPER_ModDiv(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_ModDiv; + ASTGEN_MEMBERS_AstModDiv; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstModDiv(this->fileline(), lhsp, rhsp); } @@ -2140,7 +2140,7 @@ public: : ASTGEN_SUPER_ModDivS(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_ModDivS; + ASTGEN_MEMBERS_AstModDivS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstModDivS(this->fileline(), lhsp, rhsp); } @@ -2163,7 +2163,7 @@ public: : ASTGEN_SUPER_NeqWild(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_NeqWild; + ASTGEN_MEMBERS_AstNeqWild; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqWild(this->fileline(), lhsp, rhsp); } @@ -2185,7 +2185,7 @@ public: : ASTGEN_SUPER_Pow(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Pow; + ASTGEN_MEMBERS_AstPow; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPow(this->fileline(), lhsp, rhsp); } @@ -2208,7 +2208,7 @@ public: : ASTGEN_SUPER_PowD(fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_PowD; + ASTGEN_MEMBERS_AstPowD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowD(this->fileline(), lhsp, rhsp); } @@ -2231,7 +2231,7 @@ public: : ASTGEN_SUPER_PowSS(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_PowSS; + ASTGEN_MEMBERS_AstPowSS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowSS(this->fileline(), lhsp, rhsp); } @@ -2255,7 +2255,7 @@ public: : ASTGEN_SUPER_PowSU(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_PowSU; + ASTGEN_MEMBERS_AstPowSU; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowSU(this->fileline(), lhsp, rhsp); } @@ -2279,7 +2279,7 @@ public: : ASTGEN_SUPER_PowUS(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_PowUS; + ASTGEN_MEMBERS_AstPowUS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowUS(this->fileline(), lhsp, rhsp); } @@ -2313,7 +2313,7 @@ public: } AstReplicate(FileLine* fl, AstNode* lhsp, uint32_t repCount) : AstReplicate(fl, lhsp, new AstConst(fl, repCount)) {} - ASTGEN_MEMBERS_Replicate; + ASTGEN_MEMBERS_AstReplicate; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstReplicate(this->fileline(), lhsp, rhsp); } @@ -2338,7 +2338,7 @@ public: } AstReplicateN(FileLine* fl, AstNode* lhsp, uint32_t repCount) : AstReplicateN(fl, lhsp, new AstConst(fl, repCount)) {} - ASTGEN_MEMBERS_ReplicateN; + ASTGEN_MEMBERS_AstReplicateN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstReplicateN(this->fileline(), lhsp, rhsp); } @@ -2361,7 +2361,7 @@ public: : ASTGEN_SUPER_ShiftL(fl, lhsp, rhsp) { if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_ShiftL; + ASTGEN_MEMBERS_AstShiftL; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftL(this->fileline(), lhsp, rhsp); } @@ -2385,7 +2385,7 @@ public: : ASTGEN_SUPER_ShiftR(fl, lhsp, rhsp) { if (setwidth) dtypeSetLogicSized(setwidth, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_ShiftR; + ASTGEN_MEMBERS_AstShiftR; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftR(this->fileline(), lhsp, rhsp); } @@ -2413,7 +2413,7 @@ public: // Important that widthMin be correct, as opExtend requires it after V3Expand if (setwidth) dtypeSetLogicSized(setwidth, VSigning::SIGNED); } - ASTGEN_MEMBERS_ShiftRS; + ASTGEN_MEMBERS_AstShiftRS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftRS(this->fileline(), lhsp, rhsp); } @@ -2436,7 +2436,7 @@ public: : ASTGEN_SUPER_Sub(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Sub; + ASTGEN_MEMBERS_AstSub; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstSub(this->fileline(), lhsp, rhsp); } @@ -2458,7 +2458,7 @@ public: : ASTGEN_SUPER_SubD(fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_SubD; + ASTGEN_MEMBERS_AstSubD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstSubD(this->fileline(), lhsp, rhsp); } @@ -2483,7 +2483,7 @@ public: : ASTGEN_SUPER_URandomRange(fl, lhsp, rhsp) { dtypeSetUInt32(); // Says IEEE } - ASTGEN_MEMBERS_URandomRange; + ASTGEN_MEMBERS_AstURandomRange; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstURandomRange(fileline(), lhsp, rhsp); } @@ -2509,7 +2509,7 @@ public: : ASTGEN_SUPER_Eq(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Eq; + ASTGEN_MEMBERS_AstEq; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEq(this->fileline(), lhsp, rhsp); } @@ -2533,7 +2533,7 @@ public: : ASTGEN_SUPER_EqCase(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_EqCase; + ASTGEN_MEMBERS_AstEqCase; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqCase(this->fileline(), lhsp, rhsp); } @@ -2555,7 +2555,7 @@ public: : ASTGEN_SUPER_EqD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_EqD; + ASTGEN_MEMBERS_AstEqD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqD(this->fileline(), lhsp, rhsp); } @@ -2579,7 +2579,7 @@ public: : ASTGEN_SUPER_EqN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_EqN; + ASTGEN_MEMBERS_AstEqN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqN(this->fileline(), lhsp, rhsp); } @@ -2603,7 +2603,7 @@ public: : ASTGEN_SUPER_LogEq(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LogEq; + ASTGEN_MEMBERS_AstLogEq; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogEq(this->fileline(), lhsp, rhsp); } @@ -2626,7 +2626,7 @@ public: : ASTGEN_SUPER_Neq(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_Neq; + ASTGEN_MEMBERS_AstNeq; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeq(this->fileline(), lhsp, rhsp); } @@ -2648,7 +2648,7 @@ public: : ASTGEN_SUPER_NeqCase(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_NeqCase; + ASTGEN_MEMBERS_AstNeqCase; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqCase(this->fileline(), lhsp, rhsp); } @@ -2670,7 +2670,7 @@ public: : ASTGEN_SUPER_NeqD(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_NeqD; + ASTGEN_MEMBERS_AstNeqD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqD(this->fileline(), lhsp, rhsp); } @@ -2694,7 +2694,7 @@ public: : ASTGEN_SUPER_NeqN(fl, lhsp, rhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_NeqN; + ASTGEN_MEMBERS_AstNeqN; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqN(this->fileline(), lhsp, rhsp); } @@ -2720,7 +2720,7 @@ public: : ASTGEN_SUPER_Add(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Add; + ASTGEN_MEMBERS_AstAdd; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAdd(this->fileline(), lhsp, rhsp); } @@ -2742,7 +2742,7 @@ public: : ASTGEN_SUPER_AddD(fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_AddD; + ASTGEN_MEMBERS_AstAddD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAddD(this->fileline(), lhsp, rhsp); } @@ -2766,7 +2766,7 @@ public: : ASTGEN_SUPER_And(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_And; + ASTGEN_MEMBERS_AstAnd; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAnd(this->fileline(), lhsp, rhsp); } @@ -2788,7 +2788,7 @@ public: : ASTGEN_SUPER_Mul(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Mul; + ASTGEN_MEMBERS_AstMul; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMul(this->fileline(), lhsp, rhsp); } @@ -2811,7 +2811,7 @@ public: : ASTGEN_SUPER_MulD(fl, lhsp, rhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_MulD; + ASTGEN_MEMBERS_AstMulD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMulD(this->fileline(), lhsp, rhsp); } @@ -2835,7 +2835,7 @@ public: : ASTGEN_SUPER_MulS(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_MulS; + ASTGEN_MEMBERS_AstMulS; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMulS(this->fileline(), lhsp, rhsp); } @@ -2860,7 +2860,7 @@ public: : ASTGEN_SUPER_Or(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Or; + ASTGEN_MEMBERS_AstOr; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstOr(this->fileline(), lhsp, rhsp); } @@ -2882,7 +2882,7 @@ public: : ASTGEN_SUPER_Xor(fl, lhsp, rhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Xor; + ASTGEN_MEMBERS_AstXor; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstXor(this->fileline(), lhsp, rhsp); } @@ -2920,7 +2920,7 @@ public: : ASTGEN_SUPER_ArraySel(fl, fromp, new AstConst(fl, bit)) { init(fromp); } - ASTGEN_MEMBERS_ArraySel; + ASTGEN_MEMBERS_AstArraySel; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstArraySel(this->fileline(), lhsp, rhsp); } @@ -2958,7 +2958,7 @@ public: : ASTGEN_SUPER_AssocSel(fl, fromp, bitp) { init(fromp); } - ASTGEN_MEMBERS_AssocSel; + ASTGEN_MEMBERS_AstAssocSel; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssocSel(this->fileline(), lhsp, rhsp); } @@ -2993,7 +2993,7 @@ public: : ASTGEN_SUPER_WildcardSel(fl, fromp, bitp) { init(fromp); } - ASTGEN_MEMBERS_WildcardSel; + ASTGEN_MEMBERS_AstWildcardSel; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstWildcardSel{this->fileline(), lhsp, rhsp}; } @@ -3019,7 +3019,7 @@ public: : ASTGEN_SUPER_WordSel(fl, fromp, bitp) { dtypeSetUInt32(); // Always used on WData arrays so returns edata size } - ASTGEN_MEMBERS_WordSel; + ASTGEN_MEMBERS_AstWordSel; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstWordSel(this->fileline(), lhsp, rhsp); } @@ -3044,7 +3044,7 @@ class AstStreamL final : public AstNodeStream { public: AstStreamL(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_StreamL(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_StreamL; + ASTGEN_MEMBERS_AstStreamL; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstStreamL(this->fileline(), lhsp, rhsp); } @@ -3065,7 +3065,7 @@ class AstStreamR final : public AstNodeStream { public: AstStreamR(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_StreamR(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_StreamR; + ASTGEN_MEMBERS_AstStreamR; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstStreamR(this->fileline(), lhsp, rhsp); } @@ -3087,7 +3087,7 @@ class AstAtan2D final : public AstNodeSystemBiop { public: AstAtan2D(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_Atan2D(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_Atan2D; + ASTGEN_MEMBERS_AstAtan2D; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAtan2D(this->fileline(), lhsp, rhsp); } @@ -3101,7 +3101,7 @@ class AstHypotD final : public AstNodeSystemBiop { public: AstHypotD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_HypotD(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_HypotD; + ASTGEN_MEMBERS_AstHypotD; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstHypotD(this->fileline(), lhsp, rhsp); } @@ -3123,7 +3123,7 @@ public: : ASTGEN_SUPER_CountBits(fl, exprp, ctrl1p, ctrl2p, ctrl2p->cloneTree(false)) {} AstCountBits(FileLine* fl, AstNode* exprp, AstNode* ctrl1p, AstNode* ctrl2p, AstNode* ctrl3p) : ASTGEN_SUPER_CountBits(fl, exprp, ctrl1p, ctrl2p, ctrl3p) {} - ASTGEN_MEMBERS_CountBits; + ASTGEN_MEMBERS_AstCountBits; void numberOperate(V3Number& out, const V3Number& expr, const V3Number& ctrl1, const V3Number& ctrl2, const V3Number& ctrl3) override { out.opCountBits(expr, ctrl1, ctrl2, ctrl3); @@ -3151,7 +3151,7 @@ public: , m_timeunit{timeunit} { dtypeSetUInt64(); } - ASTGEN_MEMBERS_Time; + ASTGEN_MEMBERS_AstTime; string emitVerilog() override { return "%f$time"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -3171,7 +3171,7 @@ public: , m_timeunit{timeunit} { dtypeSetDouble(); } - ASTGEN_MEMBERS_TimeD; + ASTGEN_MEMBERS_AstTimeD; string emitVerilog() override { return "%f$realtime"; } string emitC() override { V3ERROR_NA_RETURN(""); } bool cleanOut() const override { return true; } @@ -3194,7 +3194,7 @@ class AstPostAdd final : public AstNodeTriop { public: AstPostAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) : ASTGEN_SUPER_PostAdd(fl, lhsp, rhsp, thsp) {} - ASTGEN_MEMBERS_PostAdd; + ASTGEN_MEMBERS_AstPostAdd; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs @@ -3219,7 +3219,7 @@ class AstPostSub final : public AstNodeTriop { public: AstPostSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) : ASTGEN_SUPER_PostSub(fl, lhsp, rhsp, thsp) {} - ASTGEN_MEMBERS_PostSub; + ASTGEN_MEMBERS_AstPostSub; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs @@ -3244,7 +3244,7 @@ class AstPreAdd final : public AstNodeTriop { public: AstPreAdd(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) : ASTGEN_SUPER_PreAdd(fl, lhsp, rhsp, thsp) {} - ASTGEN_MEMBERS_PreAdd; + ASTGEN_MEMBERS_AstPreAdd; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs @@ -3269,7 +3269,7 @@ class AstPreSub final : public AstNodeTriop { public: AstPreSub(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* thsp) : ASTGEN_SUPER_PreSub(fl, lhsp, rhsp, thsp) {} - ASTGEN_MEMBERS_PreSub; + ASTGEN_MEMBERS_AstPreSub; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs @@ -3292,7 +3292,7 @@ public: : ASTGEN_SUPER_PutcN(fl, lhsp, rhsp, ths) { dtypeSetString(); } - ASTGEN_MEMBERS_PutcN; + ASTGEN_MEMBERS_AstPutcN; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { out.opPutcN(lhs, rhs, ths); @@ -3332,7 +3332,7 @@ public: , m_declElWidth{1} { dtypeSetLogicSized(bitwidth, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_Sel; + ASTGEN_MEMBERS_AstSel; void dump(std::ostream& str) const override; void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit, const V3Number& width) override { @@ -3373,7 +3373,7 @@ public: : ASTGEN_SUPER_SliceSel(fl, fromp, new AstConst(fl, declRange.lo()), new AstConst(fl, declRange.elements())) , m_declRange{declRange} {} - ASTGEN_MEMBERS_SliceSel; + ASTGEN_MEMBERS_AstSliceSel; void dump(std::ostream& str) const override; void numberOperate(V3Number& out, const V3Number& from, const V3Number& lo, const V3Number& width) override { @@ -3402,7 +3402,7 @@ public: : ASTGEN_SUPER_SubstrN(fl, lhsp, rhsp, ths) { dtypeSetString(); } - ASTGEN_MEMBERS_SubstrN; + ASTGEN_MEMBERS_AstSubstrN; void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) override { out.opSubstrN(lhs, rhs, ths); @@ -3428,7 +3428,7 @@ class AstCond final : public AstNodeCond { public: AstCond(FileLine* fl, AstNode* condp, AstNode* thenp, AstNode* elsep) : ASTGEN_SUPER_Cond(fl, condp, thenp, elsep) {} - ASTGEN_MEMBERS_Cond; + ASTGEN_MEMBERS_AstCond; AstNode* cloneType(AstNode* condp, AstNode* thenp, AstNode* elsep) override { return new AstCond(this->fileline(), condp, thenp, elsep); } @@ -3440,7 +3440,7 @@ class AstCondBound final : public AstNodeCond { public: AstCondBound(FileLine* fl, AstNode* condp, AstNode* thenp, AstNode* elsep) : ASTGEN_SUPER_CondBound(fl, condp, thenp, elsep) {} - ASTGEN_MEMBERS_CondBound; + ASTGEN_MEMBERS_AstCondBound; AstNode* cloneType(AstNode* condp, AstNode* thenp, AstNode* elsep) override { return new AstCondBound(this->fileline(), condp, thenp, elsep); } @@ -3460,7 +3460,7 @@ public: , m_fmt{fmt} { fmt == ATOREAL ? dtypeSetDouble() : dtypeSetSigned32(); } - ASTGEN_MEMBERS_AtoN; + ASTGEN_MEMBERS_AstAtoN; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAtoN(lhs, m_fmt); } string name() const override { switch (m_fmt) { @@ -3494,7 +3494,7 @@ public: : ASTGEN_SUPER_BitsToRealD(fl, lhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_BitsToRealD; + ASTGEN_MEMBERS_AstBitsToRealD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opBitsToRealD(lhs); } string emitVerilog() override { return "%f$bitstoreal(%l)"; } string emitC() override { return "VL_CVT_D_Q(%li)"; } @@ -3522,7 +3522,7 @@ public: dtypeFrom(typeFromp); m_size = width(); } - ASTGEN_MEMBERS_CCast; + ASTGEN_MEMBERS_AstCCast; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); } string emitVerilog() override { return "%f$_CAST(%l)"; } string emitC() override { return "VL_CAST_%nq%lq(%nw,%lw, %P, %li)"; } @@ -3542,7 +3542,7 @@ public: : ASTGEN_SUPER_CLog2(fl, lhsp) { dtypeSetSigned32(); } - ASTGEN_MEMBERS_CLog2; + ASTGEN_MEMBERS_AstCLog2; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opCLog2(lhs); } string emitVerilog() override { return "%f$clog2(%l)"; } string emitC() override { return "VL_CLOG2_%lq(%lW, %P, %li)"; } @@ -3556,7 +3556,7 @@ class AstCountOnes final : public AstNodeUniop { public: AstCountOnes(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_CountOnes(fl, lhsp) {} - ASTGEN_MEMBERS_CountOnes; + ASTGEN_MEMBERS_AstCountOnes; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opCountOnes(lhs); } string emitVerilog() override { return "%f$countones(%l)"; } string emitC() override { return "VL_COUNTONES_%lq(%lW, %P, %li)"; } @@ -3572,7 +3572,7 @@ public: : ASTGEN_SUPER_CvtPackString(fl, lhsp) { dtypeSetString(); } - ASTGEN_MEMBERS_CvtPackString; + ASTGEN_MEMBERS_AstCvtPackString; void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } string emitVerilog() override { return "%f$_CAST(%l)"; } string emitC() override { return "VL_CVT_PACK_STR_N%lq(%lW, %li)"; } @@ -3590,7 +3590,7 @@ public: : ASTGEN_SUPER_Extend(fl, lhsp) { dtypeSetLogicSized(width, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_Extend; + ASTGEN_MEMBERS_AstExtend; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); } string emitVerilog() override { return "%l"; } string emitC() override { return "VL_EXTEND_%nq%lq(%nw,%lw, %P, %li)"; } @@ -3611,7 +3611,7 @@ public: : ASTGEN_SUPER_ExtendS(fl, lhsp) { dtypeSetLogicSized(width, VSigning::UNSIGNED); } - ASTGEN_MEMBERS_ExtendS; + ASTGEN_MEMBERS_AstExtendS; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opExtendS(lhs, lhsp()->widthMinV()); } @@ -3629,7 +3629,7 @@ class AstFEof final : public AstNodeUniop { public: AstFEof(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_FEof(fl, lhsp) {} - ASTGEN_MEMBERS_FEof; + ASTGEN_MEMBERS_AstFEof; void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } string emitVerilog() override { return "%f$feof(%l)"; } string emitC() override { return "(%li ? feof(VL_CVT_I_FP(%li)) : true)"; } @@ -3644,7 +3644,7 @@ class AstFGetC final : public AstNodeUniop { public: AstFGetC(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_FGetC(fl, lhsp) {} - ASTGEN_MEMBERS_FGetC; + ASTGEN_MEMBERS_AstFGetC; void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } string emitVerilog() override { return "%f$fgetc(%l)"; } // Non-existent filehandle returns EOF @@ -3663,7 +3663,7 @@ public: : ASTGEN_SUPER_ISToRD(fl, lhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_ISToRD; + ASTGEN_MEMBERS_AstISToRD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opISToRD(lhs); } string emitVerilog() override { return "%f$itor($signed(%l))"; } string emitC() override { return "VL_ISTOR_D_%lq(%lw, %li)"; } @@ -3680,7 +3680,7 @@ public: : ASTGEN_SUPER_IToRD(fl, lhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_IToRD; + ASTGEN_MEMBERS_AstIToRD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opIToRD(lhs); } string emitVerilog() override { return "%f$itor(%l)"; } string emitC() override { return "VL_ITOR_D_%lq(%lw, %li)"; } @@ -3696,7 +3696,7 @@ public: : ASTGEN_SUPER_IsUnbounded(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_IsUnbounded; + ASTGEN_MEMBERS_AstIsUnbounded; void numberOperate(V3Number& out, const V3Number&) override { // Any constant isn't unbounded out.setZero(); @@ -3714,7 +3714,7 @@ public: : ASTGEN_SUPER_IsUnknown(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_IsUnknown; + ASTGEN_MEMBERS_AstIsUnknown; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opIsUnknown(lhs); } string emitVerilog() override { return "%f$isunknown(%l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -3729,7 +3729,7 @@ public: : ASTGEN_SUPER_LenN(fl, lhsp) { dtypeSetSigned32(); } - ASTGEN_MEMBERS_LenN; + ASTGEN_MEMBERS_AstLenN; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLenN(lhs); } string emitVerilog() override { return "%f(%l)"; } string emitC() override { return "VL_LEN_IN(%li)"; } @@ -3743,7 +3743,7 @@ public: : ASTGEN_SUPER_LogNot(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_LogNot; + ASTGEN_MEMBERS_AstLogNot; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLogNot(lhs); } string emitVerilog() override { return "%f(! %l)"; } string emitC() override { return "VL_LOGNOT_%nq%lq(%nw,%lw, %P, %li)"; } @@ -3758,7 +3758,7 @@ public: : ASTGEN_SUPER_Negate(fl, lhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Negate; + ASTGEN_MEMBERS_AstNegate; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegate(lhs); } string emitVerilog() override { return "%f(- %l)"; } string emitC() override { return "VL_NEGATE_%lq(%lW, %P, %li)"; } @@ -3773,7 +3773,7 @@ public: : ASTGEN_SUPER_NegateD(fl, lhsp) { dtypeSetDouble(); } - ASTGEN_MEMBERS_NegateD; + ASTGEN_MEMBERS_AstNegateD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegateD(lhs); } string emitVerilog() override { return "%f(- %l)"; } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -3790,7 +3790,7 @@ public: : ASTGEN_SUPER_Not(fl, lhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Not; + ASTGEN_MEMBERS_AstNot; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNot(lhs); } string emitVerilog() override { return "%f(~ %l)"; } string emitC() override { return "VL_NOT_%lq(%lW, %P, %li)"; } @@ -3807,7 +3807,7 @@ public: : ASTGEN_SUPER_NullCheck(fl, lhsp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_NullCheck; + ASTGEN_MEMBERS_AstNullCheck; void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } int instrCount() const override { return 1; } // Rarely executes string emitVerilog() override { return "%l"; } @@ -3825,7 +3825,7 @@ public: : ASTGEN_SUPER_OneHot(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_OneHot; + ASTGEN_MEMBERS_AstOneHot; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot(lhs); } string emitVerilog() override { return "%f$onehot(%l)"; } string emitC() override { return "VL_ONEHOT_%lq(%lW, %P, %li)"; } @@ -3841,7 +3841,7 @@ public: : ASTGEN_SUPER_OneHot0(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_OneHot0; + ASTGEN_MEMBERS_AstOneHot0; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot0(lhs); } string emitVerilog() override { return "%f$onehot0(%l)"; } string emitC() override { return "VL_ONEHOT0_%lq(%lW, %P, %li)"; } @@ -3857,7 +3857,7 @@ public: : ASTGEN_SUPER_RToIRoundS(fl, lhsp) { dtypeSetSigned32(); } - ASTGEN_MEMBERS_RToIRoundS; + ASTGEN_MEMBERS_AstRToIRoundS; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRToIRoundS(lhs); } string emitVerilog() override { return "%f$rtoi_rounded(%l)"; } string emitC() override { @@ -3875,7 +3875,7 @@ public: : ASTGEN_SUPER_RToIS(fl, lhsp) { dtypeSetSigned32(); } - ASTGEN_MEMBERS_RToIS; + ASTGEN_MEMBERS_AstRToIS; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRToIS(lhs); } string emitVerilog() override { return "%f$rtoi(%l)"; } string emitC() override { return "VL_RTOI_I_D(%li)"; } @@ -3890,7 +3890,7 @@ public: : ASTGEN_SUPER_RealToBits(fl, lhsp) { dtypeSetUInt64(); } - ASTGEN_MEMBERS_RealToBits; + ASTGEN_MEMBERS_AstRealToBits; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRealToBits(lhs); } string emitVerilog() override { return "%f$realtobits(%l)"; } string emitC() override { return "VL_CVT_Q_D(%li)"; } @@ -3905,7 +3905,7 @@ public: : ASTGEN_SUPER_RedAnd(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_RedAnd; + ASTGEN_MEMBERS_AstRedAnd; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedAnd(lhs); } string emitVerilog() override { return "%f(& %l)"; } string emitC() override { return "VL_REDAND_%nq%lq(%lw, %P, %li)"; } @@ -3919,7 +3919,7 @@ public: : ASTGEN_SUPER_RedOr(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_RedOr; + ASTGEN_MEMBERS_AstRedOr; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedOr(lhs); } string emitVerilog() override { return "%f(| %l)"; } string emitC() override { return "VL_REDOR_%lq(%lW, %P, %li)"; } @@ -3933,7 +3933,7 @@ public: : ASTGEN_SUPER_RedXor(fl, lhsp) { dtypeSetBit(); } - ASTGEN_MEMBERS_RedXor; + ASTGEN_MEMBERS_AstRedXor; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedXor(lhs); } string emitVerilog() override { return "%f(^ %l)"; } string emitC() override { return "VL_REDXOR_%lq(%lW, %P, %li)"; } @@ -3953,7 +3953,7 @@ public: UASSERT_OBJ(!v3Global.assertDTypesResolved(), this, "not coded to create after dtypes resolved"); } - ASTGEN_MEMBERS_Signed; + ASTGEN_MEMBERS_AstSigned; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); out.isSigned(false); @@ -3971,7 +3971,7 @@ class AstTimeImport final : public AstNodeUniop { public: AstTimeImport(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_TimeImport(fl, lhsp) {} - ASTGEN_MEMBERS_TimeImport; + ASTGEN_MEMBERS_AstTimeImport; void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } string emitVerilog() override { return "%l"; } string emitC() override { V3ERROR_NA_RETURN(""); } @@ -3989,7 +3989,7 @@ public: : ASTGEN_SUPER_ToLowerN(fl, lhsp) { dtypeSetString(); } - ASTGEN_MEMBERS_ToLowerN; + ASTGEN_MEMBERS_AstToLowerN; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opToLowerN(lhs); } string emitVerilog() override { return "%l.tolower()"; } string emitC() override { return "VL_TOLOWER_NN(%li)"; } @@ -4004,7 +4004,7 @@ public: : ASTGEN_SUPER_ToUpperN(fl, lhsp) { dtypeSetString(); } - ASTGEN_MEMBERS_ToUpperN; + ASTGEN_MEMBERS_AstToUpperN; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opToUpperN(lhs); } string emitVerilog() override { return "%l.toupper()"; } string emitC() override { return "VL_TOUPPER_NN(%li)"; } @@ -4020,7 +4020,7 @@ public: UASSERT_OBJ(!v3Global.assertDTypesResolved(), this, "not coded to create after dtypes resolved"); } - ASTGEN_MEMBERS_Unsigned; + ASTGEN_MEMBERS_AstUnsigned; void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); out.isSigned(false); @@ -4038,7 +4038,7 @@ class AstAcosD final : public AstNodeSystemUniop { public: AstAcosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AcosD(fl, lhsp) {} - ASTGEN_MEMBERS_AcosD; + ASTGEN_MEMBERS_AstAcosD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::acos(lhs.toDouble())); } @@ -4049,7 +4049,7 @@ class AstAcoshD final : public AstNodeSystemUniop { public: AstAcoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AcoshD(fl, lhsp) {} - ASTGEN_MEMBERS_AcoshD; + ASTGEN_MEMBERS_AstAcoshD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::acosh(lhs.toDouble())); } @@ -4060,7 +4060,7 @@ class AstAsinD final : public AstNodeSystemUniop { public: AstAsinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AsinD(fl, lhsp) {} - ASTGEN_MEMBERS_AsinD; + ASTGEN_MEMBERS_AstAsinD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::asin(lhs.toDouble())); } @@ -4071,7 +4071,7 @@ class AstAsinhD final : public AstNodeSystemUniop { public: AstAsinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AsinhD(fl, lhsp) {} - ASTGEN_MEMBERS_AsinhD; + ASTGEN_MEMBERS_AstAsinhD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::asinh(lhs.toDouble())); } @@ -4082,7 +4082,7 @@ class AstAtanD final : public AstNodeSystemUniop { public: AstAtanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AtanD(fl, lhsp) {} - ASTGEN_MEMBERS_AtanD; + ASTGEN_MEMBERS_AstAtanD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::atan(lhs.toDouble())); } @@ -4093,7 +4093,7 @@ class AstAtanhD final : public AstNodeSystemUniop { public: AstAtanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_AtanhD(fl, lhsp) {} - ASTGEN_MEMBERS_AtanhD; + ASTGEN_MEMBERS_AstAtanhD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::atanh(lhs.toDouble())); } @@ -4104,7 +4104,7 @@ class AstCeilD final : public AstNodeSystemUniop { public: AstCeilD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_CeilD(fl, lhsp) {} - ASTGEN_MEMBERS_CeilD; + ASTGEN_MEMBERS_AstCeilD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::ceil(lhs.toDouble())); } @@ -4115,7 +4115,7 @@ class AstCosD final : public AstNodeSystemUniop { public: AstCosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_CosD(fl, lhsp) {} - ASTGEN_MEMBERS_CosD; + ASTGEN_MEMBERS_AstCosD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::cos(lhs.toDouble())); } @@ -4126,7 +4126,7 @@ class AstCoshD final : public AstNodeSystemUniop { public: AstCoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_CoshD(fl, lhsp) {} - ASTGEN_MEMBERS_CoshD; + ASTGEN_MEMBERS_AstCoshD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::cosh(lhs.toDouble())); } @@ -4137,7 +4137,7 @@ class AstExpD final : public AstNodeSystemUniop { public: AstExpD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_ExpD(fl, lhsp) {} - ASTGEN_MEMBERS_ExpD; + ASTGEN_MEMBERS_AstExpD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::exp(lhs.toDouble())); } @@ -4148,7 +4148,7 @@ class AstFloorD final : public AstNodeSystemUniop { public: AstFloorD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_FloorD(fl, lhsp) {} - ASTGEN_MEMBERS_FloorD; + ASTGEN_MEMBERS_AstFloorD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::floor(lhs.toDouble())); } @@ -4159,7 +4159,7 @@ class AstLog10D final : public AstNodeSystemUniop { public: AstLog10D(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_Log10D(fl, lhsp) {} - ASTGEN_MEMBERS_Log10D; + ASTGEN_MEMBERS_AstLog10D; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::log10(lhs.toDouble())); } @@ -4170,7 +4170,7 @@ class AstLogD final : public AstNodeSystemUniop { public: AstLogD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_LogD(fl, lhsp) {} - ASTGEN_MEMBERS_LogD; + ASTGEN_MEMBERS_AstLogD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::log(lhs.toDouble())); } @@ -4181,7 +4181,7 @@ class AstSinD final : public AstNodeSystemUniop { public: AstSinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_SinD(fl, lhsp) {} - ASTGEN_MEMBERS_SinD; + ASTGEN_MEMBERS_AstSinD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::sin(lhs.toDouble())); } @@ -4192,7 +4192,7 @@ class AstSinhD final : public AstNodeSystemUniop { public: AstSinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_SinhD(fl, lhsp) {} - ASTGEN_MEMBERS_SinhD; + ASTGEN_MEMBERS_AstSinhD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::sinh(lhs.toDouble())); } @@ -4203,7 +4203,7 @@ class AstSqrtD final : public AstNodeSystemUniop { public: AstSqrtD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_SqrtD(fl, lhsp) {} - ASTGEN_MEMBERS_SqrtD; + ASTGEN_MEMBERS_AstSqrtD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::sqrt(lhs.toDouble())); } @@ -4214,7 +4214,7 @@ class AstTanD final : public AstNodeSystemUniop { public: AstTanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_TanD(fl, lhsp) {} - ASTGEN_MEMBERS_TanD; + ASTGEN_MEMBERS_AstTanD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::tan(lhs.toDouble())); } @@ -4225,7 +4225,7 @@ class AstTanhD final : public AstNodeSystemUniop { public: AstTanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER_TanhD(fl, lhsp) {} - ASTGEN_MEMBERS_TanhD; + ASTGEN_MEMBERS_AstTanhD; void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(std::tanh(lhs.toDouble())); } @@ -4244,7 +4244,7 @@ public: inline AstVarRef(FileLine* fl, AstVar* varp, const VAccess& access); // This form only allowed post-link (see above) inline AstVarRef(FileLine* fl, AstVarScope* varscp, const VAccess& access); - ASTGEN_MEMBERS_VarRef; + ASTGEN_MEMBERS_AstVarRef; void dump(std::ostream& str) const override; bool same(const AstNode* samep) const override; inline bool same(const AstVarRef* samep) const; @@ -4267,7 +4267,7 @@ public: : ASTGEN_SUPER_VarXRef(fl, name, nullptr, access) , m_dotted{dotted} {} inline AstVarXRef(FileLine* fl, AstVar* varp, const string& dotted, const VAccess& access); - ASTGEN_MEMBERS_VarXRef; + ASTGEN_MEMBERS_AstVarXRef; void dump(std::ostream& str) const override; string dotted() const { return m_dotted; } void dotted(const string& dotted) { m_dotted = dotted; } diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h index dcf3afbb3..3ef73b94a 100644 --- a/src/V3AstNodeOther.h +++ b/src/V3AstNodeOther.h @@ -46,7 +46,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeBlock; + ASTGEN_MEMBERS_AstNodeBlock; void dump(std::ostream& str) const override; string name() const override { return m_name; } // * = Block name void name(const string& name) override { m_name = name; } @@ -116,7 +116,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeFTask; + ASTGEN_MEMBERS_AstNodeFTask; void dump(std::ostream& str = std::cout) const override; string name() const override { return m_name; } // * = Var name bool maybePointedTo() const override { return true; } @@ -184,7 +184,7 @@ public: AstNodeFile(VNType t, FileLine* fl, const string& name) : AstNode{t, fl} , m_name{name} {} - ASTGEN_MEMBERS_NodeFile; + ASTGEN_MEMBERS_AstNodeFile; void dump(std::ostream& str) const override; string name() const override { return m_name; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -228,7 +228,7 @@ protected: , m_recursiveClone{false} {} public: - ASTGEN_MEMBERS_NodeModule; + ASTGEN_MEMBERS_AstNodeModule; void dump(std::ostream& str) const override; bool maybePointedTo() const override { return true; } string name() const override { return m_name; } @@ -279,7 +279,7 @@ protected: } public: - ASTGEN_MEMBERS_NodePreSel; + ASTGEN_MEMBERS_AstNodePreSel; // METHODS bool same(const AstNode*) const override { return true; } }; @@ -294,7 +294,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeProcedure; + ASTGEN_MEMBERS_AstNodeProcedure; // METHODS void dump(std::ostream& str) const override; bool isJustOneBodyStmt() const { return stmtsp() && !stmtsp()->nextp(); } @@ -308,7 +308,7 @@ protected: : AstNode{t, fl} {} public: - ASTGEN_MEMBERS_NodeRange; + ASTGEN_MEMBERS_AstNodeRange; void dump(std::ostream& str) const override; }; class AstNodeStmt VL_NOT_FINAL : public AstNode { @@ -320,7 +320,7 @@ protected: , m_statement{statement} {} public: - ASTGEN_MEMBERS_NodeStmt; + ASTGEN_MEMBERS_AstNodeStmt; // METHODS bool isStatement() const { return m_statement; } // Really a statement void statement(bool flag) { m_statement = flag; } @@ -346,7 +346,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeAssign; + ASTGEN_MEMBERS_AstNodeAssign; // Clone single node, just get same type back. virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) = 0; bool hasDType() const override { return true; } @@ -373,7 +373,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeCCall; + ASTGEN_MEMBERS_AstNodeCCall; void dump(std::ostream& str = std::cout) const override; void cloneRelink() override; const char* broken() const override; @@ -403,7 +403,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeCase; + ASTGEN_MEMBERS_AstNodeCase; int instrCount() const override { return INSTR_COUNT_BRANCH; } }; class AstNodeCoverOrAssert VL_NOT_FINAL : public AstNodeStmt { @@ -424,7 +424,7 @@ public: this->propp(propp); this->addPasssp(passsp); } - ASTGEN_MEMBERS_NodeCoverOrAssert; + ASTGEN_MEMBERS_AstNodeCoverOrAssert; string name() const override { return m_name; } // * = Var name bool same(const AstNode* samep) const override { return samep->name() == name(); } void name(const string& name) override { m_name = name; } @@ -459,7 +459,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeFTaskRef; + ASTGEN_MEMBERS_AstNodeFTaskRef; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str = std::cout) const override; @@ -493,7 +493,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeFor; + ASTGEN_MEMBERS_AstNodeFor; bool isGateOptimizable() const override { return false; } int instrCount() const override { return INSTR_COUNT_BRANCH; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -515,7 +515,7 @@ protected: } public: - ASTGEN_MEMBERS_NodeIf; + ASTGEN_MEMBERS_AstNodeIf; bool isGateOptimizable() const override { return false; } bool isGateDedupable() const override { return true; } int instrCount() const override { return INSTR_COUNT_BRANCH; } @@ -545,7 +545,7 @@ public: this->lsbp(lsbp); this->msbp(msbp); } - ASTGEN_MEMBERS_NodeReadWriteMem; + ASTGEN_MEMBERS_AstNodeReadWriteMem; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool isPure() const override { return false; } @@ -568,7 +568,7 @@ protected: , m_text{text} {} public: - ASTGEN_MEMBERS_NodeText; + ASTGEN_MEMBERS_AstNodeText; void dump(std::ostream& str = std::cout) const override; bool same(const AstNode* samep) const override { const AstNodeText* asamep = static_cast(samep); @@ -584,7 +584,7 @@ public: AstNodeSimpleText(VNType t, FileLine* fl, const string& textp, bool tracking = false) : AstNodeText(t, fl, textp) , m_tracking(tracking) {} - ASTGEN_MEMBERS_NodeSimpleText; + ASTGEN_MEMBERS_AstNodeSimpleText; void tracking(bool flag) { m_tracking = flag; } bool tracking() const { return m_tracking; } }; @@ -608,7 +608,7 @@ public: , m_sensesp{sensesp} { UASSERT(sensesp, "Sensesp required arg"); } - ASTGEN_MEMBERS_Active; + ASTGEN_MEMBERS_AstActive; void dump(std::ostream& str = std::cout) const override; string name() const override { return m_name; } const char* broken() const override; @@ -630,7 +630,7 @@ public: , m_name{name} { this->exprp(exprp); } - ASTGEN_MEMBERS_Arg; + ASTGEN_MEMBERS_AstArg; string name() const override { return m_name; } // * = Pin name, ""=go by number void name(const string& name) override { m_name = name; } bool emptyConnectNoNext() const { return !exprp() && name() == "" && !nextp(); } @@ -647,7 +647,7 @@ public: this->dimp(dimp); m_attrType = attrtype; } - ASTGEN_MEMBERS_AttrOf; + ASTGEN_MEMBERS_AstAttrOf; VAttrType attrType() const { return m_attrType; } void dump(std::ostream& str = std::cout) const override; }; @@ -664,7 +664,7 @@ public: UASSERT_OBJ(VN_IS(cellsp, Cell), cellsp, "Only instances allowed to be bound"); this->addCellsp(cellsp); } - ASTGEN_MEMBERS_Bind; + ASTGEN_MEMBERS_AstBind; // ACCESSORS string name() const override { return m_name; } // * = Bind Target name void name(const string& name) override { m_name = name; } @@ -735,7 +735,7 @@ public: m_dpiImportWrapper = false; m_dpiTraceInit = false; } - ASTGEN_MEMBERS_CFunc; + ASTGEN_MEMBERS_AstCFunc; string name() const override { return m_name; } const char* broken() const override; void cloneRelink() override; @@ -829,7 +829,7 @@ public: : ASTGEN_SUPER_CUse(fl) , m_useType{useType} , m_name{name} {} - ASTGEN_MEMBERS_CUse; + ASTGEN_MEMBERS_AstCUse; void dump(std::ostream& str = std::cout) const override; string name() const override { return m_name; } VUseType useType() const { return m_useType; } @@ -844,7 +844,7 @@ public: this->addCondsp(condsp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_CaseItem; + ASTGEN_MEMBERS_AstCaseItem; int instrCount() const override { return widthInstrs() + INSTR_COUNT_BRANCH; } bool isDefault() const { return condsp() == nullptr; } bool isFirstInMyListOfStatements(AstNode* n) const override { return n == stmtsp(); } @@ -865,7 +865,7 @@ public: this->fromp(fromp); dtypeFrom(dtp); } - ASTGEN_MEMBERS_Cast; + ASTGEN_MEMBERS_AstCast; bool hasDType() const override { return true; } virtual string emitVerilog() { return "((%d)'(%l))"; } virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); } @@ -884,7 +884,7 @@ public: this->lhsp(lhsp); this->dtp(dtp); } - ASTGEN_MEMBERS_CastParse; + ASTGEN_MEMBERS_AstCastParse; virtual string emitVerilog() { return "((%d)'(%l))"; } virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); } @@ -901,7 +901,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_CastSize; + ASTGEN_MEMBERS_AstCastSize; // No hasDType because widthing removes this node before the hasDType check virtual string emitVerilog() { return "((%r)'(%l))"; } virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); } @@ -937,7 +937,7 @@ public: this->addParamsp(paramsp); this->rangep(rangep); } - ASTGEN_MEMBERS_Cell; + ASTGEN_MEMBERS_AstCell; // No cloneRelink, we presume cloneee's want the same module linkages void dump(std::ostream& str) const override; const char* broken() const override; @@ -969,7 +969,7 @@ public: , m_name{name} { this->addSelp(selp); } - ASTGEN_MEMBERS_CellArrayRef; + ASTGEN_MEMBERS_AstCellArrayRef; // ACCESSORS string name() const override { return m_name; } // * = Array name }; @@ -992,7 +992,7 @@ public: , m_name{name} , m_origModName{origModName} , m_timeunit{timeunit} {} - ASTGEN_MEMBERS_CellInline; + ASTGEN_MEMBERS_AstCellInline; void dump(std::ostream& str) const override; const char* broken() const override; // ACCESSORS @@ -1017,7 +1017,7 @@ public: this->cellp(cellp); this->exprp(exprp); } - ASTGEN_MEMBERS_CellRef; + ASTGEN_MEMBERS_AstCellRef; // ACCESSORS string name() const override { return m_name; } // * = Array name }; @@ -1031,7 +1031,7 @@ public: : ASTGEN_SUPER_ClassExtends(fl) { this->classOrPkgsp(classOrPkgsp); // Only for parser } - ASTGEN_MEMBERS_ClassExtends; + ASTGEN_MEMBERS_AstClassExtends; bool hasDType() const override { return true; } string verilogKwd() const override { return "extends"; } AstClass* classp() const; // Class being extended (after link) @@ -1050,7 +1050,7 @@ public: , m_classOrPackageNodep{classOrPackageNodep} { this->addParamsp(paramsp); } - ASTGEN_MEMBERS_ClassOrPackageRef; + ASTGEN_MEMBERS_AstClassOrPackageRef; // METHODS const char* broken() const override { BROKEN_RTN(m_classOrPackageNodep && !m_classOrPackageNodep->brokeExists()); @@ -1084,7 +1084,7 @@ public: this->addSensesp(sensesp); this->addBodysp(bodysp); } - ASTGEN_MEMBERS_Clocking; + ASTGEN_MEMBERS_AstClocking; }; class AstConstPool final : public AstNode { // Container for const static data @@ -1098,7 +1098,7 @@ class AstConstPool final : public AstNode { public: explicit AstConstPool(FileLine* fl); - ASTGEN_MEMBERS_ConstPool; + ASTGEN_MEMBERS_AstConstPool; bool maybePointedTo() const override { return true; } const char* broken() const override; void cloneRelink() override { V3ERROR_NA; } @@ -1131,7 +1131,7 @@ public: this->rhsp(rhsp); } string name() const override { return m_name; } // * = Scope name - ASTGEN_MEMBERS_DefParam; + ASTGEN_MEMBERS_AstDefParam; bool same(const AstNode*) const override { return true; } string path() const { return m_path; } }; @@ -1148,7 +1148,7 @@ public: this->lhsp(lhsp); this->rhsp(rhsp); } - ASTGEN_MEMBERS_Dot; + ASTGEN_MEMBERS_AstDot; // For parser, make only if non-null package static AstNode* newIfPkg(FileLine* fl, AstNode* packageOrClassp, AstNode* rhsp) { if (!packageOrClassp) return rhsp; @@ -1169,7 +1169,7 @@ public: : ASTGEN_SUPER_DpiExport(fl) , m_name{vname} , m_cname{cname} {} - ASTGEN_MEMBERS_DpiExport; + ASTGEN_MEMBERS_AstDpiExport; string name() const override { return m_name; } void name(const string& name) override { m_name = name; } string cname() const { return m_cname; } @@ -1183,7 +1183,7 @@ private: public: inline AstElabDisplay(FileLine* fl, VDisplayType dispType, AstNode* exprsp); - ASTGEN_MEMBERS_ElabDisplay; + ASTGEN_MEMBERS_AstElabDisplay; const char* broken() const override { BROKEN_RTN(!fmtp()); return nullptr; @@ -1206,7 +1206,7 @@ class AstEmpty final : public AstNode { public: explicit AstEmpty(FileLine* fl) : ASTGEN_SUPER_Empty(fl) {} - ASTGEN_MEMBERS_Empty; + ASTGEN_MEMBERS_AstEmpty; bool same(const AstNode* /*samep*/) const override { return true; } }; class AstExecGraph final : public AstNode { @@ -1225,7 +1225,7 @@ class AstExecGraph final : public AstNode { public: explicit AstExecGraph(FileLine* fl, const string& name); - ASTGEN_MEMBERS_ExecGraph; + ASTGEN_MEMBERS_AstExecGraph; ~AstExecGraph() override; const char* broken() const override { BROKEN_RTN(!m_depGraphp); @@ -1244,7 +1244,7 @@ public: : ASTGEN_SUPER_Implicit(fl) { this->addExprsp(exprsp); } - ASTGEN_MEMBERS_Implicit; + ASTGEN_MEMBERS_AstImplicit; }; class AstInitArray final : public AstNode { // Set a var to a map of values @@ -1266,7 +1266,7 @@ public: dtypep(newDTypep); this->defaultp(defaultp); } - ASTGEN_MEMBERS_InitArray; + ASTGEN_MEMBERS_AstInitArray; void dump(std::ostream& str) const override; const char* broken() const override; void cloneRelink() override; @@ -1293,7 +1293,7 @@ public: : ASTGEN_SUPER_InitItem(fl) { this->valuep(valuep); } - ASTGEN_MEMBERS_InitItem; + ASTGEN_MEMBERS_AstInitItem; bool maybePointedTo() const override { return true; } bool hasDType() const override { return false; } // See valuep()'s dtype instead }; @@ -1306,7 +1306,7 @@ public: : ASTGEN_SUPER_IntfRef(fl) , m_name{name} {} string name() const override { return m_name; } - ASTGEN_MEMBERS_IntfRef; + ASTGEN_MEMBERS_AstIntfRef; }; class AstMTaskBody final : public AstNode { // Hold statements for each MTask @@ -1316,7 +1316,7 @@ class AstMTaskBody final : public AstNode { public: explicit AstMTaskBody(FileLine* fl) : ASTGEN_SUPER_MTaskBody(fl) {} - ASTGEN_MEMBERS_MTaskBody; + ASTGEN_MEMBERS_AstMTaskBody; const char* broken() const override { BROKEN_RTN(!m_execMTaskp); return nullptr; @@ -1344,7 +1344,7 @@ public: } string name() const override { return m_name; } bool maybePointedTo() const override { return true; } - ASTGEN_MEMBERS_Modport; + ASTGEN_MEMBERS_AstModport; }; class AstModportFTaskRef final : public AstNode { // An import/export referenced under a modport @@ -1360,7 +1360,7 @@ public: : ASTGEN_SUPER_ModportFTaskRef(fl) , m_name{name} , m_export{isExport} {} - ASTGEN_MEMBERS_ModportFTaskRef; + ASTGEN_MEMBERS_AstModportFTaskRef; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str) const override; @@ -1383,7 +1383,7 @@ public: : ASTGEN_SUPER_ModportVarRef(fl) , m_name{name} , m_direction{direction} {} - ASTGEN_MEMBERS_ModportVarRef; + ASTGEN_MEMBERS_AstModportVarRef; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str) const override; @@ -1417,7 +1417,7 @@ class AstNetlist final : public AstNode { uint32_t m_nextFreeMTaskProfilingID = 0; // Next unique ID to use for PGO public: AstNetlist(); - ASTGEN_MEMBERS_Netlist; + ASTGEN_MEMBERS_AstNetlist; const char* broken() const override; void cloneRelink() override { V3ERROR_NA; } string name() const override { return "$root"; } @@ -1463,7 +1463,7 @@ public: : ASTGEN_SUPER_PackageExport(fl) , m_name{name} , m_packagep{packagep} {} - ASTGEN_MEMBERS_PackageExport; + ASTGEN_MEMBERS_AstPackageExport; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str) const override; @@ -1477,7 +1477,7 @@ public: // cppcheck-suppress noExplicitConstructor AstPackageExportStarStar(FileLine* fl) : ASTGEN_SUPER_PackageExportStarStar(fl) {} - ASTGEN_MEMBERS_PackageExportStarStar; + ASTGEN_MEMBERS_AstPackageExportStarStar; }; class AstPackageImport final : public AstNode { private: @@ -1489,7 +1489,7 @@ public: : ASTGEN_SUPER_PackageImport(fl) , m_name{name} , m_packagep{packagep} {} - ASTGEN_MEMBERS_PackageImport; + ASTGEN_MEMBERS_AstPackageImport; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str) const override; @@ -1517,7 +1517,7 @@ public: this->lhsp(lhsp); this->ftaskrefp(ftaskrefp); } - ASTGEN_MEMBERS_ParseRef; + ASTGEN_MEMBERS_AstParseRef; void dump(std::ostream& str) const override; string name() const override { return m_name; } // * = Var name bool same(const AstNode* samep) const override { @@ -1546,7 +1546,7 @@ public: this->exprp(exprp); } inline AstPin(FileLine* fl, int pinNum, AstVarRef* varname, AstNode* exprp); - ASTGEN_MEMBERS_Pin; + ASTGEN_MEMBERS_AstPin; void dump(std::ostream& str) const override; const char* broken() const override; string name() const override { return m_name; } // * = Pin name, ""=go by number @@ -1574,7 +1574,7 @@ public: : ASTGEN_SUPER_Port(fl) , m_pinNum{pinnum} , m_name{name} {} - ASTGEN_MEMBERS_Port; + ASTGEN_MEMBERS_AstPort; string name() const override { return m_name; } // * = Port name int pinNum() const { return m_pinNum; } // * = Pin number, for order based instantiation }; @@ -1586,7 +1586,7 @@ public: AstPragma(FileLine* fl, VPragmaType pragType) : ASTGEN_SUPER_Pragma(fl) , m_pragType{pragType} {} - ASTGEN_MEMBERS_Pragma; + ASTGEN_MEMBERS_AstPragma; VPragmaType pragType() const { return m_pragType; } // *=type of the pragma bool isPredictOptimizable() const override { return false; } bool same(const AstNode* samep) const override { @@ -1607,7 +1607,7 @@ public: this->disablep(disablep); this->propp(propp); } - ASTGEN_MEMBERS_PropClocked; + ASTGEN_MEMBERS_AstPropClocked; bool hasDType() const override { return true; } // Used under Cover, which expects a bool child @@ -1623,7 +1623,7 @@ public: , m_direction{direction} { this->lhsp(lhsp); } - ASTGEN_MEMBERS_Pull; + ASTGEN_MEMBERS_AstPull; bool same(const AstNode* samep) const override { return direction() == static_cast(samep)->direction(); } @@ -1661,7 +1661,7 @@ public: dtypeSetString(); addExprsp(exprsp); } - ASTGEN_MEMBERS_SFormatF; + ASTGEN_MEMBERS_AstSFormatF; string name() const override { return m_text; } int instrCount() const override { return INSTR_COUNT_PLI; } bool hasDType() const override { return true; } @@ -1701,7 +1701,7 @@ public: , m_aboveScopep{aboveScopep} , m_aboveCellp{aboveCellp} , m_modp{modp} {} - ASTGEN_MEMBERS_Scope; + ASTGEN_MEMBERS_AstScope; void cloneRelink() override; const char* broken() const override; bool maybePointedTo() const override { return true; } @@ -1731,7 +1731,7 @@ public: this->fromp(fromp); this->addElementsp(elementsp); } - ASTGEN_MEMBERS_SelLoopVars; + ASTGEN_MEMBERS_AstSelLoopVars; bool same(const AstNode* /*samep*/) const override { return true; } bool maybePointedTo() const override { return false; } }; @@ -1769,7 +1769,7 @@ public: AstSenItem(FileLine* fl, Never) : ASTGEN_SUPER_SenItem(fl) , m_edgeType{VEdgeType::ET_NEVER} {} - ASTGEN_MEMBERS_SenItem; + ASTGEN_MEMBERS_AstSenItem; void dump(std::ostream& str) const override; bool same(const AstNode* samep) const override { return edgeType() == static_cast(samep)->edgeType(); @@ -1799,7 +1799,7 @@ public: : ASTGEN_SUPER_SenTree(fl) { this->addSensesp(sensesp); } - ASTGEN_MEMBERS_SenTree; + ASTGEN_MEMBERS_AstSenTree; void dump(std::ostream& str) const override; bool maybePointedTo() const override { return true; } bool isMulti() const { return m_multi; } @@ -1817,7 +1817,7 @@ public: // Dummy node used within V3Split; never exists outside of V3Split. explicit AstSplitPlaceholder(FileLine* fl) : ASTGEN_SUPER_SplitPlaceholder(fl) {} - ASTGEN_MEMBERS_SplitPlaceholder; + ASTGEN_MEMBERS_AstSplitPlaceholder; }; class AstStrengthSpec final : public AstNode { private: @@ -1830,7 +1830,7 @@ public: , m_s0{s0} , m_s1{s1} {} - ASTGEN_MEMBERS_StrengthSpec; + ASTGEN_MEMBERS_AstStrengthSpec; VStrength strength0() { return m_s0; } VStrength strength1() { return m_s1; } void dump(std::ostream& str) const override; @@ -1850,7 +1850,7 @@ class AstTopScope final : public AstNode { } public: - ASTGEN_MEMBERS_TopScope; + ASTGEN_MEMBERS_AstTopScope; bool maybePointedTo() const override { return true; } }; class AstTypeTable final : public AstNode { @@ -1866,7 +1866,7 @@ class AstTypeTable final : public AstNode { public: explicit AstTypeTable(FileLine* fl); - ASTGEN_MEMBERS_TypeTable; + ASTGEN_MEMBERS_AstTypeTable; bool maybePointedTo() const override { return true; } const char* broken() const override { BROKEN_RTN(m_emptyQueuep && !m_emptyQueuep->brokeExists()); @@ -1904,7 +1904,7 @@ public: addAttrsp(attrsp); dtypep(nullptr); // V3Width will resolve } - ASTGEN_MEMBERS_Typedef; + ASTGEN_MEMBERS_AstTypedef; void dump(std::ostream& str) const override; AstNodeDType* getChildDTypep() const override { return childDTypep(); } virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } @@ -1927,7 +1927,7 @@ public: AstTypedefFwd(FileLine* fl, const string& name) : ASTGEN_SUPER_TypedefFwd(fl) , m_name{name} {} - ASTGEN_MEMBERS_TypedefFwd; + ASTGEN_MEMBERS_AstTypedefFwd; // METHODS string name() const override { return m_name; } bool maybePointedTo() const override { return true; } @@ -1939,7 +1939,7 @@ public: : ASTGEN_SUPER_UdpTable(fl) { this->addLinesp(linesp); } - ASTGEN_MEMBERS_UdpTable; + ASTGEN_MEMBERS_AstUdpTable; }; class AstUdpTableLine final : public AstNode { string m_text; @@ -1948,7 +1948,7 @@ public: AstUdpTableLine(FileLine* fl, const string& text) : ASTGEN_SUPER_UdpTableLine(fl) , m_text{text} {} - ASTGEN_MEMBERS_UdpTableLine; + ASTGEN_MEMBERS_AstUdpTableLine; string name() const override { return m_text; } string text() const { return m_text; } }; @@ -1965,7 +1965,7 @@ public: this->refp(refp); this->cellrefp(cellrefp); } - ASTGEN_MEMBERS_UnlinkedRef; + ASTGEN_MEMBERS_AstUnlinkedRef; }; class AstVar final : public AstNode { // A variable (in/out/wire/reg/param) inside a module @@ -2130,7 +2130,7 @@ public: dtypeFrom(examplep); m_declKwd = examplep->declKwd(); } - ASTGEN_MEMBERS_Var; + ASTGEN_MEMBERS_AstVar; void dump(std::ostream& str) const override; string name() const override { return m_name; } // * = Var name bool hasDType() const override { return true; } @@ -2354,7 +2354,7 @@ public: m_trace = true; dtypeFrom(varp); } - ASTGEN_MEMBERS_VarScope; + ASTGEN_MEMBERS_AstVarScope; void cloneRelink() override { if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep(); @@ -2393,7 +2393,7 @@ public: : ASTGEN_SUPER_Begin(fl, name, stmtsp) , m_generate{generate} , m_implied{implied} {} - ASTGEN_MEMBERS_Begin; + ASTGEN_MEMBERS_AstBegin; void dump(std::ostream& str) const override; void generate(bool flag) { m_generate = flag; } bool generate() const { return m_generate; } @@ -2409,7 +2409,7 @@ public: // Node that puts name into the output stream AstFork(FileLine* fl, const string& name, AstNode* stmtsp) : ASTGEN_SUPER_Fork(fl, name, stmtsp) {} - ASTGEN_MEMBERS_Fork; + ASTGEN_MEMBERS_AstFork; bool isTimingControl() const override { return !joinType().joinNone(); } void dump(std::ostream& str) const override; VJoinType joinType() const { return m_joinType; } @@ -2424,7 +2424,7 @@ public: : ASTGEN_SUPER_Func(fl, name, stmtp) { this->fvarp(fvarp); } - ASTGEN_MEMBERS_Func; + ASTGEN_MEMBERS_AstFunc; bool hasDType() const override { return true; } }; class AstTask final : public AstNodeFTask { @@ -2432,7 +2432,7 @@ class AstTask final : public AstNodeFTask { public: AstTask(FileLine* fl, const string& name, AstNode* stmtp) : ASTGEN_SUPER_Task(fl, name, stmtp) {} - ASTGEN_MEMBERS_Task; + ASTGEN_MEMBERS_AstTask; }; // === AstNodeFile === @@ -2449,7 +2449,7 @@ public: , m_slow{false} , m_source{false} , m_support{false} {} - ASTGEN_MEMBERS_CFile; + ASTGEN_MEMBERS_AstCFile; void dump(std::ostream& str = std::cout) const override; bool slow() const { return m_slow; } void slow(bool flag) { m_slow = flag; } @@ -2464,7 +2464,7 @@ class AstVFile final : public AstNodeFile { public: AstVFile(FileLine* fl, const string& name) : ASTGEN_SUPER_VFile(fl, name) {} - ASTGEN_MEMBERS_VFile; + ASTGEN_MEMBERS_AstVFile; void dump(std::ostream& str = std::cout) const override; }; @@ -2483,7 +2483,7 @@ class AstClass final : public AstNodeModule { public: AstClass(FileLine* fl, const string& name) : ASTGEN_SUPER_Class(fl, name) {} - ASTGEN_MEMBERS_Class; + ASTGEN_MEMBERS_AstClass; string verilogKwd() const override { return "class"; } bool maybePointedTo() const override { return true; } void dump(std::ostream& str) const override; @@ -2518,7 +2518,7 @@ class AstClassPackage final : public AstNodeModule { public: AstClassPackage(FileLine* fl, const string& name) : ASTGEN_SUPER_ClassPackage(fl, name) {} - ASTGEN_MEMBERS_ClassPackage; + ASTGEN_MEMBERS_AstClassPackage; string verilogKwd() const override { return "classpackage"; } const char* broken() const override; void cloneRelink() override; @@ -2531,7 +2531,7 @@ class AstIface final : public AstNodeModule { public: AstIface(FileLine* fl, const string& name) : ASTGEN_SUPER_Iface(fl, name) {} - ASTGEN_MEMBERS_Iface; + ASTGEN_MEMBERS_AstIface; // Interfaces have `timescale applicability but lots of code seems to // get false warnings if we enable this string verilogKwd() const override { return "interface"; } @@ -2545,7 +2545,7 @@ public: AstModule(FileLine* fl, const string& name, bool program = false) : ASTGEN_SUPER_Module(fl, name) , m_isProgram{program} {} - ASTGEN_MEMBERS_Module; + ASTGEN_MEMBERS_AstModule; string verilogKwd() const override { return m_isProgram ? "program" : "module"; } bool timescaleMatters() const override { return true; } }; @@ -2554,7 +2554,7 @@ class AstNotFoundModule final : public AstNodeModule { public: AstNotFoundModule(FileLine* fl, const string& name) : ASTGEN_SUPER_NotFoundModule(fl, name) {} - ASTGEN_MEMBERS_NotFoundModule; + ASTGEN_MEMBERS_AstNotFoundModule; string verilogKwd() const override { return "/*not-found-*/ module"; } bool timescaleMatters() const override { return false; } }; @@ -2563,7 +2563,7 @@ class AstPackage final : public AstNodeModule { public: AstPackage(FileLine* fl, const string& name) : ASTGEN_SUPER_Package(fl, name) {} - ASTGEN_MEMBERS_Package; + ASTGEN_MEMBERS_AstPackage; string verilogKwd() const override { return "package"; } bool timescaleMatters() const override { return !isDollarUnit(); } static string dollarUnitName() { return AstNode::encodeName("$unit"); } @@ -2574,7 +2574,7 @@ class AstPrimitive final : public AstNodeModule { public: AstPrimitive(FileLine* fl, const string& name) : ASTGEN_SUPER_Primitive(fl, name) {} - ASTGEN_MEMBERS_Primitive; + ASTGEN_MEMBERS_AstPrimitive; string verilogKwd() const override { return "primitive"; } bool timescaleMatters() const override { return false; } }; @@ -2589,7 +2589,7 @@ public: UASSERT_OBJ(!v3Global.assertDTypesResolved(), this, "not coded to create after dtypes resolved"); } - ASTGEN_MEMBERS_SelBit; + ASTGEN_MEMBERS_AstSelBit; AstNode* bitp() const { return rhsp(); } }; class AstSelExtract final : public AstNodePreSel { @@ -2597,7 +2597,7 @@ class AstSelExtract final : public AstNodePreSel { public: AstSelExtract(FileLine* fl, AstNode* fromp, AstNode* msbp, AstNode* lsbp) : ASTGEN_SUPER_SelExtract(fl, fromp, msbp, lsbp) {} - ASTGEN_MEMBERS_SelExtract; + ASTGEN_MEMBERS_AstSelExtract; AstNode* leftp() const { return rhsp(); } AstNode* rightp() const { return thsp(); } }; @@ -2607,7 +2607,7 @@ class AstSelMinus final : public AstNodePreSel { public: AstSelMinus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp) : ASTGEN_SUPER_SelMinus(fl, fromp, bitp, widthp) {} - ASTGEN_MEMBERS_SelMinus; + ASTGEN_MEMBERS_AstSelMinus; AstNode* bitp() const { return rhsp(); } AstNode* widthp() const { return thsp(); } }; @@ -2617,7 +2617,7 @@ class AstSelPlus final : public AstNodePreSel { public: AstSelPlus(FileLine* fl, AstNode* fromp, AstNode* bitp, AstNode* widthp) : ASTGEN_SUPER_SelPlus(fl, fromp, bitp, widthp) {} - ASTGEN_MEMBERS_SelPlus; + ASTGEN_MEMBERS_AstSelPlus; AstNode* bitp() const { return rhsp(); } AstNode* widthp() const { return thsp(); } }; @@ -2633,7 +2633,7 @@ public: , m_keyword{keyword} { this->sensesp(sensesp); } - ASTGEN_MEMBERS_Always; + ASTGEN_MEMBERS_AstAlways; // void dump(std::ostream& str) const override; VAlwaysKwd keyword() const { return m_keyword; } @@ -2646,7 +2646,7 @@ public: : ASTGEN_SUPER_AlwaysPost(fl, stmtsp) { this->sensesp(sensesp); } - ASTGEN_MEMBERS_AlwaysPost; + ASTGEN_MEMBERS_AstAlwaysPost; }; class AstAlwaysPostponed final : public AstNodeProcedure { // Like always but postponement scheduling region @@ -2654,19 +2654,19 @@ class AstAlwaysPostponed final : public AstNodeProcedure { public: AstAlwaysPostponed(FileLine* fl, AstNode* stmtsp) : ASTGEN_SUPER_AlwaysPostponed(fl, stmtsp) {} - ASTGEN_MEMBERS_AlwaysPostponed; + ASTGEN_MEMBERS_AstAlwaysPostponed; }; class AstFinal final : public AstNodeProcedure { public: AstFinal(FileLine* fl, AstNode* stmtsp) : ASTGEN_SUPER_Final(fl, stmtsp) {} - ASTGEN_MEMBERS_Final; + ASTGEN_MEMBERS_AstFinal; }; class AstInitial final : public AstNodeProcedure { public: AstInitial(FileLine* fl, AstNode* stmtsp) : ASTGEN_SUPER_Initial(fl, stmtsp) {} - ASTGEN_MEMBERS_Initial; + ASTGEN_MEMBERS_AstInitial; }; class AstInitialAutomatic final : public AstNodeProcedure { // Automatic variable initialization @@ -2674,7 +2674,7 @@ class AstInitialAutomatic final : public AstNodeProcedure { public: AstInitialAutomatic(FileLine* fl, AstNode* stmtsp) : ASTGEN_SUPER_InitialAutomatic(fl, stmtsp) {} - ASTGEN_MEMBERS_InitialAutomatic; + ASTGEN_MEMBERS_AstInitialAutomatic; }; class AstInitialStatic final : public AstNodeProcedure { // Static variable initialization @@ -2682,7 +2682,7 @@ class AstInitialStatic final : public AstNodeProcedure { public: AstInitialStatic(FileLine* fl, AstNode* stmtsp) : ASTGEN_SUPER_InitialStatic(fl, stmtsp) {} - ASTGEN_MEMBERS_InitialStatic; + ASTGEN_MEMBERS_AstInitialStatic; }; // === AstNodeRange === @@ -2695,7 +2695,7 @@ public: : ASTGEN_SUPER_BracketRange(fl) { this->elementsp(elementsp); } - ASTGEN_MEMBERS_BracketRange; + ASTGEN_MEMBERS_AstBracketRange; virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } bool same(const AstNode* /*samep*/) const override { return true; } @@ -2715,7 +2715,7 @@ public: } inline AstRange(FileLine* fl, int left, int right); inline AstRange(FileLine* fl, const VNumRange& range); - ASTGEN_MEMBERS_Range; + ASTGEN_MEMBERS_AstRange; inline int leftConst() const; inline int rightConst() const; int hiConst() const { @@ -2739,7 +2739,7 @@ class AstUnsizedRange final : public AstNodeRange { public: explicit AstUnsizedRange(FileLine* fl) : ASTGEN_SUPER_UnsizedRange(fl) {} - ASTGEN_MEMBERS_UnsizedRange; + ASTGEN_MEMBERS_AstUnsizedRange; virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitVerilog() { return "[]"; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -2749,7 +2749,7 @@ class AstWildcardRange final : public AstNodeRange { public: explicit AstWildcardRange(FileLine* fl) : ASTGEN_SUPER_WildcardRange(fl) {} - ASTGEN_MEMBERS_WildcardRange; + ASTGEN_MEMBERS_AstWildcardRange; virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitVerilog() { return "[*]"; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -2767,7 +2767,7 @@ public: addSensesp(sensesp); addStmtsp(stmtsp); } - ASTGEN_MEMBERS_AlwaysPublic; + ASTGEN_MEMBERS_AstAlwaysPublic; bool same(const AstNode* /*samep*/) const override { return true; } // Special accessors bool isJustOneBodyStmt() const { return stmtsp() && !stmtsp()->nextp(); } @@ -2777,7 +2777,7 @@ class AstBreak final : public AstNodeStmt { public: explicit AstBreak(FileLine* fl) : ASTGEN_SUPER_Break(fl) {} - ASTGEN_MEMBERS_Break; + ASTGEN_MEMBERS_AstBreak; string verilogKwd() const override { return "break"; } bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks @@ -2793,7 +2793,7 @@ public: , m_sensesp{sensesp} { this->exprp(exprp); } - ASTGEN_MEMBERS_CAwait; + ASTGEN_MEMBERS_AstCAwait; bool isTimingControl() const override { return true; } const char* broken() const override { BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists()); @@ -2831,7 +2831,7 @@ public: this->fromp(fromp); this->addPinsp(pinsp); } - ASTGEN_MEMBERS_CMethodHard; + ASTGEN_MEMBERS_AstCMethodHard; string name() const override { return m_name; } // * = Var name bool hasDType() const override { return true; } void name(const string& name) override { m_name = name; } @@ -2854,7 +2854,7 @@ public: : ASTGEN_SUPER_CReset(fl) { this->varrefp(varrefp); } - ASTGEN_MEMBERS_CReset; + ASTGEN_MEMBERS_AstCReset; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -2867,7 +2867,7 @@ public: : ASTGEN_SUPER_CReturn(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_CReturn; + ASTGEN_MEMBERS_AstCReturn; int instrCount() const override { return widthInstrs(); } bool same(const AstNode* /*samep*/) const override { return true; } }; @@ -2880,7 +2880,7 @@ public: this->addExprsp(exprsp); } inline AstCStmt(FileLine* fl, const string& textStmt); - ASTGEN_MEMBERS_CStmt; + ASTGEN_MEMBERS_AstCStmt; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -2895,7 +2895,7 @@ public: : ASTGEN_SUPER_Comment(fl) , m_showAt{showAt} , m_name{name} {} - ASTGEN_MEMBERS_Comment; + ASTGEN_MEMBERS_AstComment; string name() const override { return m_name; } // * = Text bool same(const AstNode* samep) const override { return true; } // Ignore name in comments virtual bool showAt() const { return m_showAt; } @@ -2904,7 +2904,7 @@ class AstContinue final : public AstNodeStmt { public: explicit AstContinue(FileLine* fl) : ASTGEN_SUPER_Continue(fl) {} - ASTGEN_MEMBERS_Continue; + ASTGEN_MEMBERS_AstContinue; string verilogKwd() const override { return "continue"; } bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks @@ -2931,7 +2931,7 @@ public: , m_text{comment} , m_linescov{linescov} , m_offset{offset} {} - ASTGEN_MEMBERS_CoverDecl; + ASTGEN_MEMBERS_AstCoverDecl; const char* broken() const override { BROKEN_RTN(m_dataDeclp && !m_dataDeclp->brokeExists()); if (m_dataDeclp && m_dataDeclp->m_dataDeclp) { // Avoid O(n^2) accessing @@ -2976,7 +2976,7 @@ public: AstCoverInc(FileLine* fl, AstCoverDecl* declp) : ASTGEN_SUPER_CoverInc(fl) , m_declp{declp} {} - ASTGEN_MEMBERS_CoverInc; + ASTGEN_MEMBERS_AstCoverInc; const char* broken() const override { BROKEN_RTN(!declp()->brokeExists()); return nullptr; @@ -3008,7 +3008,7 @@ public: this->origp(origp); this->changep(changep); } - ASTGEN_MEMBERS_CoverToggle; + ASTGEN_MEMBERS_AstCoverToggle; int instrCount() const override { return 3 + INSTR_COUNT_BRANCH + INSTR_COUNT_LD; } bool same(const AstNode* /*samep*/) const override { return true; } bool isGateOptimizable() const override { return false; } @@ -3028,7 +3028,7 @@ public: this->lhsp(lhsp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_Delay; + ASTGEN_MEMBERS_AstDelay; bool isTimingControl() const override { return true; } bool same(const AstNode* /*samep*/) const override { return true; } }; @@ -3039,7 +3039,7 @@ public: AstDisable(FileLine* fl, const string& name) : ASTGEN_SUPER_Disable(fl) , m_name{name} {} - ASTGEN_MEMBERS_Disable; + ASTGEN_MEMBERS_AstDisable; string name() const override { return m_name; } // * = Block name void name(const string& flag) override { m_name = flag; } bool isBrancher() const override { @@ -3051,7 +3051,7 @@ class AstDisableFork final : public AstNodeStmt { public: explicit AstDisableFork(FileLine* fl) : ASTGEN_SUPER_DisableFork(fl) {} - ASTGEN_MEMBERS_DisableFork; + ASTGEN_MEMBERS_AstDisableFork; }; class AstDisplay final : public AstNodeStmt { // Parents: stmtlist @@ -3075,7 +3075,7 @@ public: this->fmtp(new AstSFormatF{fl, AstSFormatF::NoFormat(), exprsp, missingArgChar}); this->filep(filep); } - ASTGEN_MEMBERS_Display; + ASTGEN_MEMBERS_AstDisplay; void dump(std::ostream& str) const override; const char* broken() const override { BROKEN_RTN(!fmtp()); @@ -3110,7 +3110,7 @@ public: , m_ctlType{ctlType} { this->exprp(exprp); } - ASTGEN_MEMBERS_DumpCtl; + ASTGEN_MEMBERS_AstDumpCtl; string verilogKwd() const override { return ctlType().ascii(); } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3129,7 +3129,7 @@ public: this->sensesp(sensesp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_EventControl; + ASTGEN_MEMBERS_AstEventControl; string verilogKwd() const override { return "@(%l) %r"; } bool isTimingControl() const override { return true; } int instrCount() const override { return 0; } @@ -3142,7 +3142,7 @@ public: : ASTGEN_SUPER_FClose(fl) { this->filep(filep); } - ASTGEN_MEMBERS_FClose; + ASTGEN_MEMBERS_AstFClose; string verilogKwd() const override { return "$fclose"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3159,7 +3159,7 @@ public: : ASTGEN_SUPER_FFlush(fl) { this->filep(filep); } - ASTGEN_MEMBERS_FFlush; + ASTGEN_MEMBERS_AstFFlush; string verilogKwd() const override { return "$fflush"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3180,7 +3180,7 @@ public: this->filenamep(filenamep); this->modep(modep); } - ASTGEN_MEMBERS_FOpen; + ASTGEN_MEMBERS_AstFOpen; string verilogKwd() const override { return "$fopen"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3199,7 +3199,7 @@ public: this->filep(filep); this->filenamep(filenamep); } - ASTGEN_MEMBERS_FOpenMcd; + ASTGEN_MEMBERS_AstFOpenMcd; string verilogKwd() const override { return "$fopen"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3212,7 +3212,7 @@ class AstFinish final : public AstNodeStmt { public: explicit AstFinish(FileLine* fl) : ASTGEN_SUPER_Finish(fl) {} - ASTGEN_MEMBERS_Finish; + ASTGEN_MEMBERS_AstFinish; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool isPure() const override { return false; } // SPECIAL: $display has 'visual' ordering @@ -3231,7 +3231,7 @@ public: , m_delayed{delayed} { this->operandp(operandp); } - ASTGEN_MEMBERS_FireEvent; + ASTGEN_MEMBERS_AstFireEvent; bool isDelayed() const { return m_delayed; } }; class AstForeach final : public AstNodeStmt { @@ -3243,7 +3243,7 @@ public: this->arrayp(arrayp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_Foreach; + ASTGEN_MEMBERS_AstForeach; bool isGateOptimizable() const override { return false; } int instrCount() const override { return INSTR_COUNT_BRANCH; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -3266,7 +3266,7 @@ public: } const char* broken() const override; void cloneRelink() override; - ASTGEN_MEMBERS_JumpBlock; + ASTGEN_MEMBERS_AstJumpBlock; int instrCount() const override { return 0; } bool maybePointedTo() const override { return true; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -3286,7 +3286,7 @@ public: AstJumpGo(FileLine* fl, AstJumpLabel* labelp) : ASTGEN_SUPER_JumpGo(fl) , m_labelp{labelp} {} - ASTGEN_MEMBERS_JumpGo; + ASTGEN_MEMBERS_AstJumpGo; const char* broken() const override; void cloneRelink() override; void dump(std::ostream& str) const override; @@ -3310,7 +3310,7 @@ public: AstJumpLabel(FileLine* fl, AstJumpBlock* blockp) : ASTGEN_SUPER_JumpLabel(fl) , m_blockp{blockp} {} - ASTGEN_MEMBERS_JumpLabel; + ASTGEN_MEMBERS_AstJumpLabel; bool maybePointedTo() const override { return true; } const char* broken() const override { BROKEN_RTN(!blockp()->brokeExistsAbove()); @@ -3334,7 +3334,7 @@ public: AstMonitorOff(FileLine* fl, bool off) : ASTGEN_SUPER_MonitorOff(fl) , m_off{off} {} - ASTGEN_MEMBERS_MonitorOff; + ASTGEN_MEMBERS_AstMonitorOff; string verilogKwd() const override { return m_off ? "$monitoroff" : "$monitoron"; } bool isGateOptimizable() const override { return false; } // Though deleted before opt bool isPredictOptimizable() const override { return false; } // Though deleted before opt @@ -3353,7 +3353,7 @@ class AstPrintTimeScale final : public AstNodeStmt { public: explicit AstPrintTimeScale(FileLine* fl) : ASTGEN_SUPER_PrintTimeScale(fl) {} - ASTGEN_MEMBERS_PrintTimeScale; + ASTGEN_MEMBERS_AstPrintTimeScale; void name(const string& name) override { m_name = name; } string name() const override { return m_name; } // * = Var name void dump(std::ostream& str) const override; @@ -3374,7 +3374,7 @@ public: : ASTGEN_SUPER_Release(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_Release; + ASTGEN_MEMBERS_AstRelease; }; class AstRepeat final : public AstNodeStmt { // @astgen op1 := countp : AstNode @@ -3385,7 +3385,7 @@ public: this->countp(countp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_Repeat; + ASTGEN_MEMBERS_AstRepeat; bool isGateOptimizable() const override { return false; } // Not relevant - converted to FOR int instrCount() const override { return INSTR_COUNT_BRANCH; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -3398,7 +3398,7 @@ public: : ASTGEN_SUPER_Return(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_Return; + ASTGEN_MEMBERS_AstReturn; string verilogKwd() const override { return "return"; } bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks @@ -3420,7 +3420,7 @@ public: this->fmtp(new AstSFormatF{fl, AstSFormatF::NoFormat(), exprsp, missingArgChar}); this->lhsp(lhsp); } - ASTGEN_MEMBERS_SFormat; + ASTGEN_MEMBERS_AstSFormat; const char* broken() const override { BROKEN_RTN(!fmtp()); return nullptr; @@ -3438,7 +3438,7 @@ class AstStop final : public AstNodeStmt { public: AstStop(FileLine* fl, bool maybe) : ASTGEN_SUPER_Stop(fl) {} - ASTGEN_MEMBERS_Stop; + ASTGEN_MEMBERS_AstStop; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool isPure() const override { return false; } // SPECIAL: $display has 'visual' ordering @@ -3455,7 +3455,7 @@ public: : ASTGEN_SUPER_SysFuncAsTask(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_SysFuncAsTask; + ASTGEN_MEMBERS_AstSysFuncAsTask; string verilogKwd() const override { return ""; } bool isGateOptimizable() const override { return true; } bool isPredictOptimizable() const override { return true; } @@ -3471,7 +3471,7 @@ public: : ASTGEN_SUPER_SysIgnore(fl) { this->addExprsp(exprsp); } - ASTGEN_MEMBERS_SysIgnore; + ASTGEN_MEMBERS_AstSysIgnore; string verilogKwd() const override { return "$ignored"; } bool isGateOptimizable() const override { return false; } // Though deleted before opt bool isPredictOptimizable() const override { return false; } // Though deleted before opt @@ -3487,7 +3487,7 @@ public: : ASTGEN_SUPER_SystemT(fl) { this->lhsp(lhsp); } - ASTGEN_MEMBERS_SystemT; + ASTGEN_MEMBERS_AstSystemT; string verilogKwd() const override { return "$system"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3511,7 +3511,7 @@ public: this->suffixp(suffixp); this->widthp(widthp); } - ASTGEN_MEMBERS_TimeFormat; + ASTGEN_MEMBERS_AstTimeFormat; string verilogKwd() const override { return "$timeformat"; } bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } @@ -3553,7 +3553,7 @@ public: } void dump(std::ostream& str) const override; int instrCount() const override { return 100; } // Large... - ASTGEN_MEMBERS_TraceDecl; + ASTGEN_MEMBERS_AstTraceDecl; string name() const override { return m_showname; } bool maybePointedTo() const override { return true; } bool hasDType() const override { return true; } @@ -3589,7 +3589,7 @@ public: this->valuep( declp->valuep()->cloneTree(true)); // TODO: maybe use reference to TraceDecl instead? } - ASTGEN_MEMBERS_TraceInc; + ASTGEN_MEMBERS_AstTraceInc; const char* broken() const override { BROKEN_RTN(!declp()->brokeExists()); return nullptr; @@ -3617,7 +3617,7 @@ public: AstTracePopNamePrefix(FileLine* fl, unsigned count) : ASTGEN_SUPER_TracePopNamePrefix(fl) , m_count{count} {} - ASTGEN_MEMBERS_TracePopNamePrefix; + ASTGEN_MEMBERS_AstTracePopNamePrefix; bool same(const AstNode* samep) const override { return false; } unsigned count() const { return m_count; } }; @@ -3627,7 +3627,7 @@ public: AstTracePushNamePrefix(FileLine* fl, const string& prefix) : ASTGEN_SUPER_TracePushNamePrefix(fl) , m_prefix{prefix} {} - ASTGEN_MEMBERS_TracePushNamePrefix; + ASTGEN_MEMBERS_AstTracePushNamePrefix; bool same(const AstNode* samep) const override { return false; } string prefix() const { return m_prefix; } }; @@ -3639,7 +3639,7 @@ public: : ASTGEN_SUPER_UCStmt(fl) { this->addExprsp(exprsp); } - ASTGEN_MEMBERS_UCStmt; + ASTGEN_MEMBERS_AstUCStmt; bool isGateOptimizable() const override { return false; } bool isPredictOptimizable() const override { return false; } bool isPure() const override { return false; } @@ -3655,7 +3655,7 @@ public: this->condp(condp); this->addStmtsp(stmtsp); } - ASTGEN_MEMBERS_Wait; + ASTGEN_MEMBERS_AstWait; bool isFirstInMyListOfStatements(AstNode* n) const override { return n == stmtsp(); } bool isTimingControl() const override { return true; } }; @@ -3664,7 +3664,7 @@ class AstWaitFork final : public AstNodeStmt { public: explicit AstWaitFork(FileLine* fl) : ASTGEN_SUPER_WaitFork(fl) {} - ASTGEN_MEMBERS_WaitFork; + ASTGEN_MEMBERS_AstWaitFork; }; class AstWhile final : public AstNodeStmt { // @astgen op1 := precondsp : List[AstNode] @@ -3678,7 +3678,7 @@ public: this->addStmtsp(stmtsp); this->addIncsp(incsp); } - ASTGEN_MEMBERS_While; + ASTGEN_MEMBERS_AstWhile; bool isGateOptimizable() const override { return false; } int instrCount() const override { return INSTR_COUNT_BRANCH; } bool same(const AstNode* /*samep*/) const override { return true; } @@ -3706,7 +3706,7 @@ public: this->valueArgRefp(valueArgRefp); this->exprp(exprp); } - ASTGEN_MEMBERS_With; + ASTGEN_MEMBERS_AstWith; bool same(const AstNode* /*samep*/) const override { return true; } bool hasDType() const override { return true; } const char* broken() const override { @@ -3729,7 +3729,7 @@ public: this->funcrefp(funcrefp); this->exprp(exprp); } - ASTGEN_MEMBERS_WithParse; + ASTGEN_MEMBERS_AstWithParse; bool same(const AstNode* /*samep*/) const override { return true; } }; @@ -3740,7 +3740,7 @@ public: : ASTGEN_SUPER_Assign(fl, lhsp, rhsp, timingControlp) { dtypeFrom(lhsp); } - ASTGEN_MEMBERS_Assign; + ASTGEN_MEMBERS_AstAssign; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr; return new AstAssign{fileline(), lhsp, rhsp, controlp}; @@ -3753,7 +3753,7 @@ class AstAssignAlias final : public AstNodeAssign { public: AstAssignAlias(FileLine* fl, AstVarRef* lhsp, AstVarRef* rhsp) : ASTGEN_SUPER_AssignAlias(fl, (AstNode*)lhsp, (AstNode*)rhsp) {} - ASTGEN_MEMBERS_AssignAlias; + ASTGEN_MEMBERS_AstAssignAlias; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { V3ERROR_NA_RETURN(nullptr); } bool brokeLhsMustBeLvalue() const override { return false; } }; @@ -3761,7 +3761,7 @@ class AstAssignDly final : public AstNodeAssign { public: AstAssignDly(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* timingControlp = nullptr) : ASTGEN_SUPER_AssignDly(fl, lhsp, rhsp, timingControlp) {} - ASTGEN_MEMBERS_AssignDly; + ASTGEN_MEMBERS_AstAssignDly; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr; return new AstAssignDly{fileline(), lhsp, rhsp, controlp}; @@ -3775,7 +3775,7 @@ class AstAssignForce final : public AstNodeAssign { public: AstAssignForce(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_AssignForce(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_AssignForce; + ASTGEN_MEMBERS_AstAssignForce; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignForce{this->fileline(), lhsp, rhsp}; } @@ -3786,7 +3786,7 @@ class AstAssignPost final : public AstNodeAssign { public: AstAssignPost(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_AssignPost(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_AssignPost; + ASTGEN_MEMBERS_AstAssignPost; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignPost(this->fileline(), lhsp, rhsp); } @@ -3797,7 +3797,7 @@ class AstAssignPre final : public AstNodeAssign { public: AstAssignPre(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER_AssignPre(fl, lhsp, rhsp) {} - ASTGEN_MEMBERS_AssignPre; + ASTGEN_MEMBERS_AstAssignPre; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignPre(this->fileline(), lhsp, rhsp); } @@ -3810,7 +3810,7 @@ public: : ASTGEN_SUPER_AssignVarScope(fl, lhsp, rhsp) { dtypeFrom(rhsp); } - ASTGEN_MEMBERS_AssignVarScope; + ASTGEN_MEMBERS_AstAssignVarScope; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignVarScope(this->fileline(), lhsp, rhsp); } @@ -3822,7 +3822,7 @@ class AstAssignW final : public AstNodeAssign { public: AstAssignW(FileLine* fl, AstNode* lhsp, AstNode* rhsp, AstNode* timingControlp = nullptr) : ASTGEN_SUPER_AssignW(fl, lhsp, rhsp, timingControlp) {} - ASTGEN_MEMBERS_AssignW; + ASTGEN_MEMBERS_AstAssignW; AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { AstNode* const controlp = timingControlp() ? timingControlp()->cloneTree(false) : nullptr; return new AstAssignW{fileline(), lhsp, rhsp, controlp}; @@ -3842,7 +3842,7 @@ class AstCCall final : public AstNodeCCall { public: AstCCall(FileLine* fl, AstCFunc* funcp, AstNode* argsp = nullptr) : ASTGEN_SUPER_CCall(fl, funcp, argsp) {} - ASTGEN_MEMBERS_CCall; + ASTGEN_MEMBERS_AstCCall; string selfPointer() const { return m_selfPointer; } void selfPointer(const string& value) { m_selfPointer = value; } @@ -3857,7 +3857,7 @@ public: : ASTGEN_SUPER_CMethodCall(fl, funcp, argsp) { this->fromp(fromp); } - ASTGEN_MEMBERS_CMethodCall; + ASTGEN_MEMBERS_AstCMethodCall; const char* broken() const override { BROKEN_BASE_RTN(AstNodeCCall::broken()); BROKEN_RTN(!fromp()); @@ -3874,7 +3874,7 @@ public: statement(false); } bool hasDType() const override { return true; } - ASTGEN_MEMBERS_CNew; + ASTGEN_MEMBERS_AstCNew; }; // === AstNodeCase === @@ -3892,7 +3892,7 @@ public: AstCase(FileLine* fl, VCaseType casex, AstNode* exprp, AstCaseItem* itemsp) : ASTGEN_SUPER_Case(fl, exprp, itemsp) , m_casex{casex} {} - ASTGEN_MEMBERS_Case; + ASTGEN_MEMBERS_AstCase; string verilogKwd() const override { return casez() ? "casez" : casex() ? "casex" : "case"; } bool same(const AstNode* samep) const override { return m_casex == static_cast(samep)->m_casex; @@ -3919,14 +3919,14 @@ class AstGenCase final : public AstNodeCase { public: AstGenCase(FileLine* fl, AstNode* exprp, AstCaseItem* itemsp) : ASTGEN_SUPER_GenCase(fl, exprp, itemsp) {} - ASTGEN_MEMBERS_GenCase; + ASTGEN_MEMBERS_AstGenCase; }; // === AstNodeCoverOrAssert === class AstAssert final : public AstNodeCoverOrAssert { // @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey public: - ASTGEN_MEMBERS_Assert; + ASTGEN_MEMBERS_AstAssert; AstAssert(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, bool immediate, const string& name = "") : ASTGEN_SUPER_Assert(fl, propp, passsp, immediate, name) { @@ -3937,7 +3937,7 @@ class AstAssertIntrinsic final : public AstNodeCoverOrAssert { // A $cast or other compiler inserted assert, that must run even without --assert option // @astgen op3 := failsp: List[AstNode] // Statments when propp is failing/falsey public: - ASTGEN_MEMBERS_AssertIntrinsic; + ASTGEN_MEMBERS_AstAssertIntrinsic; AstAssertIntrinsic(FileLine* fl, AstNode* propp, AstNode* passsp, AstNode* failsp, bool immediate, const string& name = "") : ASTGEN_SUPER_AssertIntrinsic(fl, propp, passsp, immediate, name) { @@ -3947,7 +3947,7 @@ public: class AstCover final : public AstNodeCoverOrAssert { // @astgen op3 := coverincsp: List[AstNode] // Coverage node public: - ASTGEN_MEMBERS_Cover; + ASTGEN_MEMBERS_AstCover; AstCover(FileLine* fl, AstNode* propp, AstNode* stmtsp, bool immediate, const string& name = "") : ASTGEN_SUPER_Cover(fl, propp, stmtsp, immediate, name) {} @@ -3955,7 +3955,7 @@ public: }; class AstRestrict final : public AstNodeCoverOrAssert { public: - ASTGEN_MEMBERS_Restrict; + ASTGEN_MEMBERS_AstRestrict; AstRestrict(FileLine* fl, AstNode* propp) : ASTGEN_SUPER_Restrict(fl, propp, nullptr, false, "") {} }; @@ -3968,7 +3968,7 @@ public: : ASTGEN_SUPER_FuncRef(fl, false, namep, pinsp) {} AstFuncRef(FileLine* fl, const string& name, AstNode* pinsp) : ASTGEN_SUPER_FuncRef(fl, false, name, pinsp) {} - ASTGEN_MEMBERS_FuncRef; + ASTGEN_MEMBERS_AstFuncRef; bool hasDType() const override { return true; } }; class AstMethodCall final : public AstNodeFTaskRef { @@ -3989,7 +3989,7 @@ public: : ASTGEN_SUPER_MethodCall(fl, false, name, pinsp) { this->fromp(fromp); } - ASTGEN_MEMBERS_MethodCall; + ASTGEN_MEMBERS_AstMethodCall; const char* broken() const override { BROKEN_BASE_RTN(AstNodeFTaskRef::broken()); BROKEN_RTN(!fromp()); @@ -4010,7 +4010,7 @@ class AstNew final : public AstNodeFTaskRef { public: AstNew(FileLine* fl, AstNode* pinsp) : ASTGEN_SUPER_New(fl, false, "new", pinsp) {} - ASTGEN_MEMBERS_New; + ASTGEN_MEMBERS_AstNew; virtual bool cleanOut() const { return true; } bool same(const AstNode* /*samep*/) const override { return true; } bool hasDType() const override { return true; } @@ -4025,7 +4025,7 @@ public: } AstTaskRef(FileLine* fl, const string& name, AstNode* pinsp) : ASTGEN_SUPER_TaskRef(fl, true, name, pinsp) {} - ASTGEN_MEMBERS_TaskRef; + ASTGEN_MEMBERS_AstTaskRef; }; // === AstNodeFor === @@ -4033,7 +4033,7 @@ class AstGenFor final : public AstNodeFor { public: AstGenFor(FileLine* fl, AstNode* initsp, AstNode* condp, AstNode* incsp, AstNode* stmtsp) : ASTGEN_SUPER_GenFor(fl, initsp, condp, incsp, stmtsp) {} - ASTGEN_MEMBERS_GenFor; + ASTGEN_MEMBERS_AstGenFor; }; // === AstNodeIf === @@ -4041,7 +4041,7 @@ class AstGenIf final : public AstNodeIf { public: AstGenIf(FileLine* fl, AstNode* condp, AstNode* thensp, AstNode* elsesp) : ASTGEN_SUPER_GenIf(fl, condp, thensp, elsesp) {} - ASTGEN_MEMBERS_GenIf; + ASTGEN_MEMBERS_AstGenIf; }; class AstIf final : public AstNodeIf { private: @@ -4051,7 +4051,7 @@ private: public: AstIf(FileLine* fl, AstNode* condp, AstNode* thensp = nullptr, AstNode* elsesp = nullptr) : ASTGEN_SUPER_If(fl, condp, thensp, elsesp) {} - ASTGEN_MEMBERS_If; + ASTGEN_MEMBERS_AstIf; bool uniquePragma() const { return m_uniquePragma; } void uniquePragma(bool flag) { m_uniquePragma = flag; } bool unique0Pragma() const { return m_unique0Pragma; } @@ -4066,7 +4066,7 @@ public: AstReadMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp, AstNode* msbp) : ASTGEN_SUPER_ReadMem(fl, hex, filenamep, memp, lsbp, msbp) {} - ASTGEN_MEMBERS_ReadMem; + ASTGEN_MEMBERS_AstReadMem; string verilogKwd() const override { return (isHex() ? "$readmemh" : "$readmemb"); } const char* cFuncPrefixp() const override { return "VL_READMEM_"; } }; @@ -4075,7 +4075,7 @@ public: AstWriteMem(FileLine* fl, bool hex, AstNode* filenamep, AstNode* memp, AstNode* lsbp, AstNode* msbp) : ASTGEN_SUPER_WriteMem(fl, hex, filenamep, memp, lsbp, msbp) {} - ASTGEN_MEMBERS_WriteMem; + ASTGEN_MEMBERS_AstWriteMem; string verilogKwd() const override { return (isHex() ? "$writememh" : "$writememb"); } const char* cFuncPrefixp() const override { return "VL_WRITEMEM_"; } }; @@ -4085,7 +4085,7 @@ class AstScCtor final : public AstNodeText { public: AstScCtor(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScCtor(fl, textp) {} - ASTGEN_MEMBERS_ScCtor; + ASTGEN_MEMBERS_AstScCtor; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4093,7 +4093,7 @@ class AstScDtor final : public AstNodeText { public: AstScDtor(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScDtor(fl, textp) {} - ASTGEN_MEMBERS_ScDtor; + ASTGEN_MEMBERS_AstScDtor; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4101,7 +4101,7 @@ class AstScHdr final : public AstNodeText { public: AstScHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScHdr(fl, textp) {} - ASTGEN_MEMBERS_ScHdr; + ASTGEN_MEMBERS_AstScHdr; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4109,7 +4109,7 @@ class AstScImp final : public AstNodeText { public: AstScImp(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScImp(fl, textp) {} - ASTGEN_MEMBERS_ScImp; + ASTGEN_MEMBERS_AstScImp; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4117,7 +4117,7 @@ class AstScImpHdr final : public AstNodeText { public: AstScImpHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScImpHdr(fl, textp) {} - ASTGEN_MEMBERS_ScImpHdr; + ASTGEN_MEMBERS_AstScImpHdr; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4125,7 +4125,7 @@ class AstScInt final : public AstNodeText { public: AstScInt(FileLine* fl, const string& textp) : ASTGEN_SUPER_ScInt(fl, textp) {} - ASTGEN_MEMBERS_ScInt; + ASTGEN_MEMBERS_AstScInt; bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs bool isOutputter() const override { return true; } }; @@ -4135,7 +4135,7 @@ class AstText final : public AstNodeSimpleText { public: AstText(FileLine* fl, const string& textp, bool tracking = false) : ASTGEN_SUPER_Text(fl, textp, tracking) {} - ASTGEN_MEMBERS_Text; + ASTGEN_MEMBERS_AstText; }; class AstTextBlock final : public AstNodeSimpleText { // @astgen op1 := nodesp : List[AstNode] @@ -4145,7 +4145,7 @@ public: bool commas = false) : ASTGEN_SUPER_TextBlock(fl, textp, tracking) , m_commas(commas) {} - ASTGEN_MEMBERS_TextBlock; + ASTGEN_MEMBERS_AstTextBlock; void commas(bool flag) { m_commas = flag; } bool commas() const { return m_commas; } void addText(FileLine* fl, const string& textp, bool tracking = false) { diff --git a/src/V3Dfg.cpp b/src/V3Dfg.cpp index 8c86710b8..e353c5b5c 100644 --- a/src/V3Dfg.cpp +++ b/src/V3Dfg.cpp @@ -208,8 +208,7 @@ class ExtractCyclicComponents final { // The extracted cyclic components std::vector> m_components; // Map from 'variable vertex' -> 'component index' -> 'clone in that component' - std::unordered_map> - m_clones; + std::unordered_map> m_clones; // METHODS @@ -285,7 +284,7 @@ class ExtractCyclicComponents final { void visitMergeSCCs(const DfgVertex& vtx, size_t targetComponent) { // We stop at variable boundaries, which is where we will split the graphs - if (vtx.is() || vtx.is()) return; + if (vtx.is()) return; // Mark visited/move on if already visited if (!m_merged.insert(&vtx).second) return; @@ -312,9 +311,9 @@ class ExtractCyclicComponents final { // Methods for extraction // Retrieve clone of vertex in the given component - DfgVertexLValue& getClone(DfgVertexLValue& vtx, size_t component) { + DfgVertexVar& getClone(DfgVertexVar& vtx, size_t component) { UASSERT_OBJ(m_state.at(&vtx).component != component, &vtx, "Vertex is in that component"); - DfgVertexLValue*& clonep = m_clones[&vtx][component]; + DfgVertexVar*& clonep = m_clones[&vtx][component]; if (!clonep) { DfgGraph& dfg = component == 0 ? m_dfg : *m_components[component - 1]; if (DfgVarPacked* const pVtxp = vtx.cast()) { @@ -322,7 +321,7 @@ class ExtractCyclicComponents final { } else if (DfgVarArray* const aVtxp = vtx.cast()) { clonep = new DfgVarArray{dfg, aVtxp->varp()}; } - UASSERT_OBJ(clonep, &vtx, "Unhandled 'DfgVertexLValue' sub-type"); + UASSERT_OBJ(clonep, &vtx, "Unhandled 'DfgVertexVar' sub-type"); if (VL_UNLIKELY(m_doExpensiveChecks)) { // Assign component number of clone for later checks m_state @@ -338,30 +337,30 @@ class ExtractCyclicComponents final { return *clonep; } - // Fix up non-variable sources of a DfgVertexLValue that are in a different component, + // Fix up non-variable sources of a DfgVertexVar that are in a different component, // using the provided 'relink' callback template void fixSources(T_Vertex& vtx, std::function relink) { - static_assert(std::is_base_of::value, - "'Vertex' must be a 'DfgVertexLValue'"); + static_assert(std::is_base_of::value, + "'Vertex' must be a 'DfgVertexVar'"); const size_t component = m_state.at(&vtx).component; vtx.forEachSourceEdge([&](DfgEdge& edge, size_t idx) { DfgVertex& source = *edge.sourcep(); - // DfgVertexLValue sources are fixed up by `fixSinks` on those sources - if (source.is() || source.is()) return; + // DfgVertexVar sources are fixed up by `fixSinks` on those sources + if (source.is()) return; const size_t sourceComponent = m_state.at(&source).component; // Same component is OK if (sourceComponent == component) return; // Unlink the source edge (source is reconnected by 'relink' edge.unlinkSource(); // Apply the fixup - DfgVertexLValue& clone = getClone(vtx, sourceComponent); + DfgVertexVar& clone = getClone(vtx, sourceComponent); relink(*(clone.as()), source, idx); }); } // Fix up sinks of given variable vertex that are in a different component - void fixSinks(DfgVertexLValue& vtx) { + void fixSinks(DfgVertexVar& vtx) { const size_t component = m_state.at(&vtx).component; vtx.forEachSinkEdge([&](DfgEdge& edge) { const size_t sinkComponent = m_state.at(edge.sinkp()).component; @@ -400,7 +399,7 @@ class ExtractCyclicComponents final { vtx.forEachSourceEdge([&](DfgEdge& edge, size_t) { DfgVertex& source = *edge.sourcep(); // OK to cross at variables - if (source.is() || source.is()) return; + if (source.is()) return; UASSERT_OBJ(component == m_state.at(&source).component, &vtx, "Component crossing edge without variable involvement"); }); @@ -670,9 +669,7 @@ static void dumpDotVertexAndSourceEdges(std::ostream& os, const DfgVertex& vtx) vtx.forEachSourceEdge([&](const DfgEdge& edge, size_t idx) { // if (edge.sourcep()) { string headLabel; - if (vtx.arity() > 1 || vtx.is() || vtx.is()) { - headLabel = vtx.srcName(idx); - } + if (vtx.arity() > 1 || vtx.is()) headLabel = vtx.srcName(idx); dumpDotEdge(os, edge, headLabel); } }); @@ -843,7 +840,7 @@ void DfgEdge::relinkSource(DfgVertex* newSourcep) { // DfgVertex //------------------------------------------------------------------------------ -DfgVertex::DfgVertex(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type) +DfgVertex::DfgVertex(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep) : m_filelinep{flp} , m_dtypep{dtypep} , m_type{type} { @@ -897,7 +894,7 @@ V3Hash DfgVertex::hash(HashCache& cache) const { result += selfHash(); // Variables are defined by themselves, so there is no need to hash the sources. This // enables sound hashing of graphs circular only through variables, which we rely on. - if (!is() && !is()) { + if (!is()) { forEachSource([&result, &cache](const DfgVertex& src) { result += src.hash(cache); }); } } @@ -930,7 +927,6 @@ void DfgVertex::replaceWith(DfgVertex* newSorucep) { //------------------------------------------------------------------------------ // DfgVarPacked ---------- -void DfgVarPacked::accept(DfgVisitor& visitor) { visitor.visit(this); } bool DfgVarPacked::selfEquals(const DfgVertex& that) const { if (const DfgVarPacked* otherp = that.cast()) { @@ -943,7 +939,6 @@ bool DfgVarPacked::selfEquals(const DfgVertex& that) const { V3Hash DfgVarPacked::selfHash() const { return V3Hasher::uncachedHash(varp()); } // DfgVarPacked ---------- -void DfgVarArray::accept(DfgVisitor& visitor) { visitor.visit(this); } bool DfgVarArray::selfEquals(const DfgVertex& that) const { if (const DfgVarArray* otherp = that.cast()) { @@ -956,7 +951,6 @@ bool DfgVarArray::selfEquals(const DfgVertex& that) const { V3Hash DfgVarArray::selfHash() const { return V3Hasher::uncachedHash(varp()); } // DfgConst ---------- -void DfgConst::accept(DfgVisitor& visitor) { visitor.visit(this); } bool DfgConst::selfEquals(const DfgVertex& that) const { if (const DfgConst* otherp = that.cast()) { @@ -971,12 +965,4 @@ V3Hash DfgConst::selfHash() const { return V3Hasher::uncachedHash(m_constp); } // DfgVisitor //------------------------------------------------------------------------------ -void DfgVisitor::visit(DfgVarPacked* vtxp) { visit(static_cast(vtxp)); } -void DfgVisitor::visit(DfgVarArray* vtxp) { visit(static_cast(vtxp)); } -void DfgVisitor::visit(DfgConst* vtxp) { visit(static_cast(vtxp)); } - -//------------------------------------------------------------------------------ -// 'astgen' generated definitions -//------------------------------------------------------------------------------ - -#include "V3Dfg__gen_definitions.h" +#include "V3Dfg__gen_visitor_defns.h" // From ./astgen diff --git a/src/V3Dfg.h b/src/V3Dfg.h index 1cfe8768e..e0745dad2 100644 --- a/src/V3Dfg.h +++ b/src/V3Dfg.h @@ -21,7 +21,7 @@ // than the linked list based structures used by V3Graph. // // A bulk of the DfgVertex sub-types are generated by astgen, and are -// analogous to the correspondign AstNode sub-types. +// analogous to the corresponding AstNode sub-types. // // See also the internals documentation docs/internals.rst // @@ -39,6 +39,8 @@ #include "V3Hasher.h" #include "V3List.h" +#include "V3Dfg__gen_forward_class_decls.h" // From ./astgen + #include #include #include @@ -46,7 +48,10 @@ #include #include -class DfgVertex; +#ifndef VL_NOT_FINAL +#define VL_NOT_FINAL // This #define fixes broken code folding in the CLion IDE +#endif + class DfgEdge; class DfgVisitor; @@ -63,6 +68,25 @@ struct std::hash> final { } }; +//------------------------------------------------------------------------------ +// Dataflow vertex type enum +//------------------------------------------------------------------------------ + +class VDfgType final { +public: +#include "V3Dfg__gen_type_enum.h" // From ./astgen + enum en m_e; + VDfgType() = default; + // cppcheck-suppress noExplicitConstructor + constexpr VDfgType(en _e) + : m_e{_e} {} + constexpr operator en() const { return m_e; } +}; +constexpr bool operator==(VDfgType lhs, VDfgType rhs) { return lhs.m_e == rhs.m_e; } +constexpr bool operator==(VDfgType lhs, VDfgType::en rhs) { return lhs.m_e == rhs; } +constexpr bool operator==(VDfgType::en lhs, VDfgType rhs) { return lhs == rhs.m_e; } +inline std::ostream& operator<<(std::ostream& os, const VDfgType& t) { return os << t.ascii(); } + //------------------------------------------------------------------------------ // Dataflow graph //------------------------------------------------------------------------------ @@ -191,9 +215,6 @@ public: // Dataflow graph vertex //------------------------------------------------------------------------------ -// Reuse the generated type constants -using DfgType = VNType; - // Base data flow graph vertex class DfgVertex VL_NOT_FINAL { friend class DfgGraph; @@ -206,10 +227,10 @@ protected: DfgEdge* m_sinksp = nullptr; // List of sinks of this vertex FileLine* const m_filelinep; // Source location AstNodeDType* m_dtypep = nullptr; // Data type of the result of this vertex - const DfgType m_type; + const VDfgType m_type; // CONSTRUCTOR - DfgVertex(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type); + DfgVertex(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep); public: virtual ~DfgVertex(); @@ -277,7 +298,7 @@ public: // The data type of the result of the nodes AstNodeDType* dtypep() const { return m_dtypep; } // The type of this vertex - DfgType type() const { return m_type; } + VDfgType type() const { return m_type; } // Width of result uint32_t width() const { @@ -396,11 +417,18 @@ public: string warnMore() const { return fileline()->warnMore(); } string warnOther() const { return fileline()->warnOther(); } +private: + // For internal use only. + // Note: specializations for particular vertex types are provided by 'astgen' + template + inline static bool privateTypeTest(const DfgVertex* nodep); + +public: // Subtype test template bool is() const { static_assert(std::is_base_of::value, "'T' must be a subtype of DfgVertex"); - return m_type == T::dfgType(); + return privateTypeTest::type>(this); } // Ensure subtype, then cast to that type @@ -436,367 +464,8 @@ public: virtual const string srcName(size_t idx) const = 0; }; -// DfgVertices are, well ... DfgVertices -template <> -constexpr bool DfgVertex::is() const { - return true; -} -template <> -constexpr DfgVertex* DfgVertex::as() { - return this; -} -template <> -constexpr const DfgVertex* DfgVertex::as() const { - return this; -} -template <> -constexpr DfgVertex* DfgVertex::cast() { - return this; -} -template <> -constexpr const DfgVertex* DfgVertex::cast() const { - return this; -} - -template -class DfgVertexWithArity VL_NOT_FINAL : public DfgVertex { - static_assert(1 <= Arity && Arity <= 4, "Arity must be between 1 and 4 inclusive"); - - std::array m_srcs; // Source edges - -protected: - DfgVertexWithArity(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type) - : DfgVertex{dfg, flp, dtypep, type} { - // Initialize source edges - for (size_t i = 0; i < Arity; ++i) m_srcs[i].init(this); - } - - ~DfgVertexWithArity() override = default; - -public: - std::pair sourceEdges() override { // - return {m_srcs.data(), Arity}; - } - std::pair sourceEdges() const override { - return {m_srcs.data(), Arity}; - } - - template - DfgEdge* sourceEdge() { - static_assert(Index < Arity, "Source index out of range"); - return &m_srcs[Index]; - } - - template - const DfgEdge* sourceEdge() const { - static_assert(Index < Arity, "Source index out of range"); - return &m_srcs[Index]; - } - - template - DfgVertex* source() const { - static_assert(Index < Arity, "Source index out of range"); - return m_srcs[Index].sourcep(); - } - - template - void relinkSource(DfgVertex* newSourcep) { - static_assert(Index < Arity, "Source index out of range"); - UASSERT_OBJ(m_srcs[Index].sinkp() == this, this, "Inconsistent"); - m_srcs[Index].relinkSource(newSourcep); - } - - // Named source getter/setter for unary vertices - template - typename std::enable_if::type srcp() const { - static_assert(A == Arity, "Should not be changed"); - return source<0>(); - } - template - typename std::enable_if::type srcp(DfgVertex* vtxp) { - static_assert(A == Arity, "Should not be changed"); - relinkSource<0>(vtxp); - } - - // Named source getter/setter for binary vertices - template - typename std::enable_if::type lhsp() const { - static_assert(A == Arity, "Should not be changed"); - return source<0>(); - } - template - typename std::enable_if::type lhsp(DfgVertex* vtxp) { - static_assert(A == Arity, "Should not be changed"); - relinkSource<0>(vtxp); - } - - template - typename std::enable_if::type rhsp() const { - static_assert(A == Arity, "Should not be changed"); - return source<1>(); - } - template - typename std::enable_if::type rhsp(DfgVertex* vtxp) { - static_assert(A == Arity, "Should not be changed"); - relinkSource<1>(vtxp); - } -}; - -class DfgVertexVariadic VL_NOT_FINAL : public DfgVertex { - DfgEdge* m_srcsp; // The source edges - uint32_t m_srcCnt = 0; // Number of sources used - uint32_t m_srcCap; // Number of sources allocated - - // Allocate a new source edge array - DfgEdge* allocSources(size_t n) { - DfgEdge* const srcsp = new DfgEdge[n]; - for (size_t i = 0; i < n; ++i) srcsp[i].init(this); - return srcsp; - } - - // Double the capacity of m_srcsp - void growSources() { - m_srcCap *= 2; - DfgEdge* const newsp = allocSources(m_srcCap); - for (size_t i = 0; i < m_srcCnt; ++i) { - DfgEdge* const oldp = m_srcsp + i; - // Skip over unlinked source edge - if (!oldp->sourcep()) continue; - // New edge driven from the same vertex as the old edge - newsp[i].relinkSource(oldp->sourcep()); - // Unlink the old edge, it will be deleted - oldp->unlinkSource(); - } - // Delete old source edges - delete[] m_srcsp; - // Keep hold of new source edges - m_srcsp = newsp; - } - -protected: - DfgVertexVariadic(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep, DfgType type, - uint32_t initialCapacity = 1) - : DfgVertex{dfg, flp, dtypep, type} - , m_srcsp{allocSources(initialCapacity)} - , m_srcCap{initialCapacity} {} - - ~DfgVertexVariadic() override { delete[] m_srcsp; }; - - DfgEdge* addSource() { - if (m_srcCnt == m_srcCap) growSources(); - return m_srcsp + m_srcCnt++; - } - - void resetSources() { - // #ifdef VL_DEBUG TODO: DEBUG ONLY - for (uint32_t i = 0; i < m_srcCnt; ++i) { - UASSERT_OBJ(!m_srcsp[i].sourcep(), m_srcsp[i].sourcep(), "Connected source"); - } - // #endif - m_srcCnt = 0; - } - -public: - DfgEdge* sourceEdge(size_t idx) const { return &m_srcsp[idx]; } - DfgVertex* source(size_t idx) const { return m_srcsp[idx].sourcep(); } - - std::pair sourceEdges() override { return {m_srcsp, m_srcCnt}; } - std::pair sourceEdges() const override { return {m_srcsp, m_srcCnt}; } -}; - -//------------------------------------------------------------------------------ -// Vertex classes -//------------------------------------------------------------------------------ - -class DfgVertexLValue VL_NOT_FINAL : public DfgVertexVariadic { - AstVar* const m_varp; // The AstVar associated with this vertex (not owned by this vertex) - bool m_hasModRefs = false; // This AstVar is referenced outside the DFG, but in the module - bool m_hasExtRefs = false; // This AstVar is referenced from outside the module - -public: - DfgVertexLValue(DfgGraph& dfg, DfgType type, AstVar* varp, uint32_t initialCapacity) - : DfgVertexVariadic{dfg, varp->fileline(), dtypeFor(varp), type, initialCapacity} - , m_varp{varp} {} - - AstVar* varp() const { return m_varp; } - bool hasModRefs() const { return m_hasModRefs; } - void setHasModRefs() { m_hasModRefs = true; } - bool hasExtRefs() const { return m_hasExtRefs; } - void setHasExtRefs() { m_hasExtRefs = true; } - bool hasRefs() const { return m_hasModRefs || m_hasExtRefs; } - - // Variable cannot be removed, even if redundant in the DfgGraph (might be used externally) - bool keep() const { - // Keep if referenced outside this module - if (hasExtRefs()) return true; - // Keep if traced - if (v3Global.opt.trace() && varp()->isTrace()) return true; - // Keep if public - if (varp()->isSigPublic()) return true; - // Otherwise it can be removed - return false; - } -}; - -class DfgVarPacked final : public DfgVertexLValue { - friend class DfgVertex; - friend class DfgVisitor; - - using DriverData = std::pair; - - std::vector m_driverData; // Additional data associate with each driver - - void accept(DfgVisitor& visitor) override; - bool selfEquals(const DfgVertex& that) const override; - V3Hash selfHash() const override; - static constexpr DfgType dfgType() { return DfgType::atVar; }; - -public: - DfgVarPacked(DfgGraph& dfg, AstVar* varp) - : DfgVertexLValue{dfg, dfgType(), varp, 1u} {} - - bool isDrivenByDfg() const { return arity() > 0; } - bool isDrivenFullyByDfg() const { return arity() == 1 && source(0)->dtypep() == dtypep(); } - - void addDriver(FileLine* flp, uint32_t lsb, DfgVertex* vtxp) { - m_driverData.emplace_back(flp, lsb); - DfgVertexVariadic::addSource()->relinkSource(vtxp); - } - - void resetSources() { - m_driverData.clear(); - DfgVertexVariadic::resetSources(); - } - - // Remove undriven sources - void packSources() { - // Grab and reset the driver data - std::vector driverData{std::move(m_driverData)}; - - // Grab and unlink the sources - std::vector sources{arity()}; - forEachSourceEdge([&](DfgEdge& edge, size_t idx) { - sources[idx] = edge.sourcep(); - edge.unlinkSource(); - }); - DfgVertexVariadic::resetSources(); - - // Add back the driven sources - for (size_t i = 0; i < sources.size(); ++i) { - if (!sources[i]) continue; - addDriver(driverData[i].first, driverData[i].second, sources[i]); - } - } - - FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; } - uint32_t driverLsb(size_t idx) const { return m_driverData[idx].second; } - - const string srcName(size_t idx) const override { - return isDrivenFullyByDfg() ? "" : cvtToStr(driverLsb(idx)); - } -}; - -class DfgVarArray final : public DfgVertexLValue { - friend class DfgVertex; - friend class DfgVisitor; - - using DriverData = std::pair; - - std::vector m_driverData; // Additional data associate with each driver - - void accept(DfgVisitor& visitor) override; - bool selfEquals(const DfgVertex& that) const override; - V3Hash selfHash() const override; - static constexpr DfgType dfgType() { return DfgType::atUnpackArrayDType; }; // TODO: gross - -public: - DfgVarArray(DfgGraph& dfg, AstVar* varp) - : DfgVertexLValue{dfg, dfgType(), varp, 4u} { - UASSERT_OBJ(VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType), varp, "Non array DfgVarArray"); - } - - bool isDrivenByDfg() const { return arity() > 0; } - - void addDriver(FileLine* flp, uint32_t index, DfgVertex* vtxp) { - m_driverData.emplace_back(flp, index); - DfgVertexVariadic::addSource()->relinkSource(vtxp); - } - - void resetSources() { - m_driverData.clear(); - DfgVertexVariadic::resetSources(); - } - - // Remove undriven sources - void packSources() { - // Grab and reset the driver data - std::vector driverData{std::move(m_driverData)}; - - // Grab and unlink the sources - std::vector sources{arity()}; - forEachSourceEdge([&](DfgEdge& edge, size_t idx) { - sources[idx] = edge.sourcep(); - edge.unlinkSource(); - }); - DfgVertexVariadic::resetSources(); - - // Add back the driven sources - for (size_t i = 0; i < sources.size(); ++i) { - if (!sources[i]) continue; - addDriver(driverData[i].first, driverData[i].second, sources[i]); - } - } - - FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; } - uint32_t driverIndex(size_t idx) const { return m_driverData[idx].second; } - - DfgVertex* driverAt(size_t idx) const { - const DfgEdge* const edgep = findSourceEdge([=](const DfgEdge&, size_t i) { // - return driverIndex(i) == idx; - }); - return edgep ? edgep->sourcep() : nullptr; - } - - const string srcName(size_t idx) const override { return cvtToStr(driverIndex(idx)); } -}; - -class DfgConst final : public DfgVertex { - friend class DfgVertex; - friend class DfgVisitor; - - AstConst* const m_constp; // The AstConst associated with this vertex (owned by this vertex) - - void accept(DfgVisitor& visitor) override; - bool selfEquals(const DfgVertex& that) const override; - V3Hash selfHash() const override; - static constexpr DfgType dfgType() { return DfgType::atConst; }; - -public: - DfgConst(DfgGraph& dfg, AstConst* constp) - : DfgVertex{dfg, constp->fileline(), dtypeFor(constp), dfgType()} - , m_constp{constp} {} - - ~DfgConst() override { VL_DO_DANGLING(m_constp->deleteTree(), m_constp); } - - AstConst* constp() const { return m_constp; } - V3Number& num() const { return m_constp->num(); } - - uint32_t toU32() const { return num().toUInt(); } - int32_t toI32() const { return num().toSInt(); } - - bool isZero() const { return num().isEqZero(); } - bool isOnes() const { return num().isEqAllOnes(width()); } - - std::pair sourceEdges() override { return {nullptr, 0}; } - std::pair sourceEdges() const override { return {nullptr, 0}; } - const string srcName(size_t) const override { // LCOV_EXCL_START - VL_UNREACHABLE; - return ""; - } // LCOV_EXCL_STOP -}; - -// The rest of the DfgVertex subclasses are generated by 'astgen' from AstNodeMath nodes -#include "V3Dfg__gen_vertex_classes.h" +// Specialisations of privateTypeTest +#include "V3Dfg__gen_type_tests.h" // From ./astgen //------------------------------------------------------------------------------ // Dfg vertex visitor @@ -807,10 +476,8 @@ public: // Dispatch to most specific 'visit' method on 'vtxp' void iterate(DfgVertex* vtxp) { vtxp->accept(*this); } - virtual void visit(DfgVarPacked* vtxp); - virtual void visit(DfgVarArray* vtxp); - virtual void visit(DfgConst* vtxp); -#include "V3Dfg__gen_visitor_decls.h" + virtual void visit(DfgVertex* nodep) = 0; +#include "V3Dfg__gen_visitor_decls.h" // From ./astgen }; //------------------------------------------------------------------------------ @@ -937,6 +604,180 @@ Vertex* DfgVertex::findSink() const { return findSink([](const Vertex&) { return true; }); } +//------------------------------------------------------------------------------ +// DfgVertex sub-types follow +//------------------------------------------------------------------------------ + +// Include macros generated by 'astgen'. These include DFGGEN_MEMBERS_ +// for each DfgVertex sub-type. The generated members include boilerplate +// methods related to cloning, visitor dispatch, and other functionality. +// For precise details please read the generated macros. +#include "V3Dfg__gen_macros.h" + +//------------------------------------------------------------------------------ +// Implementation of dataflow graph vertices with a fixed number of sources +//------------------------------------------------------------------------------ + +template +class DfgVertexWithArity VL_NOT_FINAL : public DfgVertex { + static_assert(1 <= Arity && Arity <= 4, "Arity must be between 1 and 4 inclusive"); + + std::array m_srcs; // Source edges + +protected: + DfgVertexWithArity(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep) + : DfgVertex{dfg, type, flp, dtypep} { + // Initialize source edges + for (size_t i = 0; i < Arity; ++i) m_srcs[i].init(this); + } + + ~DfgVertexWithArity() override = default; + +public: + std::pair sourceEdges() final override { // + return {m_srcs.data(), Arity}; + } + std::pair sourceEdges() const final override { + return {m_srcs.data(), Arity}; + } + + template + DfgEdge* sourceEdge() { + static_assert(Index < Arity, "Source index out of range"); + return &m_srcs[Index]; + } + + template + const DfgEdge* sourceEdge() const { + static_assert(Index < Arity, "Source index out of range"); + return &m_srcs[Index]; + } + + template + DfgVertex* source() const { + static_assert(Index < Arity, "Source index out of range"); + return m_srcs[Index].sourcep(); + } + + template + void relinkSource(DfgVertex* newSourcep) { + static_assert(Index < Arity, "Source index out of range"); + UASSERT_OBJ(m_srcs[Index].sinkp() == this, this, "Inconsistent"); + m_srcs[Index].relinkSource(newSourcep); + } +}; + +class DfgVertexUnary VL_NOT_FINAL : public DfgVertexWithArity<1> { +protected: + DfgVertexUnary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep) + : DfgVertexWithArity<1>{dfg, type, flp, dtypep} {} + +public: + ASTGEN_MEMBERS_DfgVertexUnary; + + // Named getter/setter for sources + DfgVertex* srcp() const { return source<0>(); } + void srcp(DfgVertex* vtxp) { relinkSource<0>(vtxp); } +}; + +class DfgVertexBinary VL_NOT_FINAL : public DfgVertexWithArity<2> { +protected: + DfgVertexBinary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep) + : DfgVertexWithArity<2>{dfg, type, flp, dtypep} {} + +public: + ASTGEN_MEMBERS_DfgVertexBinary; + + // Named getter/setter for sources + DfgVertex* lhsp() const { return source<0>(); } + void lhsp(DfgVertex* vtxp) { relinkSource<0>(vtxp); } + DfgVertex* rhsp() const { return source<1>(); } + void rhsp(DfgVertex* vtxp) { relinkSource<1>(vtxp); } +}; + +class DfgVertexTernary VL_NOT_FINAL : public DfgVertexWithArity<3> { +protected: + DfgVertexTernary(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep) + : DfgVertexWithArity<3>{dfg, type, flp, dtypep} {} + +public: + ASTGEN_MEMBERS_DfgVertexTernary; +}; + +//------------------------------------------------------------------------------ +// Implementation of dataflow graph vertices with a variable number of sources +//------------------------------------------------------------------------------ + +class DfgVertexVariadic VL_NOT_FINAL : public DfgVertex { + DfgEdge* m_srcsp; // The source edges + uint32_t m_srcCnt = 0; // Number of sources used + uint32_t m_srcCap; // Number of sources allocated + + // Allocate a new source edge array + DfgEdge* allocSources(size_t n) { + DfgEdge* const srcsp = new DfgEdge[n]; + for (size_t i = 0; i < n; ++i) srcsp[i].init(this); + return srcsp; + } + + // Double the capacity of m_srcsp + void growSources() { + m_srcCap *= 2; + DfgEdge* const newsp = allocSources(m_srcCap); + for (size_t i = 0; i < m_srcCnt; ++i) { + DfgEdge* const oldp = m_srcsp + i; + // Skip over unlinked source edge + if (!oldp->sourcep()) continue; + // New edge driven from the same vertex as the old edge + newsp[i].relinkSource(oldp->sourcep()); + // Unlink the old edge, it will be deleted + oldp->unlinkSource(); + } + // Delete old source edges + delete[] m_srcsp; + // Keep hold of new source edges + m_srcsp = newsp; + } + +protected: + DfgVertexVariadic(DfgGraph& dfg, VDfgType type, FileLine* flp, AstNodeDType* dtypep, + uint32_t initialCapacity = 1) + : DfgVertex{dfg, type, flp, dtypep} + , m_srcsp{allocSources(initialCapacity)} + , m_srcCap{initialCapacity} {} + + ~DfgVertexVariadic() override { delete[] m_srcsp; }; + + DfgEdge* addSource() { + if (m_srcCnt == m_srcCap) growSources(); + return m_srcsp + m_srcCnt++; + } + + void resetSources() { + // #ifdef VL_DEBUG TODO: DEBUG ONLY + for (uint32_t i = 0; i < m_srcCnt; ++i) { + UASSERT_OBJ(!m_srcsp[i].sourcep(), m_srcsp[i].sourcep(), "Connected source"); + } + // #endif + m_srcCnt = 0; + } + +public: + ASTGEN_MEMBERS_DfgVertexVariadic; + + DfgEdge* sourceEdge(size_t idx) const { return &m_srcsp[idx]; } + DfgVertex* source(size_t idx) const { return m_srcsp[idx].sourcep(); } + + std::pair sourceEdges() override { return {m_srcsp, m_srcCnt}; } + std::pair sourceEdges() const override { return {m_srcsp, m_srcCnt}; } +}; + +// DfgVertex subclasses +#include "V3DfgVertices.h" + +// The rest of the DfgVertex subclasses are generated by 'astgen' from AstNodeMath nodes +#include "V3Dfg__gen_auto_classes.h" + bool DfgVertex::isZero() const { if (const DfgConst* const constp = cast()) return constp->isZero(); return false; diff --git a/src/V3DfgAstToDfg.cpp b/src/V3DfgAstToDfg.cpp index c63814f90..32344bdff 100644 --- a/src/V3DfgAstToDfg.cpp +++ b/src/V3DfgAstToDfg.cpp @@ -41,8 +41,8 @@ namespace { // Create a DfgVertex out of a AstNodeMath. For most AstNodeMath subtypes, this can be done // automatically. For the few special cases, we provide specializations below -template -Vertex* makeVertex(const AstForDfg* nodep, DfgGraph& dfg) { +template +Vertex* makeVertex(const Node* nodep, DfgGraph& dfg) { return new Vertex{dfg, nodep->fileline(), DfgVertex::dtypeFor(nodep)}; } @@ -51,22 +51,22 @@ Vertex* makeVertex(const AstForDfg* nodep, DfgGraph& dfg) { // LCOV_EXCL_START // AstCCast changes width, but should not exists where DFG optimization is currently invoked template <> -DfgCCast* makeVertex(const AstCCast*, DfgGraph&) { +DfgCCast* makeVertex(const AstCCast*, DfgGraph&) { return nullptr; } // Unhandled in DfgToAst, but also operates on strings which we don't optimize anyway template <> -DfgAtoN* makeVertex(const AstAtoN*, DfgGraph&) { +DfgAtoN* makeVertex(const AstAtoN*, DfgGraph&) { return nullptr; } // Unhandled in DfgToAst, but also operates on strings which we don't optimize anyway template <> -DfgCompareNN* makeVertex(const AstCompareNN*, DfgGraph&) { +DfgCompareNN* makeVertex(const AstCompareNN*, DfgGraph&) { return nullptr; } // Unhandled in DfgToAst, but also operates on unpacked arrays which we don't optimize anyway template <> -DfgSliceSel* makeVertex(const AstSliceSel*, DfgGraph&) { +DfgSliceSel* makeVertex(const AstSliceSel*, DfgGraph&) { return nullptr; } // LCOV_EXCL_STOP @@ -105,11 +105,11 @@ class AstToDfgVisitor final : public VNVisitor { m_uncommittedVertices.clear(); } - DfgVertexLValue* getNet(AstVar* varp) { + DfgVertexVar* getNet(AstVar* varp) { if (!varp->user1p()) { - // Note DfgVertexLValue vertices are not added to m_uncommittedVertices, because we + // Note DfgVertexVar vertices are not added to m_uncommittedVertices, because we // want to hold onto them via AstVar::user1p, and the AstVar might be referenced via - // multiple AstVarRef instances, so we will never revert a DfgVertexLValue once + // multiple AstVarRef instances, so we will never revert a DfgVertexVar once // created. We will delete unconnected variable vertices at the end. if (VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) { DfgVarArray* const vtxp = new DfgVarArray{*m_dfgp, varp}; @@ -122,7 +122,7 @@ class AstToDfgVisitor final : public VNVisitor { varp->user1p(vtxp); } } - return varp->user1u().to(); + return varp->user1u().to(); } DfgVertex* getVertex(AstNode* nodep) { diff --git a/src/V3DfgDfgToAst.cpp b/src/V3DfgDfgToAst.cpp index 9666b203c..de08f1060 100644 --- a/src/V3DfgDfgToAst.cpp +++ b/src/V3DfgDfgToAst.cpp @@ -42,8 +42,8 @@ namespace { // Create an AstNodeMath out of a DfgVertex. For most AstNodeMath subtypes, this can be done // automatically. For the few special cases, we provide specializations below -template -Node* makeNode(const DfgForAst* vtxp, Ops... ops) { +template +Node* makeNode(const Vertex* vtxp, Ops... ops) { Node* const nodep = new Node{vtxp->fileline(), ops...}; UASSERT_OBJ(nodep->width() == static_cast(vtxp->width()), vtxp, "Incorrect width in AstNode created from DfgVertex " @@ -55,31 +55,31 @@ Node* makeNode(const DfgForAst* vtxp, Ops... ops) { // Vertices needing special conversion template <> -AstExtend* makeNode( // +AstExtend* makeNode( // const DfgExtend* vtxp, AstNodeMath* op1) { return new AstExtend{vtxp->fileline(), op1, static_cast(vtxp->width())}; } template <> -AstExtendS* makeNode( // +AstExtendS* makeNode( // const DfgExtendS* vtxp, AstNodeMath* op1) { return new AstExtendS{vtxp->fileline(), op1, static_cast(vtxp->width())}; } template <> -AstShiftL* makeNode( // +AstShiftL* makeNode( // const DfgShiftL* vtxp, AstNodeMath* op1, AstNodeMath* op2) { return new AstShiftL{vtxp->fileline(), op1, op2, static_cast(vtxp->width())}; } template <> -AstShiftR* makeNode( // +AstShiftR* makeNode( // const DfgShiftR* vtxp, AstNodeMath* op1, AstNodeMath* op2) { return new AstShiftR{vtxp->fileline(), op1, op2, static_cast(vtxp->width())}; } template <> -AstShiftRS* makeNode( // +AstShiftRS* makeNode( // const DfgShiftRS* vtxp, AstNodeMath* op1, AstNodeMath* op2) { return new AstShiftRS{vtxp->fileline(), op1, op2, static_cast(vtxp->width())}; } @@ -88,20 +88,21 @@ AstShiftRS* makeNode( // // Currently unhandled nodes - see corresponding AstToDfg functions // LCOV_EXCL_START template <> -AstCCast* makeNode(const DfgCCast* vtxp, AstNodeMath*) { +AstCCast* makeNode(const DfgCCast* vtxp, AstNodeMath*) { vtxp->v3fatalSrc("not implemented"); } template <> -AstAtoN* makeNode(const DfgAtoN* vtxp, AstNodeMath*) { +AstAtoN* makeNode(const DfgAtoN* vtxp, AstNodeMath*) { vtxp->v3fatalSrc("not implemented"); } template <> -AstCompareNN* makeNode(const DfgCompareNN* vtxp, +AstCompareNN* +makeNode(const DfgCompareNN* vtxp, AstNodeMath*, AstNodeMath*) { vtxp->v3fatalSrc("not implemented"); } template <> -AstSliceSel* makeNode( +AstSliceSel* makeNode( const DfgSliceSel* vtxp, AstNodeMath*, AstNodeMath*, AstNodeMath*) { vtxp->v3fatalSrc("not implemented"); } @@ -215,8 +216,7 @@ class DfgToAstVisitor final : DfgVisitor { // Inline vertices that drive only a single node, or are special if (!vtx.hasMultipleSinks()) return true; if (vtx.is()) return true; - if (vtx.is()) return true; - if (vtx.is()) return true; + if (vtx.is()) return true; if (const DfgArraySel* const selp = vtx.cast()) { return selp->bitp()->is(); } diff --git a/src/V3DfgPasses.cpp b/src/V3DfgPasses.cpp index 0c975fa98..bd192416a 100644 --- a/src/V3DfgPasses.cpp +++ b/src/V3DfgPasses.cpp @@ -154,7 +154,7 @@ void V3DfgPasses::removeVars(DfgGraph& dfg, DfgRemoveVarsContext& ctx) { void V3DfgPasses::removeUnused(DfgGraph& dfg) { const auto processVertex = [&](DfgVertex& vtx) { // Keep variables - if (vtx.is() || vtx.is()) return false; + if (vtx.is()) return false; // Keep if it has sinks if (vtx.hasSinks()) return false; // Unlink and delete vertex diff --git a/src/V3DfgPeephole.cpp b/src/V3DfgPeephole.cpp index 8ba02b5e2..e02671d64 100644 --- a/src/V3DfgPeephole.cpp +++ b/src/V3DfgPeephole.cpp @@ -115,7 +115,7 @@ class V3DfgPeephole final : public DfgVisitor { DfgConst* makeZero(FileLine* flp, uint32_t width) { return makeConst(flp, width, 0); } // Transformations that apply to all commutative binary vertices - void commutativeBinary(DfgVertexWithArity<2>* vtxp) { + void commutativeBinary(DfgVertexBinary* vtxp) { DfgVertex* const lhsp = vtxp->source<0>(); DfgVertex* const rhsp = vtxp->source<1>(); // Ensure Const is on left-hand side to simplify other patterns @@ -138,9 +138,9 @@ class V3DfgPeephole final : public DfgVisitor { } // If both sides are variable references, order the side in some defined way. This allows // CSE to later merge 'a op b' with 'b op a'. - if (lhsp->is() && rhsp->is()) { - AstVar* const lVarp = lhsp->as()->varp(); - AstVar* const rVarp = rhsp->as()->varp(); + if (lhsp->is() && rhsp->is()) { + AstVar* const lVarp = lhsp->as()->varp(); + AstVar* const rVarp = rhsp->as()->varp(); if (lVarp->name() > rVarp->name()) { APPLYING(SWAP_VAR_IN_COMMUTATIVE_BINARY) { vtxp->lhsp(rhsp); @@ -152,12 +152,12 @@ class V3DfgPeephole final : public DfgVisitor { } // Transformations that apply to all associative binary vertices - void associativeBinary(DfgVertexWithArity<2>* vtxp) { + void associativeBinary(DfgVertexBinary* vtxp) { DfgVertex* const lhsp = vtxp->lhsp(); // Make associative trees right leaning (for better CSE opportunities) if (lhsp->type() == vtxp->type() && !lhsp->hasMultipleSinks()) { - DfgVertexWithArity<2>* const lBinp = static_cast*>(lhsp); + DfgVertexBinary* const lBinp = lhsp->as(); APPLYING(RIGHT_LEANING_ASSOC) { vtxp->replaceWith(lBinp); vtxp->lhsp(lBinp->rhsp()); @@ -242,7 +242,7 @@ class V3DfgPeephole final : public DfgVisitor { newRhsp->rhsp(concatp->rhsp()); // The replacement Vertex - DfgVertexWithArity<2>* const replacementp + DfgVertexBinary* const replacementp = std::is_same::value ? new DfgAnd{m_dfg, concatp->fileline(), m_bitDType} : nullptr; @@ -334,7 +334,7 @@ class V3DfgPeephole final : public DfgVisitor { rReducep->srcp(concatp->rhsp()); // Bitwise reduce the results - DfgVertexWithArity<2>* const replacementp = new Bitwise{m_dfg, flp, m_bitDType}; + Bitwise* const replacementp = new Bitwise{m_dfg, flp, m_bitDType}; replacementp->lhsp(lReducep); replacementp->rhsp(rReducep); vtxp->replaceWith(replacementp); @@ -362,7 +362,7 @@ class V3DfgPeephole final : public DfgVisitor { } } - void optimizeShiftRHS(DfgVertexWithArity<2>* vtxp) { + void optimizeShiftRHS(DfgVertexBinary* vtxp) { if (const DfgConcat* const concatp = vtxp->rhsp()->cast()) { if (concatp->lhsp()->isZero()) { // Drop redundant zero extension APPLYING(REMOVE_REDUNDANT_ZEXT_ON_RHS_OF_SHIFT) { // @@ -1330,12 +1330,12 @@ class V3DfgPeephole final : public DfgVisitor { // Process one vertex. Return true if graph changed bool processVertex(DfgVertex& vtx) { - // Keep DfgVertexLValue vertices in this pass. We will remove them later if they become + // Keep DfgVertexVar vertices in this pass. We will remove them later if they become // redundant. We want to keep the original variables for non-var vertices that drive // multiple sinks (otherwise we would need to introduce a temporary, but it is better for // debugging to keep the original variable name, if one is available), so we can't remove // redundant variables here. - const bool keep = vtx.is() || vtx.is(); + const bool keep = vtx.is(); // If it has no sinks (unused), we can remove it if (!keep && !vtx.hasSinks()) { diff --git a/src/V3DfgVertices.h b/src/V3DfgVertices.h new file mode 100644 index 000000000..f504bcbd3 --- /dev/null +++ b/src/V3DfgVertices.h @@ -0,0 +1,229 @@ +// -*- mode: C++; c-file-style: "cc-mode" -*- +//************************************************************************* +// DESCRIPTION: Verilator: DfgVertex sub-classes +// +// Code available from: https://verilator.org +// +//************************************************************************* +// +// Copyright 2003-2022 by Wilson Snyder. This program is free software; you +// can redistribute it and/or modify it under the terms of either the GNU +// Lesser General Public License Version 3 or the Perl Artistic License +// Version 2.0. +// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0 +// +//************************************************************************* +// +// This is a data-flow graph based representation of combinational logic, +// the main difference from a V3Graph is that DfgVertex owns the storage +// of it's input edges (operands/sources/arguments), and can access each +// input edge directly by indexing, making modifications more efficient +// than the linked list based structures used by V3Graph. +// +// A bulk of the DfgVertex sub-types are generated by astgen, and are +// analogous to the corresponding AstNode sub-types. +// +// See also the internals documentation docs/internals.rst +// +//************************************************************************* + +#ifndef VERILATOR_V3DFGVERTICES_H_ +#define VERILATOR_V3DFGVERTICES_H_ + +#ifndef VERILATOR_V3DFG_H_ +#error "Use V3Dfg.h as the include" +#include "V3Dfg.h" // This helps code analysis tools pick up symbols in V3Dfg.h +#define VL_NOT_FINAL // This #define fixes broken code folding in the CLion IDE +#endif + +// === Abstract base node types (DfgVertex*) =================================== + +class DfgVertexVar VL_NOT_FINAL : public DfgVertexVariadic { + AstVar* const m_varp; // The AstVar associated with this vertex (not owned by this vertex) + bool m_hasModRefs = false; // This AstVar is referenced outside the DFG, but in the module + bool m_hasExtRefs = false; // This AstVar is referenced from outside the module + +public: + DfgVertexVar(DfgGraph& dfg, VDfgType type, AstVar* varp, uint32_t initialCapacity) + : DfgVertexVariadic{dfg, type, varp->fileline(), dtypeFor(varp), initialCapacity} + , m_varp{varp} {} + ASTGEN_MEMBERS_DfgVertexVar; + + AstVar* varp() const { return m_varp; } + bool hasModRefs() const { return m_hasModRefs; } + void setHasModRefs() { m_hasModRefs = true; } + bool hasExtRefs() const { return m_hasExtRefs; } + void setHasExtRefs() { m_hasExtRefs = true; } + bool hasRefs() const { return m_hasModRefs || m_hasExtRefs; } + + // Variable cannot be removed, even if redundant in the DfgGraph (might be used externally) + bool keep() const { + // Keep if referenced outside this module + if (hasExtRefs()) return true; + // Keep if traced + if (v3Global.opt.trace() && varp()->isTrace()) return true; + // Keep if public + if (varp()->isSigPublic()) return true; + // Otherwise it can be removed + return false; + } +}; + +// === Concrete node types ===================================================== + +// === DfgVertex === +class DfgConst final : public DfgVertex { + friend class DfgVertex; + friend class DfgVisitor; + + AstConst* const m_constp; // The AstConst associated with this vertex (owned by this vertex) + + bool selfEquals(const DfgVertex& that) const override; + V3Hash selfHash() const override; + +public: + DfgConst(DfgGraph& dfg, AstConst* constp) + : DfgVertex{dfg, dfgType(), constp->fileline(), dtypeFor(constp)} + , m_constp{constp} {} + ASTGEN_MEMBERS_DfgConst; + + ~DfgConst() override { VL_DO_DANGLING(m_constp->deleteTree(), m_constp); } + + AstConst* constp() const { return m_constp; } + V3Number& num() const { return m_constp->num(); } + + uint32_t toU32() const { return num().toUInt(); } + int32_t toI32() const { return num().toSInt(); } + + bool isZero() const { return num().isEqZero(); } + bool isOnes() const { return num().isEqAllOnes(width()); } + + std::pair sourceEdges() override { return {nullptr, 0}; } + std::pair sourceEdges() const override { return {nullptr, 0}; } + const string srcName(size_t) const override { // LCOV_EXCL_START + VL_UNREACHABLE; + return ""; + } // LCOV_EXCL_STOP +}; + +// === DfgVertexVar === +class DfgVarArray final : public DfgVertexVar { + friend class DfgVertex; + friend class DfgVisitor; + + using DriverData = std::pair; + + std::vector m_driverData; // Additional data associate with each driver + + bool selfEquals(const DfgVertex& that) const override; + V3Hash selfHash() const override; + +public: + DfgVarArray(DfgGraph& dfg, AstVar* varp) + : DfgVertexVar{dfg, dfgType(), varp, 4u} { + UASSERT_OBJ(VN_IS(varp->dtypeSkipRefp(), UnpackArrayDType), varp, "Non array DfgVarArray"); + } + ASTGEN_MEMBERS_DfgVarArray; + + bool isDrivenByDfg() const { return arity() > 0; } + + void addDriver(FileLine* flp, uint32_t index, DfgVertex* vtxp) { + m_driverData.emplace_back(flp, index); + DfgVertexVariadic::addSource()->relinkSource(vtxp); + } + + void resetSources() { + m_driverData.clear(); + DfgVertexVariadic::resetSources(); + } + + // Remove undriven sources + void packSources() { + // Grab and reset the driver data + std::vector driverData{std::move(m_driverData)}; + + // Grab and unlink the sources + std::vector sources{arity()}; + forEachSourceEdge([&](DfgEdge& edge, size_t idx) { + sources[idx] = edge.sourcep(); + edge.unlinkSource(); + }); + DfgVertexVariadic::resetSources(); + + // Add back the driven sources + for (size_t i = 0; i < sources.size(); ++i) { + if (!sources[i]) continue; + addDriver(driverData[i].first, driverData[i].second, sources[i]); + } + } + + FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; } + uint32_t driverIndex(size_t idx) const { return m_driverData[idx].second; } + + DfgVertex* driverAt(size_t idx) const { + const DfgEdge* const edgep = findSourceEdge([=](const DfgEdge&, size_t i) { // + return driverIndex(i) == idx; + }); + return edgep ? edgep->sourcep() : nullptr; + } + + const string srcName(size_t idx) const override { return cvtToStr(driverIndex(idx)); } +}; +class DfgVarPacked final : public DfgVertexVar { + friend class DfgVertex; + friend class DfgVisitor; + + using DriverData = std::pair; + + std::vector m_driverData; // Additional data associate with each driver + + bool selfEquals(const DfgVertex& that) const override; + V3Hash selfHash() const override; + +public: + DfgVarPacked(DfgGraph& dfg, AstVar* varp) + : DfgVertexVar{dfg, dfgType(), varp, 1u} {} + ASTGEN_MEMBERS_DfgVarPacked; + + bool isDrivenByDfg() const { return arity() > 0; } + bool isDrivenFullyByDfg() const { return arity() == 1 && source(0)->dtypep() == dtypep(); } + + void addDriver(FileLine* flp, uint32_t lsb, DfgVertex* vtxp) { + m_driverData.emplace_back(flp, lsb); + DfgVertexVariadic::addSource()->relinkSource(vtxp); + } + + void resetSources() { + m_driverData.clear(); + DfgVertexVariadic::resetSources(); + } + + // Remove undriven sources + void packSources() { + // Grab and reset the driver data + std::vector driverData{std::move(m_driverData)}; + + // Grab and unlink the sources + std::vector sources{arity()}; + forEachSourceEdge([&](DfgEdge& edge, size_t idx) { + sources[idx] = edge.sourcep(); + edge.unlinkSource(); + }); + DfgVertexVariadic::resetSources(); + + // Add back the driven sources + for (size_t i = 0; i < sources.size(); ++i) { + if (!sources[i]) continue; + addDriver(driverData[i].first, driverData[i].second, sources[i]); + } + } + + FileLine* driverFileLine(size_t idx) const { return m_driverData[idx].first; } + uint32_t driverLsb(size_t idx) const { return m_driverData[idx].second; } + + const string srcName(size_t idx) const override { + return isDrivenFullyByDfg() ? "" : cvtToStr(driverLsb(idx)); + } +}; + +#endif diff --git a/src/astgen b/src/astgen index f0883dd08..3348d0e44 100755 --- a/src/astgen +++ b/src/astgen @@ -8,12 +8,14 @@ import os import re import sys import textwrap + # from pprint import pprint, pformat +# This class is used to represents both AstNode and DfgVertex sub-types class Node: - def __init__(self, name, superClass, file, lineno): + def __init__(self, name, superClass, file=None, lineno=None): self._name = name self._superClass = superClass self._subClasses = [] # Initially list, but tuple after completion @@ -173,9 +175,11 @@ class Node: return self in other.allSubClasses -Nodes = {} -SortedNodes = None -DfgVertices = None +AstNodes = {} +AstNodeList = None + +DfgVertices = {} +DfgVertexList = None ClassRefs = {} Stages = {} @@ -278,7 +282,7 @@ class Cpt: self.error("Can't parse from function: " + func) typen = match.group(1) subnodes = match.group(2) - if Nodes[typen].isRoot: + if AstNodes[typen].isRoot: self.error("Unknown AstNode typen: " + typen + ": in " + func) mif = "" @@ -333,7 +337,7 @@ class Cpt: elif match_skip: typen = match_skip.group(1) self.tree_skip_visit[typen] = 1 - if typen not in Nodes: + if typen not in AstNodes: self.error("Unknown node type: " + typen) else: @@ -463,7 +467,7 @@ class Cpt: self.print( " // Bottom class up, as more simple transforms are generally better\n" ) - for node in SortedNodes: + for node in AstNodeList: out_for_type_sc = [] out_for_type = [] classes = list(node.allSuperClasses) @@ -502,7 +506,7 @@ class Cpt: "".join(out_for_type_sc)) if out_for_type[0]: self.print(" iterateAndNextNull(nodep->rhsp());\n") - if node.isSubClassOf(Nodes["NodeTriop"]): + if node.isSubClassOf(AstNodes["NodeTriop"]): self.print( " iterateAndNextNull(nodep->thsp());\n") self.print("".join(out_for_type) + " }\n") @@ -542,7 +546,7 @@ def parseOpType(string): return None -def read_types(filename): +def read_types(filename, Nodes, prefix): hasErrors = False def error(lineno, message): @@ -560,8 +564,9 @@ def read_types(filename): return if not hasAstgenMembers: error( - node.lineno, "'Ast" + node.name + - "' does not contain 'ASTGEN_MEMBERS_" + node.name + ";'") + node.lineno, + "'{p}{n}' does not contain 'ASTGEN_MEMBERS_{p}{n};'".format( + p=prefix, n=node.name)) hasAstgenMembers = False with open(filename) as fh: @@ -575,12 +580,12 @@ def read_types(filename): classn = match.group(2) match = re.search(r':\s*public\s+(\S+)', line) supern = match.group(1) if match else "" - if re.search(r'Ast', supern): - classn = re.sub(r'^Ast', '', classn) - supern = re.sub(r'^Ast', '', supern) + if re.search(prefix, supern): + classn = re.sub(r'^' + prefix, '', classn) + supern = re.sub(r'^' + prefix, '', supern) if not supern: - sys.exit("%Error: 'Ast{}' has no super-class".format( - classn)) + sys.exit("%Error: '{p}{c}' has no super-class".format( + p=prefix, c=classn)) checkFinishedNode(node) superClass = Nodes[supern] node = Node(classn, superClass, filename, lineno) @@ -589,8 +594,13 @@ def read_types(filename): if not node: continue - if re.match(r'^\s*ASTGEN_MEMBERS_' + node.name + ';', line): + if re.match(r'^\s*ASTGEN_MEMBERS_' + prefix + node.name + ';', + line): hasAstgenMembers = True + + if prefix != "Ast": + continue + match = re.match(r'^\s*//\s*@astgen\s+(.*)$', line) if match: decl = re.sub(r'//.*$', '', match.group(1)) @@ -650,6 +660,59 @@ def read_types(filename): sys.exit("%Error: Stopping due to errors reported above") +def check_types(sortedTypes, prefix, abstractPrefix): + baseClass = prefix + abstractPrefix + + # Check all leaf types are not AstNode* and non-leaves are AstNode* + for node in sortedTypes: + if re.match(r'^' + abstractPrefix, node.name): + if node.isLeaf: + sys.exit( + "%Error: Final {b} subclasses must not be named {b}*: {p}{n}" + .format(b=baseClass, p=prefix, n=node.name)) + else: + if not node.isLeaf: + sys.exit( + "%Error: Non-final {b} subclasses must be named {b}*: {p}{n}" + .format(b=baseClass, p=prefix, n=node.name)) + + # Check ordering of node definitions + hasOrderingError = False + + files = tuple( + sorted(set(_.file for _ in sortedTypes if _.file is not None))) + + for file in files: + nodes = tuple(filter(lambda _, f=file: _.file == f, sortedTypes)) + expectOrder = tuple(sorted(nodes, key=lambda _: (_.isLeaf, _.ordIdx))) + actualOrder = tuple(sorted(nodes, key=lambda _: _.lineno)) + expect = { + node: pred + for pred, node in zip((None, ) + expectOrder[:-1], expectOrder) + } + actual = { + node: pred + for pred, node in zip((None, ) + actualOrder[:-1], actualOrder) + } + for node in nodes: + if expect[node] != actual[node]: + hasOrderingError = True + pred = expect[node] + print( + "{file}:{lineno}: %Error: Definition of '{p}{n}' is out of order. Shold be {where}." + .format(file=file, + lineno=node.lineno, + p=prefix, + n=node.name, + where=("right after '" + prefix + pred.name + + "'" if pred else "first in file")), + file=sys.stderr) + + if hasOrderingError: + sys.exit( + "%Error: Stopping due to out of order definitions listed above") + + def read_stages(filename): with open(filename) as fh: n = 100 @@ -712,7 +775,7 @@ def write_report(filename): fh.write(" " + classn + "\n") fh.write("\nClasses:\n") - for node in SortedNodes: + for node in AstNodeList: fh.write(" class Ast%-17s\n" % node.name) fh.write(" arity: {}\n".format(node.arity)) fh.write(" parent: ") @@ -741,97 +804,110 @@ def write_report(filename): fh.write("\n") -def write_classes(filename): - with open_file(filename) as fh: - fh.write("class AstNode;\n") - for node in SortedNodes: - fh.write("class Ast%-17s // " % (node.name + ";")) +################################################################################ +# Common code genaration +################################################################################ + + +def write_forward_class_decls(prefix, nodeList): + with open_file("V3{p}__gen_forward_class_decls.h".format(p=prefix)) as fh: + for node in nodeList: + fh.write("class {p}{n:<17} // ".format(p=prefix, + n=node.name + ";")) for superClass in node.allSuperClasses: - fh.write("Ast%-12s " % superClass.name) + fh.write("{p}{n:<12} ".format(p=prefix, n=superClass.name)) fh.write("\n") -def write_visitor_decls(filename): - with open_file(filename) as fh: - for node in SortedNodes: +def write_visitor_decls(prefix, nodeList): + with open_file("V3{p}__gen_visitor_decls.h".format(p=prefix)) as fh: + for node in nodeList: if not node.isRoot: - fh.write("virtual void visit(Ast" + node.name + "*);\n") + fh.write("virtual void visit({p}{n}*);\n".format(p=prefix, + n=node.name)) -def write_visitor_defns(filename): - with open_file(filename) as fh: - for node in SortedNodes: +def write_visitor_defns(prefix, nodeList, visitor): + with open_file("V3{p}__gen_visitor_defns.h".format(p=prefix)) as fh: + variable = "nodep" if prefix == "Ast" else "vtxp" + for node in nodeList: base = node.superClass if base is not None: - fh.write("void VNVisitor::visit(Ast" + node.name + - "* nodep) { visit(static_cast(nodep)); }\n") + fh.write( + "void {c}::visit({p}{n}* {v}) {{ visit(static_cast<{p}{b}*>({v})); }}\n" + .format(c=visitor, + p=prefix, + n=node.name, + b=base.name, + v=variable)) -def write_impl(filename): - with open_file(filename) as fh: - fh.write("\n") - fh.write("// For internal use. They assume argument is not nullptr.\n") - for node in SortedNodes: - fh.write("template<> inline bool AstNode::privateTypeTest(const AstNode* nodep) { ") - if node.isRoot: - fh.write("return true; ") - else: - fh.write("return ") - if not node.isLeaf: - fh.write( - "static_cast(nodep->type()) >= static_cast(VNType::first" - + node.name + ") && ") - fh.write( - "static_cast(nodep->type()) <= static_cast(VNType::last" - + node.name + "); ") - else: - fh.write("nodep->type() == VNType::at" + node.name + "; ") - fh.write("}\n") +def write_type_enum(prefix, nodeList): + root = next(_ for _ in nodeList if _.isRoot) + with open_file("V3{p}__gen_type_enum.h".format(p=prefix)) as fh: - -def write_types(filename): - with open_file(filename) as fh: fh.write(" enum en : uint16_t {\n") - for node in sorted(filter(lambda _: _.isLeaf, SortedNodes), + for node in sorted(filter(lambda _: _.isLeaf, nodeList), key=lambda _: _.typeId): - fh.write(" at" + node.name + " = " + str(node.typeId) + - ",\n") - fh.write(" _ENUM_END = " + str(Nodes["Node"].typeIdMax + 1) + - "\n") + fh.write(" at{t} = {n},\n".format(t=node.name, + n=node.typeId)) + fh.write(" _ENUM_END = {n}\n".format(n=root.typeIdMax + 1)) fh.write(" };\n") fh.write(" enum bounds : uint16_t {\n") - for node in sorted(filter(lambda _: not _.isLeaf, SortedNodes), + for node in sorted(filter(lambda _: not _.isLeaf, nodeList), key=lambda _: _.typeIdMin): - fh.write(" first" + node.name + " = " + - str(node.typeIdMin) + ",\n") - fh.write(" last" + node.name + " = " + str(node.typeIdMax) + - ",\n") + fh.write(" first{t} = {n},\n".format(t=node.name, + n=node.typeIdMin)) + fh.write(" last{t} = {n},\n".format(t=node.name, + n=node.typeIdMax)) fh.write(" _BOUNDS_END\n") fh.write(" };\n") fh.write(" const char* ascii() const {\n") fh.write(" static const char* const names[_ENUM_END + 1] = {\n") - for node in sorted(filter(lambda _: _.isLeaf, SortedNodes), + for node in sorted(filter(lambda _: _.isLeaf, nodeList), key=lambda _: _.typeId): - fh.write(" \"" + node.name.upper() + "\",\n") + fh.write(' "{T}",\n'.format(T=node.name.upper())) fh.write(" \"_ENUM_END\"\n") fh.write(" };\n") fh.write(" return names[m_e];\n") fh.write(" }\n") -def write_yystype(filename): - with open_file(filename) as fh: - for node in SortedNodes: - fh.write("Ast{t}* {m}p;\n".format(t=node.name, - m=node.name[0].lower() + - node.name[1:])) +def write_type_tests(prefix, nodeList): + with open_file("V3{p}__gen_type_tests.h".format(p=prefix)) as fh: + fh.write("// For internal use. They assume argument is not nullptr.\n") + if prefix == "Ast": + base = "AstNode" + variable = "nodep" + enum = "VNType" + elif prefix == "Dfg": + base = "DfgVertex" + variable = "vtxp" + enum = "VDfgType" + for node in nodeList: + fh.write( + "template<> inline bool {b}::privateTypeTest<{p}{n}>(const {b}* {v}) {{ " + .format(b=base, p=prefix, n=node.name, v=variable)) + if node.isRoot: + fh.write("return true;") + elif not node.isLeaf: + fh.write( + "return static_cast({v}->type()) >= static_cast({e}::first{t}) && static_cast({v}->type()) <= static_cast({e}::last{t});" + .format(v=variable, e=enum, t=node.name)) + else: + fh.write("return {v}->type() == {e}::at{t};".format( + v=variable, e=enum, t=node.name)) + fh.write(" }\n") -def write_macros(filename): +################################################################################ +# Ast code genaration +################################################################################ + + +def write_ast_macros(filename): with open_file(filename) as fh: def emitBlock(pattern, **fmt): @@ -839,8 +915,8 @@ def write_macros(filename): textwrap.indent(textwrap.dedent(pattern), " ").format(**fmt).replace("\n", " \\\n")) - for node in SortedNodes: - fh.write("#define ASTGEN_MEMBERS_{t} \\\n".format(t=node.name)) + for node in AstNodeList: + fh.write("#define ASTGEN_MEMBERS_Ast{t} \\\n".format(t=node.name)) emitBlock('''\ static Ast{t}* cloneTreeNull(Ast{t}* nodep, bool cloneNextLink) {{ return nodep ? nodep->cloneTree(cloneNextLink) : nullptr; @@ -860,7 +936,7 @@ def write_macros(filename): ''', t=node.name) - for n in (1, 2, 3, 4): + for n in range(1, 5): op = node.getOp(n) if not op: continue @@ -907,7 +983,15 @@ def write_macros(filename): fh.write("\n") -def write_op_checks(filename): +def write_ast_yystype(filename): + with open_file(filename) as fh: + for node in AstNodeList: + fh.write("Ast{t}* {m}p;\n".format(t=node.name, + m=node.name[0].lower() + + node.name[1:])) + + +def write_ast_op_checks(filename): with open_file(filename) as fh: indent = "" @@ -917,7 +1001,7 @@ def write_op_checks(filename): textwrap.indent(textwrap.dedent(pattern), indent).format(**fmt)) - for node in SortedNodes: + for node in AstNodeList: if not node.isLeaf: continue @@ -991,102 +1075,98 @@ def write_op_checks(filename): ''') -def write_dfg_vertex_classes(filename): +################################################################################ +# DFG code genaration +################################################################################ + + +def write_dfg_macros(filename): with open_file(filename) as fh: - fh.write("\n") - for node in DfgVertices: - fh.write("class Dfg{} final : public DfgVertexWithArity<{}> {{\n". - format(node.name, node.arity)) - fh.write(" friend class DfgVertex;\n") - fh.write(" friend class DfgVisitor;\n") - fh.write(" void accept(DfgVisitor& visitor) override;\n") + + def emitBlock(pattern, **fmt): fh.write( - " static constexpr DfgType dfgType() {{ return DfgType::at{t}; }};\n" - .format(t=node.name)) - fh.write("public:\n") - fh.write( - " Dfg{t}(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep) : DfgVertexWithArity<{a}>{{dfg, flp, dtypep, dfgType()}} {{}}\n" - .format(t=node.name, a=node.arity)) - # Accessors + textwrap.indent(textwrap.dedent(pattern), + " ").format(**fmt).replace("\n", " \\\n")) + + for node in DfgVertexList: + fh.write("#define ASTGEN_MEMBERS_Dfg{t} \\\n".format(t=node.name)) + + if node.isLeaf: + emitBlock('''\ + static constexpr VDfgType dfgType() {{ return VDfgType::at{t}; }}; + void accept(DfgVisitor& v) override {{ v.visit(this); }} + ''', + t=node.name) + + for n in range(1, node.arity + 1): + name, _, _ = node.getOp(n) + emitBlock('''\ + DfgVertex* {name}() const {{ return source<{n}>(); }} + void {name}(DfgVertex* vtxp) {{ relinkSource<{n}>(vtxp); }} + ''', + name=name, + n=n - 1) + operandNames = tuple( node.getOp(n)[0] for n in range(1, node.arity + 1)) - assert not operandNames or len(operandNames) == node.arity - for i, n in enumerate(operandNames): - fh.write( - " DfgVertex* {n}() const {{ return source<{i}>(); }}\n". - format(n=n, i=i)) - for i, n in enumerate(operandNames): - fh.write( - " void {n}(DfgVertex* vtxp) {{ relinkSource<{i}>(vtxp); }}\n" - .format(n=n, i=i)) if operandNames: - names = ", ".join(map(lambda _: '"' + _ + '"', operandNames)) - fh.write( - " const string srcName(size_t idx) const override {\n") - fh.write( - " static const char* names[{a}] = {{ {ns} }};\n". - format(a=node.arity, ns=names)) - fh.write(" return names[idx];\n") - fh.write(" }\n") - fh.write("};\n") - fh.write("\n") - fh.write("\n") - - fh.write("\n\ntemplate\n") - fh.write("struct DfgForAstImpl;\n\n") - for node in DfgVertices: - fh.write("template <>\n") + emitBlock('''\ + const std::string srcName(size_t idx) const override {{ + static const char* names[{a}] = {{ {ns} }}; + return names[idx]; + }} + ''', + a=node.arity, + ns=", ".join( + map(lambda _: '"' + _ + '"', operandNames))) fh.write( - "struct DfgForAstImpl {{\n".format(name=node.name)) - fh.write(" using type = Dfg{name};\n".format(name=node.name)) - fh.write("};\n") - fh.write("\ntemplate\n") - fh.write("using DfgForAst = typename DfgForAstImpl::type;\n") - - fh.write("\n\ntemplate\n") - fh.write("struct AstForDfgImpl;\n\n") - for node in DfgVertices: - fh.write("template <>\n") - fh.write( - "struct AstForDfgImpl {{\n".format(name=node.name)) - fh.write(" using type = Ast{name};\n".format(name=node.name)) - fh.write("};\n") - fh.write("\ntemplate\n") - fh.write("using AstForDfg = typename AstForDfgImpl::type;\n") + " static_assert(true, \"\")\n") # Swallowing the semicolon -def write_dfg_visitor_decls(filename): +def write_dfg_auto_classes(filename): with open_file(filename) as fh: - fh.write("\n") - fh.write("virtual void visit(DfgVertex*) = 0;\n") - for node in DfgVertices: - fh.write("virtual void visit(Dfg{}*);\n".format(node.name)) + def emitBlock(pattern, **fmt): + fh.write(textwrap.dedent(pattern).format(**fmt)) -def write_dfg_definitions(filename): - with open_file(filename) as fh: + for node in DfgVertexList: + # Only generate code for automatically derieved leaf nodes + if (node.file is not None) or not node.isLeaf: + continue + + emitBlock('''\ + class Dfg{t} final : public Dfg{s} {{ + public: + Dfg{t}(DfgGraph& dfg, FileLine* flp, AstNodeDType* dtypep) + : Dfg{s}{{dfg, dfgType(), flp, dtypep}} {{}} + ASTGEN_MEMBERS_Dfg{t}; + }}; + ''', + t=node.name, + s=node.superClass.name) fh.write("\n") - for node in DfgVertices: - fh.write( - "void Dfg{}::accept(DfgVisitor& visitor) {{ visitor.visit(this); }}\n" - .format(node.name)) - fh.write("\n") - for node in DfgVertices: - fh.write( - "void DfgVisitor::visit(Dfg{}* vtxp) {{ visit(static_cast(vtxp)); }}\n" - .format(node.name)) def write_dfg_ast_to_dfg(filename): with open_file(filename) as fh: - fh.write("\n") - for node in DfgVertices: + for node in DfgVertexList: + # Only generate code for automatically derieved leaf nodes + if (node.file is not None) or (not node.isLeaf): + continue + fh.write( "void visit(Ast{t}* nodep) override {{\n".format(t=node.name)) fh.write( - ' UASSERT_OBJ(!nodep->user1p(), nodep, "Already has Dfg vertex");\n' + ' UASSERT_OBJ(!nodep->user1p(), nodep, "Already has Dfg vertex");\n\n' ) - fh.write(" if (unhandled(nodep)) return;\n") + fh.write(" if (unhandled(nodep)) return;\n\n") + for i in range(node.arity): + fh.write(" iterate(nodep->op{j}p());\n".format(j=i + 1)) + fh.write(" if (m_foundUnhandled) return;\n") + fh.write( + ' UASSERT_OBJ(nodep->op{j}p()->user1p(), nodep, "Child {j} missing Dfg vertex");\n' + .format(j=i + 1)) + fh.write("\n") fh.write( " Dfg{t}* const vtxp = makeVertex(nodep, *m_dfgp);\n" .format(t=node.name)) @@ -1095,24 +1175,23 @@ def write_dfg_ast_to_dfg(filename): fh.write(" ++m_ctx.m_nonRepNode;\n") fh.write(" return;\n") fh.write(" }\n\n") - fh.write(" m_uncommittedVertices.push_back(vtxp);\n") for i in range(node.arity): - fh.write(" iterate(nodep->op{j}p());\n".format(j=i + 1)) - fh.write(" if (m_foundUnhandled) return;\n") fh.write( - ' UASSERT_OBJ(nodep->op{j}p()->user1p(), nodep, "Child {j} missing Dfg vertex");\n' - .format(j=i + 1)) - fh.write( - " vtxp->relinkSource<{i}>(nodep->op{j}p()->user1u().to());\n\n" + " vtxp->relinkSource<{i}>(nodep->op{j}p()->user1u().to());\n" .format(i=i, j=i + 1)) + fh.write("\n") + fh.write(" m_uncommittedVertices.push_back(vtxp);\n") fh.write(" nodep->user1p(vtxp);\n") fh.write("}\n") def write_dfg_dfg_to_ast(filename): with open_file(filename) as fh: - fh.write("\n") - for node in DfgVertices: + for node in DfgVertexList: + # Only generate code for automatically derieved leaf nodes + if (node.file is not None) or (not node.isLeaf): + continue + fh.write( "void visit(Dfg{t}* vtxp) override {{\n".format(t=node.name)) for i in range(node.arity): @@ -1146,6 +1225,9 @@ parser.add_argument('-I', action='store', help='source code include directory') parser.add_argument('--astdef', action='append', help='add AST definition file (relative to -I)') +parser.add_argument('--dfgdef', + action='append', + help='add DFG definition file (relative to -I)') parser.add_argument('--classes', action='store_true', help='makes class declaration files') @@ -1155,66 +1237,86 @@ parser.add_argument('infiles', nargs='*', help='list of input .cpp filenames') Args = parser.parse_args() +############################################################################### +# Read AstNode definitions +############################################################################### + # Set up the root AstNode type. It is standalone so we don't need to parse the # sources for this. -Nodes["Node"] = Node("Node", None, "AstNode", 1) +AstNodes["Node"] = Node("Node", None) -# Read Ast node definitions +# Read AstNode definitions for filename in Args.astdef: - read_types(os.path.join(Args.I, filename)) + read_types(os.path.join(Args.I, filename), AstNodes, "Ast") # Compute derived properties over the whole AstNode hierarchy -Nodes["Node"].complete() +AstNodes["Node"].complete() -SortedNodes = tuple(map(lambda _: Nodes[_], sorted(Nodes.keys()))) +AstNodeList = tuple(map(lambda _: AstNodes[_], sorted(AstNodes.keys()))) -for node in SortedNodes: - # Check all leaves are not AstNode* and non-leaves are AstNode* - if re.match(r'^Node', node.name): - if node.isLeaf: - sys.exit( - "%Error: Final AstNode subclasses must not be named AstNode*: Ast" - + node.name) +check_types(AstNodeList, "Ast", "Node") + +############################################################################### +# Read and generate DfgVertex definitions +############################################################################### + +# Set up the root DfgVertex type and some other hand-written base types. +# These are standalone so we don't need to parse the sources for this. +DfgVertices["Vertex"] = Node("Vertex", None) +DfgVertices["VertexUnary"] = Node("VertexUnary", DfgVertices["Vertex"]) +DfgVertices["Vertex"].addSubClass(DfgVertices["VertexUnary"]) +DfgVertices["VertexBinary"] = Node("VertexBinary", DfgVertices["Vertex"]) +DfgVertices["Vertex"].addSubClass(DfgVertices["VertexBinary"]) +DfgVertices["VertexTernary"] = Node("VertexTernary", DfgVertices["Vertex"]) +DfgVertices["Vertex"].addSubClass(DfgVertices["VertexTernary"]) +DfgVertices["VertexVariadic"] = Node("VertexVariadic", DfgVertices["Vertex"]) +DfgVertices["Vertex"].addSubClass(DfgVertices["VertexVariadic"]) + +# Read DfgVertex definitions +for filename in Args.dfgdef: + read_types(os.path.join(Args.I, filename), DfgVertices, "Dfg") + +# Add the DfgVertex sub-types automatically derived from AstNode sub-types +for node in AstNodeList: + # Ignore the hierarchy for now + if not node.isLeaf: + continue + + # Ignore any explicitly defined vertex + if node.name in DfgVertices: + continue + + if node.isSubClassOf(AstNodes["NodeUniop"]): + base = DfgVertices["VertexUnary"] + elif node.isSubClassOf(AstNodes["NodeBiop"]): + base = DfgVertices["VertexBinary"] + elif node.isSubClassOf(AstNodes["NodeTriop"]): + base = DfgVertices["VertexTernary"] else: - if not node.isLeaf: - sys.exit( - "%Error: Non-final AstNode subclasses must be named AstNode*: Ast" - + node.name) + continue -DfgBases = (Nodes["NodeUniop"], Nodes["NodeBiop"], Nodes["NodeTriop"]) -DfgVertices = tuple( - node for node in SortedNodes - if node.isLeaf and any(node.isSubClassOf(base) for base in DfgBases)) + vertex = Node(node.name, base) + DfgVertices[node.name] = vertex + base.addSubClass(vertex) -# Check ordering of node definitions -files = tuple(sorted(set(_.file for _ in SortedNodes))) + for n in range(1, node.arity + 1): + op = node.getOp(n) + if op is not None: + name, monad, kind = op + assert monad == "", "Cannot represnt AstNode as DfgVertex" + vertex.addOp(n, name, "", "") -hasOrderingError = False -for file in files: - nodes = tuple(filter(lambda _, f=file: _.file == f, SortedNodes)) - expectOrder = tuple(sorted(nodes, key=lambda _: (_.isLeaf, _.ordIdx))) - actualOrder = tuple(sorted(nodes, key=lambda _: _.lineno)) - expect = { - node: pred - for pred, node in zip((None, ) + expectOrder[:-1], expectOrder) - } - actual = { - node: pred - for pred, node in zip((None, ) + actualOrder[:-1], actualOrder) - } - for node in nodes: - if expect[node] != actual[node]: - hasOrderingError = True - pred = expect[node] - print(file + ":" + str(node.lineno) + - ": %Error: Definition of 'Ast" + node.name + - "' is out of order. Should be " + - ("right after 'Ast" + pred.name + - "'" if pred else "first in file") + ".", - file=sys.stderr) +# Compute derived properties over the whole DfgVertex hierarchy +DfgVertices["Vertex"].complete() -if hasOrderingError: - sys.exit("%Error: Stopping due to out of order definitions listed above") +DfgVertexList = tuple(map(lambda _: DfgVertices[_], + sorted(DfgVertices.keys()))) + +check_types(DfgVertexList, "Dfg", "Vertex") + +############################################################################### +# Read additional files +############################################################################### read_stages(Args.I + "/Verilator.cpp") @@ -1224,19 +1326,29 @@ source_files.extend(glob.glob(Args.I + "/*.cpp")) for filename in source_files: read_refs(filename) +############################################################################### +# Generate output +############################################################################### + if Args.classes: write_report("V3Ast__gen_report.txt") - write_classes("V3Ast__gen_classes.h") - write_visitor_decls("V3Ast__gen_visitor_decls.h") - write_visitor_defns("V3Ast__gen_visitor_defns.h") - write_impl("V3Ast__gen_impl.h") - 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") - write_dfg_vertex_classes("V3Dfg__gen_vertex_classes.h") - write_dfg_visitor_decls("V3Dfg__gen_visitor_decls.h") - write_dfg_definitions("V3Dfg__gen_definitions.h") + # Write Ast code + write_forward_class_decls("Ast", AstNodeList) + write_visitor_decls("Ast", AstNodeList) + write_visitor_defns("Ast", AstNodeList, "VNVisitor") + write_type_enum("Ast", AstNodeList) + write_type_tests("Ast", AstNodeList) + write_ast_macros("V3Ast__gen_macros.h") + write_ast_yystype("V3Ast__gen_yystype.h") + write_ast_op_checks("V3Ast__gen_op_checks.h") + # Write Dfg code + write_forward_class_decls("Dfg", DfgVertexList) + write_visitor_decls("Dfg", DfgVertexList) + write_visitor_defns("Dfg", DfgVertexList, "DfgVisitor") + write_type_enum("Dfg", DfgVertexList) + write_type_tests("Dfg", DfgVertexList) + write_dfg_macros("V3Dfg__gen_macros.h") + write_dfg_auto_classes("V3Dfg__gen_auto_classes.h") write_dfg_ast_to_dfg("V3Dfg__gen_ast_to_dfg.h") write_dfg_dfg_to_ast("V3Dfg__gen_dfg_to_ast.h")