From 042d3eed237d7bab0c2b8637e0dc3a26d3b0e1e0 Mon Sep 17 00:00:00 2001 From: Wilson Snyder Date: Sat, 15 Aug 2020 11:44:10 -0400 Subject: [PATCH] C++11: Use override where possible. No functional change. --- include/verilated_fst_c.h | 6 +- include/verilated_vcd_c.h | 6 +- include/verilated_vpi.cpp | 80 +- src/V3Active.cpp | 6 +- src/V3ActiveTop.cpp | 2 +- src/V3Assert.cpp | 2 +- src/V3AssertPre.cpp | 2 +- src/V3Ast.h | 236 +- src/V3AstNodes.h | 4576 +++++++++++++++++++------------------ src/V3Begin.cpp | 4 +- src/V3Branch.cpp | 2 +- src/V3Broken.cpp | 6 +- src/V3CUse.cpp | 4 +- src/V3Case.cpp | 4 +- src/V3Cast.cpp | 2 +- src/V3Cdc.cpp | 24 +- src/V3Changed.cpp | 4 +- src/V3Class.cpp | 2 +- src/V3Clean.cpp | 2 +- src/V3Clock.cpp | 2 +- src/V3Combine.cpp | 8 +- src/V3Const.cpp | 6 +- src/V3Coverage.cpp | 2 +- src/V3CoverageJoin.cpp | 2 +- src/V3Dead.cpp | 4 +- src/V3Delayed.cpp | 2 +- src/V3Depth.cpp | 2 +- src/V3DepthBlock.cpp | 2 +- src/V3Descope.cpp | 2 +- src/V3EmitC.cpp | 12 +- src/V3EmitCBase.h | 4 +- src/V3EmitCMain.cpp | 2 +- src/V3EmitV.cpp | 42 +- src/V3EmitXml.cpp | 6 +- src/V3Expand.cpp | 2 +- src/V3File.h | 18 +- src/V3Gate.cpp | 52 +- src/V3GenClk.cpp | 4 +- src/V3GraphAcyc.cpp | 14 +- src/V3GraphDfa.h | 20 +- src/V3GraphTest.cpp | 32 +- src/V3Hashed.cpp | 2 +- src/V3Inline.cpp | 10 +- src/V3Inst.cpp | 6 +- src/V3InstrCount.cpp | 4 +- src/V3Life.cpp | 4 +- src/V3LifePost.cpp | 4 +- src/V3LinkCells.cpp | 18 +- src/V3LinkDot.cpp | 22 +- src/V3LinkInc.cpp | 2 +- src/V3LinkJump.cpp | 2 +- src/V3LinkLValue.cpp | 2 +- src/V3LinkParse.cpp | 2 +- src/V3LinkResolve.cpp | 4 +- src/V3Localize.cpp | 4 +- src/V3MergeCond.cpp | 2 +- src/V3Name.cpp | 2 +- src/V3Order.cpp | 6 +- src/V3OrderGraph.h | 167 +- src/V3Param.cpp | 2 +- src/V3Partition.cpp | 14 +- src/V3PartitionGraph.h | 14 +- src/V3Premit.cpp | 4 +- src/V3Reloop.cpp | 2 +- src/V3Scope.cpp | 4 +- src/V3Simulate.h | 2 +- src/V3Slice.cpp | 2 +- src/V3Split.cpp | 74 +- src/V3SplitAs.cpp | 6 +- src/V3Stats.cpp | 2 +- src/V3Subst.cpp | 4 +- src/V3TSP.cpp | 8 +- src/V3Table.cpp | 6 +- src/V3Task.cpp | 26 +- src/V3Trace.cpp | 32 +- src/V3TraceDecl.cpp | 2 +- src/V3Tristate.cpp | 12 +- src/V3Undriven.cpp | 2 +- src/V3Unknown.cpp | 2 +- src/V3Unroll.cpp | 2 +- src/V3Width.cpp | 2 +- src/V3WidthCommit.h | 4 +- src/V3WidthSel.cpp | 2 +- 83 files changed, 2905 insertions(+), 2798 deletions(-) diff --git a/include/verilated_fst_c.h b/include/verilated_fst_c.h index 6c222e0aa..a86dd3f4d 100644 --- a/include/verilated_fst_c.h +++ b/include/verilated_fst_c.h @@ -63,11 +63,11 @@ protected: // Implementation of VerilatedTrace interface // Implementations of protected virtual methods for VerilatedTrace - void emitTimeChange(vluint64_t timeui) override; + virtual void emitTimeChange(vluint64_t timeui) override; // Hooks called from VerilatedTrace - bool preFullDump() override { return isOpen(); } - bool preChangeDump() override { return isOpen(); } + virtual bool preFullDump() override { return isOpen(); } + virtual bool preChangeDump() override { return isOpen(); } // Implementations of duck-typed methods for VerilatedTrace. These are // called from only one place (namely full*) so always inline them. diff --git a/include/verilated_vcd_c.h b/include/verilated_vcd_c.h index d6dca4847..baa2bc8ee 100644 --- a/include/verilated_vcd_c.h +++ b/include/verilated_vcd_c.h @@ -113,11 +113,11 @@ protected: // Implementation of VerilatedTrace interface // Implementations of protected virtual methods for VerilatedTrace - void emitTimeChange(vluint64_t timeui) override; + virtual void emitTimeChange(vluint64_t timeui) override; // Hooks called from VerilatedTrace - bool preFullDump() override { return isOpen(); } - bool preChangeDump() override; + virtual bool preFullDump() override { return isOpen(); } + virtual bool preChangeDump() override; // Implementations of duck-typed methods for VerilatedTrace. These are // called from only one place (namely full*) so always inline them. diff --git a/include/verilated_vpi.cpp b/include/verilated_vpi.cpp index f657c351e..d34bed58c 100644 --- a/include/verilated_vpi.cpp +++ b/include/verilated_vpi.cpp @@ -114,11 +114,11 @@ public: m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal; m_cbData.value = &m_value; } - virtual ~VerilatedVpioCb() {} + virtual ~VerilatedVpioCb() override {} static inline VerilatedVpioCb* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiCallback; } + virtual vluint32_t type() const override { return vpiCallback; } vluint32_t reason() const { return m_cbData.reason; } VerilatedPliCb cb_rtnp() const { return m_cbData.cb_rtn; } t_cb_data* cb_datap() { return &(m_cbData); } @@ -131,11 +131,11 @@ class VerilatedVpioConst : public VerilatedVpio { public: explicit VerilatedVpioConst(vlsint32_t num) : m_num(num) {} - virtual ~VerilatedVpioConst() {} + virtual ~VerilatedVpioConst() override {} static inline VerilatedVpioConst* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiConstant; } + virtual vluint32_t type() const override { return vpiConstant; } vlsint32_t num() const { return m_num; } }; @@ -148,17 +148,17 @@ public: : m_varp(varp) , m_scopep(scopep) {} - virtual ~VerilatedVpioParam() {} + virtual ~VerilatedVpioParam() override {} static inline VerilatedVpioParam* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiParameter; } + virtual vluint32_t type() const override { return vpiParameter; } const VerilatedVar* varp() const { return m_varp; } void* varDatap() const { return m_varp->datap(); } const VerilatedScope* scopep() const { return m_scopep; } - virtual const char* name() const { return m_varp->name(); } - virtual const char* fullname() const { + virtual const char* name() const override { return m_varp->name(); } + virtual const char* fullname() const override { static VL_THREAD_LOCAL std::string out; out = std::string(m_scopep->name()) + "." + name(); return out.c_str(); @@ -173,16 +173,16 @@ public: explicit VerilatedVpioRange(const VerilatedRange* range) : m_range(range) , m_iteration(0) {} - virtual ~VerilatedVpioRange() {} + virtual ~VerilatedVpioRange() override {} static inline VerilatedVpioRange* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiRange; } - virtual vluint32_t size() const { return m_range->elements(); } - virtual const VerilatedRange* rangep() const { return m_range; } + virtual vluint32_t type() const override { return vpiRange; } + virtual vluint32_t size() const override { return m_range->elements(); } + virtual const VerilatedRange* rangep() const override { return m_range; } int iteration() const { return m_iteration; } void iterationInc() { ++m_iteration; } - virtual vpiHandle dovpi_scan() { + virtual vpiHandle dovpi_scan() override { if (!iteration()) { VerilatedVpioRange* nextp = new VerilatedVpioRange(*this); nextp->iterationInc(); @@ -199,14 +199,14 @@ protected: public: explicit VerilatedVpioScope(const VerilatedScope* scopep) : m_scopep(scopep) {} - virtual ~VerilatedVpioScope() {} + virtual ~VerilatedVpioScope() override {} static inline VerilatedVpioScope* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiScope; } + virtual vluint32_t type() const override { return vpiScope; } const VerilatedScope* scopep() const { return m_scopep; } - virtual const char* name() const { return m_scopep->name(); } - virtual const char* fullname() const { return m_scopep->name(); } + virtual const char* name() const override { return m_scopep->name(); } + virtual const char* fullname() const override { return m_scopep->name(); } }; class VerilatedVpioVar : public VerilatedVpio { @@ -236,7 +236,7 @@ public: m_entSize = varp->entSize(); m_varDatap = varp->datap(); } - virtual ~VerilatedVpioVar() { + virtual ~VerilatedVpioVar() override { if (m_prevDatap) VL_DO_CLEAR(delete[] m_prevDatap, m_prevDatap = nullptr); } static inline VerilatedVpioVar* castp(vpiHandle h) { @@ -248,13 +248,13 @@ public: vluint8_t mask_byte(int idx) { return m_mask.u8[idx & 3]; } vluint32_t entSize() const { return m_entSize; } vluint32_t index() { return m_index; } - virtual vluint32_t type() const { + virtual vluint32_t type() const override { return (varp()->dims() > 1) ? vpiMemory : vpiReg; // but might be wire, logic } - virtual vluint32_t size() const { return get_range().elements(); } - virtual const VerilatedRange* rangep() const { return &get_range(); } - virtual const char* name() const { return m_varp->name(); } - virtual const char* fullname() const { + virtual vluint32_t size() const override { return get_range().elements(); } + virtual const VerilatedRange* rangep() const override { return &get_range(); } + virtual const char* name() const override { return m_varp->name(); } + virtual const char* fullname() const override { static VL_THREAD_LOCAL std::string out; out = std::string(m_scopep->name()) + "." + name(); return out.c_str(); @@ -277,14 +277,14 @@ public: m_index = index; m_varDatap = (static_cast(varp->datap())) + entSize() * offset; } - virtual ~VerilatedVpioMemoryWord() {} + virtual ~VerilatedVpioMemoryWord() override {} static inline VerilatedVpioMemoryWord* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiMemoryWord; } - virtual vluint32_t size() const { return varp()->packed().elements(); } - virtual const VerilatedRange* rangep() const { return &(varp()->packed()); } - virtual const char* fullname() const { + virtual vluint32_t type() const override { return vpiMemoryWord; } + virtual vluint32_t size() const override { return varp()->packed().elements(); } + virtual const VerilatedRange* rangep() const override { return &(varp()->packed()); } + virtual const char* fullname() const override { static VL_THREAD_LOCAL std::string out; char num[20]; sprintf(num, "%d", m_index); @@ -302,12 +302,12 @@ public: explicit VerilatedVpioVarIter(const VerilatedScope* scopep) : m_scopep(scopep) , m_started(false) {} - virtual ~VerilatedVpioVarIter() {} + virtual ~VerilatedVpioVarIter() override {} static inline VerilatedVpioVarIter* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiIterator; } - virtual vpiHandle dovpi_scan() { + virtual vluint32_t type() const override { return vpiIterator; } + virtual vpiHandle dovpi_scan() override { if (VL_LIKELY(m_scopep->varsp())) { VerilatedVarNameMap* varsp = m_scopep->varsp(); if (VL_UNLIKELY(!m_started)) { @@ -339,15 +339,15 @@ public: , m_iteration(varp->unpacked().right()) , m_direction(VL_LIKELY(varp->unpacked().left() > varp->unpacked().right()) ? 1 : -1) , m_done(false) {} - virtual ~VerilatedVpioMemoryWordIter() {} + virtual ~VerilatedVpioMemoryWordIter() override {} static inline VerilatedVpioMemoryWordIter* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiIterator; } + virtual vluint32_t type() const override { return vpiIterator; } void iterationInc() { if (!(m_done = (m_iteration == m_varp->unpacked().left()))) m_iteration += m_direction; } - virtual vpiHandle dovpi_scan() { + virtual vpiHandle dovpi_scan() override { vpiHandle result; if (m_done) return 0; result = vpi_handle_by_index(m_handle, m_iteration); @@ -370,9 +370,9 @@ public: static inline VerilatedVpioModule* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiModule; } - virtual const char* name() const { return m_name; } - virtual const char* fullname() const { return m_fullname; } + virtual vluint32_t type() const override { return vpiModule; } + virtual const char* name() const override { return m_name; } + virtual const char* fullname() const override { return m_fullname; } }; class VerilatedVpioModuleIter : public VerilatedVpio { @@ -384,12 +384,12 @@ public: : m_vec(&vec) { m_it = m_vec->begin(); } - virtual ~VerilatedVpioModuleIter() {} + virtual ~VerilatedVpioModuleIter() override {} static inline VerilatedVpioModuleIter* castp(vpiHandle h) { return dynamic_cast(reinterpret_cast(h)); } - virtual vluint32_t type() const { return vpiIterator; } - virtual vpiHandle dovpi_scan() { + virtual vluint32_t type() const override { return vpiIterator; } + virtual vpiHandle dovpi_scan() override { if (m_it == m_vec->end()) return 0; const VerilatedScope* modp = *m_it++; return (new VerilatedVpioModule(modp))->castVpiHandle(); diff --git a/src/V3Active.cpp b/src/V3Active.cpp index 71dfc1d5a..384c83ff6 100644 --- a/src/V3Active.cpp +++ b/src/V3Active.cpp @@ -136,7 +136,7 @@ public: m_iActivep = nullptr; m_cActivep = nullptr; } - virtual ~ActiveNamer() {} + virtual ~ActiveNamer() override {} void main(AstScope* nodep) { iterate(nodep); } }; @@ -211,7 +211,7 @@ public: m_assignp = nullptr; iterate(nodep); } - virtual ~ActiveDlyVisitor() {} + virtual ~ActiveDlyVisitor() override {} }; //###################################################################### @@ -417,7 +417,7 @@ public: , m_itemSequent(false) { iterate(nodep); } - virtual ~ActiveVisitor() {} + virtual ~ActiveVisitor() override {} }; //###################################################################### diff --git a/src/V3ActiveTop.cpp b/src/V3ActiveTop.cpp index 3e2a4224c..c5a0d3b53 100644 --- a/src/V3ActiveTop.cpp +++ b/src/V3ActiveTop.cpp @@ -131,7 +131,7 @@ public: : m_topscopep(nullptr) { iterate(nodep); } - virtual ~ActiveTopVisitor() {} + virtual ~ActiveTopVisitor() override {} }; //###################################################################### diff --git a/src/V3Assert.cpp b/src/V3Assert.cpp index 78950f699..7ad9ea18d 100644 --- a/src/V3Assert.cpp +++ b/src/V3Assert.cpp @@ -392,7 +392,7 @@ public: // Process iterate(nodep); } - virtual ~AssertVisitor() { + virtual ~AssertVisitor() override { V3Stats::addStat("Assertions, assert non-immediate statements", m_statAsNotImm); V3Stats::addStat("Assertions, assert immediate statements", m_statAsImm); V3Stats::addStat("Assertions, cover statements", m_statCover); diff --git a/src/V3AssertPre.cpp b/src/V3AssertPre.cpp index d082d6385..83f60c49b 100644 --- a/src/V3AssertPre.cpp +++ b/src/V3AssertPre.cpp @@ -176,7 +176,7 @@ public: // Process iterate(nodep); } - virtual ~AssertPreVisitor() {} + virtual ~AssertPreVisitor() override {} }; //###################################################################### diff --git a/src/V3Ast.h b/src/V3Ast.h index 160d5e85e..b693ab752 100644 --- a/src/V3Ast.h +++ b/src/V3Ast.h @@ -1888,7 +1888,7 @@ public: : AstNode(t, fl) {} ASTNODE_BASE_FUNCS(NodeMath) // METHODS - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } virtual string emitVerilog() = 0; /// Format string for verilog writing; see V3EmitV // For documentation on emitC format see EmitCStmts::emitOpName virtual string emitC() = 0; @@ -1932,9 +1932,9 @@ public: // Signed flavor of nodes with both flavors? virtual bool signedFlavor() const { return false; } virtual bool stringFlavor() const { return false; } // N flavor of nodes with both flavors? - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } }; class AstNodeBiop : public AstNodeMath { @@ -1964,9 +1964,9 @@ public: // Signed flavor of nodes with both flavors? virtual bool signedFlavor() const { return false; } virtual bool stringFlavor() const { return false; } // N flavor of nodes with both flavors? - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } }; class AstNodeTriop : public AstNodeMath { @@ -1996,9 +1996,9 @@ public: virtual bool sizeMattersLhs() const = 0; // True if output result depends on lhs size virtual bool sizeMattersRhs() const = 0; // True if output result depends on rhs size virtual bool sizeMattersThs() const = 0; // True if output result depends on ths size - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } }; class AstNodeQuadop : public AstNodeMath { @@ -2033,9 +2033,9 @@ public: virtual bool sizeMattersRhs() const = 0; // True if output result depends on rhs size virtual bool sizeMattersThs() const = 0; // True if output result depends on ths size virtual bool sizeMattersFhs() const = 0; // True if output result depends on ths size - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } }; class AstNodeBiCom : public AstNodeBiop { @@ -2065,20 +2065,22 @@ public: } ASTNODE_BASE_FUNCS(NodeCond) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths); + const V3Number& ths) override; AstNode* condp() const { return op1p(); } // op1 = Condition AstNode* expr1p() const { return op2p(); } // op2 = If true... AstNode* expr2p() const { return op3p(); } // op3 = If false... - virtual string emitVerilog() { return "%k(%l %f? %r %k: %t)"; } - virtual string emitC() { return "VL_COND_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri, %ti)"; } - virtual bool cleanOut() const { return false; } // clean if e1 & e2 clean - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return false; } - virtual bool cleanThs() const { return false; } // Propagates up - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual int instrCount() const { return instrCountBranch(); } + virtual string emitVerilog() override { return "%k(%l %f? %r %k: %t)"; } + virtual string emitC() override { + return "VL_COND_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri, %ti)"; + } + virtual bool cleanOut() const override { return false; } // clean if e1 & e2 clean + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return false; } + virtual bool cleanThs() const override { return false; } // Propagates up + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual int instrCount() const override { return instrCountBranch(); } virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) = 0; }; @@ -2097,9 +2099,9 @@ public: m_unnamed = (name == ""); } ASTNODE_BASE_FUNCS(NodeBlock) - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } // * = Block name - virtual void name(const string& name) { m_name = name; } + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } // * = Block name + virtual void name(const string& name) override { m_name = name; } // op1 = Statements AstNode* stmtsp() const { return op1p(); } // op1 = List of statements void addStmtsp(AstNode* nodep) { addNOp1p(nodep); } @@ -2126,8 +2128,8 @@ public: void thsp(AstNode* nodep) { return setOp3p(nodep); } void attrp(AstAttrOf* nodep) { return setOp4p((AstNode*)nodep); } // METHODS - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } }; class AstNodeProcedure : public AstNode { @@ -2175,12 +2177,12 @@ public: AstNode* lhsp() const { return op2p(); } // op2 = Assign to void rhsp(AstNode* np) { setOp1p(np); } void lhsp(AstNode* np) { setOp2p(np); } - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } virtual bool cleanRhs() const { return true; } - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } - virtual string verilogKwd() const { return "="; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } + virtual string verilogKwd() const override { return "="; } virtual bool brokeLhsMustBeLvalue() const = 0; }; @@ -2199,10 +2201,10 @@ public: AstNode* condp() const { return op2p(); } // op2 = condition to continue AstNode* incsp() const { return op3p(); } // op3 = increment statements AstNode* bodysp() const { return op4p(); } // op4 = body of loop - virtual bool isGateOptimizable() const { return false; } - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstNodeIf : public AstNodeStmt { @@ -2222,11 +2224,11 @@ public: void condp(AstNode* newp) { setOp1p(newp); } void addIfsp(AstNode* newp) { addOp2p(newp); } void addElsesp(AstNode* newp) { addOp3p(newp); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isGateDedupable() const { return true; } - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isGateDedupable() const override { return true; } + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } void branchPred(VBranchPred flag) { m_branchPred = flag; } VBranchPred branchPred() const { return m_branchPred; } }; @@ -2239,7 +2241,7 @@ public: addNOp2p(casesp); } ASTNODE_BASE_FUNCS(NodeCase) - virtual int instrCount() const { return instrCountBranch(); } + virtual int instrCount() const override { return instrCountBranch(); } AstNode* exprp() const { return op1p(); } // op1 = case condition AstCaseItem* itemsp() const { return VN_CAST(op2p(), CaseItem); @@ -2281,12 +2283,12 @@ public: this->varp(varp); } ASTNODE_BASE_FUNCS(NodeVarRef) - virtual bool hasDType() const { return true; } - virtual const char* broken() const; - virtual int instrCount() const { return widthInstrs(); } - virtual void cloneRelink(); - virtual string name() const { return m_name; } // * = Var name - virtual void name(const string& name) { m_name = name; } + virtual bool hasDType() const override { return true; } + virtual const char* broken() const override; + virtual int instrCount() const override { return widthInstrs(); } + virtual void cloneRelink() override; + virtual string name() const override { return m_name; } // * = Var name + virtual void name(const string& name) override { m_name = name; } bool lvalue() const { return m_lvalue; } void lvalue(bool lval) { m_lvalue = lval; } // Avoid using this; Set in constructor AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable @@ -2317,9 +2319,9 @@ public: m_text = textp; // Copy it } ASTNODE_BASE_FUNCS(NodeText) - virtual void dump(std::ostream& str = std::cout) const; - virtual V3Hash sameHash() const { return V3Hash(text()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str = std::cout) const override; + virtual V3Hash sameHash() const override { return V3Hash(text()); } + virtual bool same(const AstNode* samep) const override { const AstNodeText* asamep = static_cast(samep); return text() == asamep->text(); } @@ -2349,9 +2351,9 @@ public: } ASTNODE_BASE_FUNCS(NodeDType) // ACCESSORS - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; virtual void dumpSmall(std::ostream& str) const; - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } virtual AstBasicDType* basicp() const = 0; // (Slow) recurse down to find basic data type // recurses over typedefs/const/enum to next non-typeref type virtual AstNodeDType* skipRefp() const = 0; @@ -2363,7 +2365,7 @@ public: virtual int widthAlignBytes() const = 0; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,... virtual int widthTotalBytes() const = 0; - virtual bool maybePointedTo() const { return true; } + virtual bool maybePointedTo() const override { return true; } // Iff has a non-null refDTypep(), as generic node function virtual AstNodeDType* virtRefDTypep() const { return nullptr; } // Iff has refDTypep(), set as generic node function @@ -2437,10 +2439,10 @@ public: numeric(VSigning::fromBool(numericUnpack.isSigned())); } ASTNODE_BASE_FUNCS(NodeUOrStructDType) - virtual const char* broken() const; - virtual void dump(std::ostream& str) const; + virtual const char* broken() const override; + virtual void dump(std::ostream& str) const override; // For basicp() we reuse the size to indicate a "fake" basic type of same size - virtual AstBasicDType* basicp() const { + virtual AstBasicDType* basicp() const override { return (isFourstate() ? VN_CAST( findLogicRangeDType(VNumRange(width() - 1, 0, false), width(), numeric()), BasicDType) @@ -2448,19 +2450,19 @@ public: width(), numeric()), BasicDType)); } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() - const; // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this) - virtual int - widthTotalBytes() const; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,... + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this) + virtual int widthAlignBytes() const override; + // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,... + virtual int widthTotalBytes() const override; // op1 = members - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; // We don't compare members, require exact equivalence } - virtual string name() const { return m_name; } - void name(const string& flag) { m_name = flag; } + virtual string name() const override { return m_name; } + virtual void name(const string& flag) override { m_name = flag; } AstMemberDType* membersp() const { return VN_CAST(op1p(), MemberDType); } // op1 = AstMember list @@ -2469,7 +2471,7 @@ public: // packed() but as don't support unpacked, presently all structs static bool packedUnsup() { return true; } void isFourstate(bool flag) { m_isFourstate = flag; } - virtual bool isFourstate() const { return m_isFourstate; } + virtual bool isFourstate() const override { return m_isFourstate; } void clearCache() { m_members.clear(); } void repairMemberCache(); AstMemberDType* findMember(const string& name) const { @@ -2494,48 +2496,50 @@ public: m_refDTypep = nullptr; } ASTNODE_BASE_FUNCS(NodeArrayDType) - virtual void dump(std::ostream& str) const; - virtual void dumpSmall(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual void dumpSmall(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstNodeArrayDType* asamep = static_cast(samep); return (msb() == asamep->msb() && subDTypep() == asamep->subDTypep() && rangenp()->sameTree(asamep->rangenp())); } // HashedDT doesn't recurse, so need to check children - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { const AstNodeArrayDType* asamep = static_cast(samep); return (asamep && type() == samep->type() && msb() == asamep->msb() && rangenp()->sameTree(asamep->rangenp()) && subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); } - virtual V3Hash sameHash() const { + virtual V3Hash sameHash() const override { return V3Hash(V3Hash(m_refDTypep), V3Hash(msb()), V3Hash(lsb())); } - virtual AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } AstRange* rangep() const { return VN_CAST(op2p(), Range); } // op2 = Array(s) of variable void rangep(AstRange* nodep); // METHODS - virtual AstBasicDType* basicp() const { + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } // (Slow) recurse down to find basic data type - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return elementsConst() * subDTypep()->widthTotalBytes(); } int msb() const; @@ -2557,7 +2561,7 @@ public: AstNode* bitp() const { return op2p(); } // op2 = Msb selection expression void bitp(AstNode* nodep) { setOp2p(nodep); } int bitConst() const; - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } }; class AstNodeStream : public AstNodeBiop { @@ -2597,20 +2601,20 @@ public: if (oldp->argsp()) addNOp2p(oldp->argsp()->unlinkFrBackWithNext()); } ASTNODE_BASE_FUNCS(NodeCCall) - virtual void dump(std::ostream& str = std::cout) const; - virtual void cloneRelink(); - virtual const char* broken() const; - virtual int instrCount() const { return instrCountCall(); } - virtual V3Hash sameHash() const { return V3Hash(funcp()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str = std::cout) const override; + virtual void cloneRelink() override; + virtual const char* broken() const override; + virtual int instrCount() const override { return instrCountCall(); } + virtual V3Hash sameHash() const override { return V3Hash(funcp()); } + virtual bool same(const AstNode* samep) const override { const AstNodeCCall* asamep = static_cast(samep); return (funcp() == asamep->funcp() && argTypes() == asamep->argTypes()); } AstNode* exprsp() const { return op2p(); } // op2 = expressions to print - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const; - virtual bool isOutputter() const { return !isPure(); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override; + virtual bool isOutputter() const override { return !isPure(); } AstCFunc* funcp() const { return m_funcp; } string hiername() const { return m_hiername; } void hiername(const string& hn) { m_hiername = hn; } @@ -2665,12 +2669,14 @@ public: cname(name); // Might be overridden by dpi import/export } ASTNODE_BASE_FUNCS(NodeFTask) - virtual void dump(std::ostream& str = std::cout) const; - virtual string name() const { return m_name; } // * = Var name - virtual bool maybePointedTo() const { return true; } - virtual bool isGateOptimizable() const { return !((m_dpiExport || m_dpiImport) && !m_pure); } + virtual void dump(std::ostream& str = std::cout) const override; + virtual string name() const override { return m_name; } // * = Var name + virtual bool maybePointedTo() const override { return true; } + virtual bool isGateOptimizable() const override { + return !((m_dpiExport || m_dpiImport) && !m_pure); + } // {AstFunc only} op1 = Range output variable - virtual void name(const string& name) { m_name = name; } + virtual void name(const string& name) override { m_name = name; } string cname() const { return m_cname; } void cname(const string& cname) { m_cname = cname; } // op1 = Output variable (functions only, nullptr for tasks) @@ -2747,23 +2753,25 @@ public: addNOp3p(pinsp); } ASTNODE_BASE_FUNCS(NodeFTaskRef) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_taskp && !m_taskp->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_taskp && m_taskp->clonep()) { m_taskp = m_taskp->clonep(); } } - virtual void dump(std::ostream& str = std::cout) const; - virtual string name() const { return m_name; } // * = Var name - virtual bool isGateOptimizable() const { return m_taskp && m_taskp->isGateOptimizable(); } + virtual void dump(std::ostream& str = std::cout) const override; + virtual string name() const override { return m_name; } // * = Var name + virtual bool isGateOptimizable() const override { + return m_taskp && m_taskp->isGateOptimizable(); + } string dotted() const { return m_dotted; } // * = Scope name or "" string prettyDotted() const { return prettyName(dotted()); } string inlinedDots() const { return m_inlinedDots; } void inlinedDots(const string& flag) { m_inlinedDots = flag; } AstNodeFTask* taskp() const { return m_taskp; } // [After Link] Pointer to variable void taskp(AstNodeFTask* taskp) { m_taskp = taskp; } - virtual void name(const string& name) { m_name = name; } + virtual void name(const string& name) override { m_name = name; } void dotted(const string& name) { m_dotted = name; } AstNodeModule* packagep() const { return m_packagep; } void packagep(AstNodeModule* nodep) { m_packagep = nodep; } @@ -2819,9 +2827,9 @@ public: , m_varNum(0) , m_typeNum(0) {} ASTNODE_BASE_FUNCS(NodeModule) - virtual void dump(std::ostream& str) const; - virtual bool maybePointedTo() const { return true; } - virtual string name() const { return m_name; } + virtual void dump(std::ostream& str) const override; + virtual bool maybePointedTo() const override { return true; } + virtual string name() const override { return m_name; } AstNode* stmtsp() const { return op2p(); } // op2 = List of statements AstActive* activesp() const { return VN_CAST(op3p(), Active); } // op3 = List of i/sblocks // METHODS @@ -2829,8 +2837,8 @@ public: void addStmtp(AstNode* nodep) { addNOp2p(nodep); } void addActivep(AstNode* nodep) { addOp3p(nodep); } // ACCESSORS - virtual void name(const string& name) { m_name = name; } - virtual string origName() const { return m_origName; } + virtual void name(const string& name) override { m_name = name; } + virtual string origName() const override { return m_origName; } string hierName() const { return m_hierName; } void hierName(const string& hierName) { m_hierName = hierName; } bool inLibrary() const { return m_inLibrary; } diff --git a/src/V3AstNodes.h b/src/V3AstNodes.h index 6d96f2783..5d5fadf01 100644 --- a/src/V3AstNodes.h +++ b/src/V3AstNodes.h @@ -25,8 +25,8 @@ // Standard defines for all AstNode final classes #define ASTNODE_NODE_FUNCS_NO_DTOR(name) \ - virtual void accept(AstNVisitor& v) { v.visit(this); } \ - virtual AstNode* clone() { return new Ast##name(*this); } \ + virtual void accept(AstNVisitor& v) override { v.visit(this); } \ + virtual AstNode* clone() override { return new Ast##name(*this); } \ static Ast##name* cloneTreeNull(Ast##name* nodep, bool cloneNextLink) { \ return nodep ? nodep->cloneTree(cloneNextLink) : nullptr; \ } \ @@ -36,7 +36,7 @@ Ast##name* clonep() const { return static_cast(AstNode::clonep()); } #define ASTNODE_NODE_FUNCS(name) \ - virtual ~Ast##name() {} \ + virtual ~Ast##name() override {} \ ASTNODE_NODE_FUNCS_NO_DTOR(name) //###################################################################### @@ -153,21 +153,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Const) - virtual string name() const { return num().ascii(); } // * = Value + virtual string name() const override { return num().ascii(); } // * = Value const V3Number& num() const { return m_num; } // * = Value V3Number& num() { return m_num; } // * = Value uint32_t toUInt() const { return num().toUInt(); } vlsint32_t toSInt() const { return num().toSInt(); } vluint64_t toUQuad() const { return num().toUQuad(); } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(num().toHash()); } - virtual bool same(const AstNode* samep) const { + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(num().toHash()); } + virtual bool same(const AstNode* samep) const override { const AstConst* sp = static_cast(samep); return num().isCaseEq(sp->num()); } - virtual int instrCount() const { return widthInstrs(); } + virtual int instrCount() const override { return widthInstrs(); } bool isEqAllOnes() const { return num().isEqAllOnes(width()); } bool isEqAllOnesV() const { return num().isEqAllOnes(widthMinV()); } // Parse string and create appropriate type of AstConst. @@ -228,10 +228,10 @@ public: int leftToRightInc() const { return littleEndian() ? 1 : -1; } bool littleEndian() const { return m_littleEndian; } void littleEndian(bool flag) { m_littleEndian = flag; } - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstBracketRange : public AstNodeRange { @@ -245,11 +245,11 @@ public: ASTNODE_NODE_FUNCS(BracketRange) virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // Will be removed in V3Width, which relies on this // being a child not a dtype pointed node - virtual bool maybePointedTo() const { return false; } + virtual bool maybePointedTo() const override { return false; } AstNode* elementsp() const { return op1p(); } }; @@ -261,8 +261,8 @@ public: ASTNODE_NODE_FUNCS(UnsizedRange) virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual string emitVerilog() { return "[]"; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstGatePin : public AstNodeMath { @@ -274,9 +274,9 @@ public: setOp2p(rangep); } ASTNODE_NODE_FUNCS(GatePin) - virtual string emitVerilog() { return "%l"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual string emitVerilog() override { return "%l"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } AstNode* exprp() const { return op1p(); } // op1 = Pin expression AstRange* rangep() const { return VN_CAST(op2p(), Range); } // op2 = Range of pin }; @@ -292,8 +292,8 @@ public: : ASTGEN_SUPER(fl, name) , m_classp(nullptr) {} ASTNODE_NODE_FUNCS(ClassPackage) - virtual string verilogKwd() const { return "/*class*/package"; } - virtual const char* broken() const; + virtual string verilogKwd() const override { return "/*class*/package"; } + virtual const char* broken() const override; AstClass* classp() const { return m_classp; } void classp(AstClass* classp) { m_classp = classp; } }; @@ -312,11 +312,11 @@ public: : ASTGEN_SUPER(fl, name) , m_packagep(nullptr) {} ASTNODE_NODE_FUNCS(Class) - virtual string verilogKwd() const { return "class"; } - virtual bool isHeavy() const { return true; } - virtual bool maybePointedTo() const { return true; } - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual string verilogKwd() const override { return "class"; } + virtual bool isHeavy() const override { return true; } + virtual bool maybePointedTo() const override { return true; } + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_BASE_RTN(AstNodeModule::broken()); BROKEN_RTN(m_packagep && !m_packagep->brokeExists()); return nullptr; @@ -350,8 +350,8 @@ public: setNOp1p(classOrPkgsp); // Only for parser } ASTNODE_NODE_FUNCS(ClassExtends) - virtual string verilogKwd() const { return "extends"; } - virtual bool hasDType() const { return true; } + virtual string verilogKwd() const override { return "extends"; } + virtual bool hasDType() const override { return true; } AstNodeDType* classOrPkgsp() const { return VN_CAST(op1p(), NodeDType); } void classOrPkgsp(AstNodeDType* nodep) { setOp1p(nodep); } AstClass* classp() const; // Class being extended (after link) @@ -376,26 +376,30 @@ public: dtypep(nullptr); // V3Width will resolve } ASTNODE_NODE_FUNCS(ParamTypeDType) - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Type assigning to AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } - virtual AstNodeDType* skipRefp() const { return subDTypep()->skipRefp(); } - virtual AstNodeDType* skipRefToConstp() const { return subDTypep()->skipRefToConstp(); } - virtual AstNodeDType* skipRefToEnump() const { return subDTypep()->skipRefToEnump(); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual AstNodeDType* subDTypep() const override { + return dtypep() ? dtypep() : childDTypep(); + } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } + virtual AstNodeDType* skipRefp() const override { return subDTypep()->skipRefp(); } + virtual AstNodeDType* skipRefToConstp() const override { + return subDTypep()->skipRefToConstp(); + } + virtual AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } + virtual bool similarDType(AstNodeDType* samep) const override { const AstParamTypeDType* sp = static_cast(samep); return (sp && this->subDTypep()->skipRefp()->similarDType(sp->subDTypep()->skipRefp())); } - virtual int widthAlignBytes() const { return dtypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return dtypep()->widthTotalBytes(); } + virtual int widthAlignBytes() const override { return dtypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return dtypep()->widthTotalBytes(); } // METHODS - virtual string name() const { return m_name; } - virtual bool maybePointedTo() const { return true; } - virtual bool hasDType() const { return true; } - void name(const string& flag) { m_name = flag; } + virtual string name() const override { return m_name; } + virtual bool maybePointedTo() const override { return true; } + virtual bool hasDType() const override { return true; } + virtual void name(const string& flag) override { m_name = flag; } AstVarType varType() const { return m_varType; } // * = Type of variable bool isParam() const { return true; } bool isGParam() const { return (varType() == AstVarType::GPARAM); } @@ -417,8 +421,8 @@ public: m_attrPublic = false; } ASTNODE_NODE_FUNCS(Typedef) - virtual void dump(std::ostream& str) const; - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual void dump(std::ostream& str) const override; + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Type assigning to AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } @@ -426,14 +430,14 @@ public: void addAttrsp(AstNode* nodep) { addNOp4p(nodep); } AstNode* attrsp() const { return op4p(); } // op4 = Attributes during early parse // METHODS - virtual string name() const { return m_name; } - virtual bool maybePointedTo() const { return true; } - virtual bool hasDType() const { return true; } - void name(const string& flag) { m_name = flag; } + virtual string name() const override { return m_name; } + virtual bool maybePointedTo() const override { return true; } + virtual bool hasDType() const override { return true; } + virtual void name(const string& flag) override { m_name = flag; } bool attrPublic() const { return m_attrPublic; } void attrPublic(bool flag) { m_attrPublic = flag; } - virtual void tag(const string& text) { m_tag = text; } - virtual string tag() const { return m_tag; } + virtual void tag(const string& text) override { m_tag = text; } + virtual string tag() const override { return m_tag; } }; class AstTypedefFwd : public AstNode { @@ -447,8 +451,8 @@ public: , m_name(name) {} ASTNODE_NODE_FUNCS(TypedefFwd) // METHODS - virtual string name() const { return m_name; } - virtual bool maybePointedTo() const { return true; } + virtual string name() const override { return m_name; } + virtual bool maybePointedTo() const override { return true; } }; class AstDefImplicitDType : public AstNodeDType { @@ -472,31 +476,33 @@ public: m_uniqueNum = uniqueNumInc(); } ASTNODE_NODE_FUNCS(DefImplicitDType) - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstDefImplicitDType* sp = static_cast(samep); return m_uniqueNum == sp->m_uniqueNum; } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { return type() == samep->type() && same(samep); } - virtual V3Hash sameHash() const { return V3Hash(m_uniqueNum); } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual V3Hash sameHash() const override { return V3Hash(m_uniqueNum); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return dtypep() ? dtypep() : childDTypep(); + } void* containerp() const { return m_containerp; } // METHODS // op1 = Range of variable AstNodeDType* dtypeSkipRefp() const { return dtypep()->skipRefp(); } - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return dtypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return dtypep()->widthTotalBytes(); } - virtual string name() const { return m_name; } - void name(const string& flag) { m_name = flag; } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return dtypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return dtypep()->widthTotalBytes(); } + virtual string name() const override { return m_name; } + virtual void name(const string& flag) override { m_name = flag; } }; class AstAssocArrayDType : public AstNodeDType { @@ -516,40 +522,42 @@ public: dtypep(nullptr); // V3Width will resolve } ASTNODE_NODE_FUNCS(AssocArrayDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); BROKEN_RTN(!((m_keyDTypep && !childDTypep() && m_keyDTypep->brokeExists()) || (!m_keyDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } if (m_keyDTypep && m_keyDTypep->clonep()) { m_keyDTypep = m_keyDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstAssocArrayDType* asamep = static_cast(samep); return (subDTypep() == asamep->subDTypep() && keyDTypep() == asamep->keyDTypep()); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { const AstAssocArrayDType* asamep = static_cast(samep); return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); } - virtual string prettyDTypeName() const; - virtual void dumpSmall(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); } - virtual AstNodeDType* getChildDTypep() const { return childDTypep(); } - virtual AstNodeDType* getChild2DTypep() const { return keyChildDTypep(); } - virtual bool isHeavy() const { return true; } + virtual string prettyDTypeName() const override; + virtual void dumpSmall(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(m_refDTypep); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } + virtual AstNodeDType* getChild2DTypep() const override { return keyChildDTypep(); } + virtual bool isHeavy() const override { return true; } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } - virtual AstNodeDType* virtRefDType2p() const { return m_keyDTypep; } - virtual void virtRefDType2p(AstNodeDType* nodep) { keyDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } + virtual AstNodeDType* virtRefDType2p() const override { return m_keyDTypep; } + virtual void virtRefDType2p(AstNodeDType* nodep) override { keyDTypep(nodep); } // AstNodeDType* keyDTypep() const { return m_keyDTypep ? m_keyDTypep : keyChildDTypep(); } void keyDTypep(AstNodeDType* nodep) { m_keyDTypep = nodep; } @@ -557,12 +565,12 @@ public: AstNodeDType* keyChildDTypep() const { return VN_CAST(op2p(), NodeDType); } void keyChildDTypep(AstNodeDType* nodep) { setOp2p(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstBracketArrayDType : public AstNodeDType { @@ -577,22 +585,22 @@ public: setOp2p(elementsp); // Only for parser } ASTNODE_NODE_FUNCS(BracketArrayDType) - virtual bool similarDType(AstNodeDType* samep) const { V3ERROR_NA_RETURN(false); } + virtual bool similarDType(AstNodeDType* samep) const override { V3ERROR_NA_RETURN(false); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } - virtual AstNodeDType* subDTypep() const { return childDTypep(); } + virtual AstNodeDType* subDTypep() const override { return childDTypep(); } // op2 = Range of variable AstNode* elementsp() const { return op2p(); } // METHODS // Will be removed in V3Width, which relies on this // being a child not a dtype pointed node - virtual bool maybePointedTo() const { return false; } - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { V3ERROR_NA_RETURN(0); } - virtual int widthTotalBytes() const { V3ERROR_NA_RETURN(0); } + virtual bool maybePointedTo() const override { return false; } + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { V3ERROR_NA_RETURN(0); } + virtual int widthTotalBytes() const override { V3ERROR_NA_RETURN(0); } }; class AstDynArrayDType : public AstNodeDType { @@ -613,41 +621,43 @@ public: dtypep(nullptr); // V3Width will resolve } ASTNODE_NODE_FUNCS(DynArrayDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstAssocArrayDType* asamep = static_cast(samep); return subDTypep() == asamep->subDTypep(); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { const AstAssocArrayDType* asamep = static_cast(samep); return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); } - virtual string prettyDTypeName() const; - virtual void dumpSmall(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); } - virtual bool isHeavy() const { return true; } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual string prettyDTypeName() const override; + virtual void dumpSmall(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(m_refDTypep); } + virtual bool isHeavy() const override { return true; } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstPackArrayDType : public AstNodeArrayDType { @@ -673,7 +683,7 @@ public: widthForce(width, width); } ASTNODE_NODE_FUNCS(PackArrayDType) - virtual string prettyDTypeName() const; + virtual string prettyDTypeName() const override; }; class AstUnpackArrayDType : public AstNodeArrayDType { @@ -701,7 +711,7 @@ public: widthFromSub(subDTypep()); } ASTNODE_NODE_FUNCS(UnpackArrayDType) - virtual string prettyDTypeName() const; + virtual string prettyDTypeName() const override; }; class AstUnsizedArrayDType : public AstNodeDType { @@ -717,39 +727,41 @@ public: dtypep(nullptr); // V3Width will resolve } ASTNODE_NODE_FUNCS(UnsizedArrayDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstNodeArrayDType* asamep = static_cast(samep); return (subDTypep() == asamep->subDTypep()); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { const AstNodeArrayDType* asamep = static_cast(samep); return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); } - virtual void dumpSmall(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual void dumpSmall(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(m_refDTypep); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstBasicDType : public AstNodeDType { @@ -828,24 +840,25 @@ private: public: ASTNODE_NODE_FUNCS(BasicDType) - virtual void dump(std::ostream& str) const; - virtual V3Hash sameHash() const { + virtual void dump(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(V3Hash(m.m_keyword), V3Hash(m.m_nrange.hi())); } - virtual bool same(const AstNode* samep) const { // width/widthMin/numeric compared elsewhere + // width/widthMin/numeric compared elsewhere + virtual bool same(const AstNode* samep) const override { const AstBasicDType* sp = static_cast(samep); return m == sp->m; } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { return type() == samep->type() && same(samep); } - virtual string name() const { return m.m_keyword.ascii(); } - virtual string prettyDTypeName() const; - virtual const char* broken() const { + virtual string name() const override { return m.m_keyword.ascii(); } + virtual string prettyDTypeName() const override; + virtual const char* broken() const override { BROKEN_RTN(dtypep() != this); return nullptr; } - virtual bool isHeavy() const { return keyword() == AstBasicDTypeKwd::STRING; } + virtual bool isHeavy() const override { return keyword() == AstBasicDTypeKwd::STRING; } AstRange* rangep() const { return VN_CAST(op1p(), Range); } // op1 = Range of variable void rangep(AstRange* nodep) { setNOp1p(nodep); } void setSignedState(const VSigning& signst) { @@ -857,15 +870,15 @@ public: } } // METHODS - virtual AstBasicDType* basicp() const { return (AstBasicDType*)this; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } + virtual AstBasicDType* basicp() const override { return (AstBasicDType*)this; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this) - virtual int widthAlignBytes() const; + virtual int widthAlignBytes() const override; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,... - virtual int widthTotalBytes() const; - virtual bool isFourstate() const { return keyword().isFourstate(); } + virtual int widthTotalBytes() const override; + virtual bool isFourstate() const override { return keyword().isFourstate(); } AstBasicDTypeKwd keyword() const { // Avoid using - use isSomething accessors instead return m.m_keyword; } @@ -923,39 +936,41 @@ public: widthFromSub(subDTypep()); } ASTNODE_NODE_FUNCS(ConstDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstConstDType* sp = static_cast(samep); return (m_refDTypep == sp->m_refDTypep); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { return skipRefp()->similarDType(samep->skipRefp()); } - virtual V3Hash sameHash() const { + virtual V3Hash sameHash() const override { return V3Hash(m_refDTypep); } // node's type() included elsewhere - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } - virtual AstNodeDType* skipRefp() const { return subDTypep()->skipRefp(); } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return subDTypep()->skipRefToEnump(); } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } + virtual AstNodeDType* skipRefp() const override { return subDTypep()->skipRefp(); } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstClassRefDType : public AstNodeDType { @@ -972,31 +987,35 @@ public: } ASTNODE_NODE_FUNCS(ClassRefDType) // METHODS - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_classp && !m_classp->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_classp && m_classp->clonep()) m_classp = m_classp->clonep(); } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstClassRefDType* asamep = static_cast(samep); return (m_classp == asamep->m_classp && m_packagep == asamep->m_packagep); } - virtual bool similarDType(AstNodeDType* samep) const { return this == samep || same(samep); } - virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_classp), V3Hash(m_packagep)); } - virtual void dump(std::ostream& str = std::cout) const; - virtual void dumpSmall(std::ostream& str) const; - virtual string name() const { return classp() ? classp()->name() : ""; } - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return 0; } - virtual int widthTotalBytes() const { return 0; } - virtual AstNodeDType* virtRefDTypep() const { return nullptr; } - virtual void virtRefDTypep(AstNodeDType* nodep) {} - virtual AstNodeDType* subDTypep() const { return nullptr; } + virtual bool similarDType(AstNodeDType* samep) const override { + return this == samep || same(samep); + } + virtual V3Hash sameHash() const override { + return V3Hash(V3Hash(m_classp), V3Hash(m_packagep)); + } + virtual void dump(std::ostream& str = std::cout) const override; + virtual void dumpSmall(std::ostream& str) const override; + virtual string name() const override { return classp() ? classp()->name() : ""; } + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return 0; } + virtual int widthTotalBytes() const override { return 0; } + virtual AstNodeDType* virtRefDTypep() const override { return nullptr; } + virtual void virtRefDTypep(AstNodeDType* nodep) override {} + virtual AstNodeDType* subDTypep() const override { return nullptr; } AstNodeModule* packagep() const { return m_packagep; } void packagep(AstNodeModule* nodep) { m_packagep = nodep; } AstClass* classp() const { return m_classp; } @@ -1035,18 +1054,18 @@ public: , m_modportp(nullptr) {} ASTNODE_NODE_FUNCS(IfaceRefDType) // METHODS - virtual const char* broken() const; - virtual void dump(std::ostream& str = std::cout) const; - virtual void dumpSmall(std::ostream& str) const; - virtual void cloneRelink(); - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual bool similarDType(AstNodeDType* samep) const { return this == samep; } - virtual V3Hash sameHash() const { return V3Hash(m_cellp); } - virtual int widthAlignBytes() const { return 1; } - virtual int widthTotalBytes() const { return 1; } + virtual const char* broken() const override; + virtual void dump(std::ostream& str = std::cout) const override; + virtual void dumpSmall(std::ostream& str) const override; + virtual void cloneRelink() override; + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; } + virtual V3Hash sameHash() const override { return V3Hash(m_cellp); } + virtual int widthAlignBytes() const override { return 1; } + virtual int widthTotalBytes() const override { return 1; } FileLine* modportFileline() const { return m_modportFileline; } string cellName() const { return m_cellName; } void cellName(const string& name) { m_cellName = name; } @@ -1078,31 +1097,33 @@ public: dtypep(nullptr); // V3Width will resolve } ASTNODE_NODE_FUNCS(QueueDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstQueueDType* asamep = static_cast(samep); return (subDTypep() == asamep->subDTypep()); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { const AstQueueDType* asamep = static_cast(samep); return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp())); } - virtual void dumpSmall(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); } - virtual string prettyDTypeName() const; - virtual bool isHeavy() const { return true; } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual void dumpSmall(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(m_refDTypep); } + virtual string prettyDTypeName() const override; + virtual bool isHeavy() const override { return true; } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } AstNode* boundp() const { return op2p(); } // op2 = Bound, nullptr = none void boundp(AstNode* nodep) { setNOp2p(nodep); } @@ -1110,18 +1131,18 @@ public: AstConst* constp = VN_CAST(boundp(), Const); return (constp ? constp->toSInt() : 0); } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return nullptr; } + virtual AstBasicDType* basicp() const override { return nullptr; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstRefDType : public AstNodeDType { @@ -1159,35 +1180,39 @@ public: } ASTNODE_NODE_FUNCS(RefDType) // METHODS - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_typedefp && !m_typedefp->brokeExists()); BROKEN_RTN(m_refDTypep && !m_refDTypep->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_typedefp && m_typedefp->clonep()) { m_typedefp = m_typedefp->clonep(); } if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstRefDType* asamep = static_cast(samep); return (m_typedefp == asamep->m_typedefp && m_refDTypep == asamep->m_refDTypep && m_name == asamep->m_name && m_packagep == asamep->m_packagep); } - virtual bool similarDType(AstNodeDType* samep) const { + virtual bool similarDType(AstNodeDType* samep) const override { return skipRefp()->similarDType(samep->skipRefp()); } - virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_typedefp), V3Hash(m_packagep)); } - virtual void dump(std::ostream& str = std::cout) const; - virtual string name() const { return m_name; } - virtual string prettyDTypeName() const { + virtual V3Hash sameHash() const override { + return V3Hash(V3Hash(m_typedefp), V3Hash(m_packagep)); + } + virtual void dump(std::ostream& str = std::cout) const override; + virtual string name() const override { return m_name; } + virtual string prettyDTypeName() const override { return subDTypep() ? subDTypep()->name() : prettyName(); } - virtual AstBasicDType* basicp() const { return subDTypep() ? subDTypep()->basicp() : nullptr; } - AstNodeDType* subDTypep() const { + virtual AstBasicDType* basicp() const override { + return subDTypep() ? subDTypep()->basicp() : nullptr; + } + virtual AstNodeDType* subDTypep() const override { if (typedefp()) return typedefp()->subDTypep(); return refDTypep(); // Maybe nullptr } - virtual AstNodeDType* skipRefp() const { + virtual AstNodeDType* skipRefp() const override { // Skip past both the Ref and the Typedef if (subDTypep()) { return subDTypep()->skipRefp(); @@ -1196,7 +1221,7 @@ public: return nullptr; } } - virtual AstNodeDType* skipRefToConstp() const { + virtual AstNodeDType* skipRefToConstp() const override { if (subDTypep()) { return subDTypep()->skipRefToConstp(); } else { @@ -1204,7 +1229,7 @@ public: return nullptr; } } - virtual AstNodeDType* skipRefToEnump() const { + virtual AstNodeDType* skipRefToEnump() const override { if (subDTypep()) { return subDTypep()->skipRefToEnump(); } else { @@ -1212,17 +1237,17 @@ public: return nullptr; } } - virtual int widthAlignBytes() const { return dtypeSkipRefp()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return dtypeSkipRefp()->widthTotalBytes(); } - void name(const string& flag) { m_name = flag; } + virtual int widthAlignBytes() const override { return dtypeSkipRefp()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return dtypeSkipRefp()->widthTotalBytes(); } + virtual void name(const string& flag) override { m_name = flag; } // op1 = Range of variable AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); } AstTypedef* typedefp() const { return m_typedefp; } void typedefp(AstTypedef* nodep) { m_typedefp = nodep; } AstNodeDType* refDTypep() const { return m_refDTypep; } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return refDTypep(); } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } + virtual AstNodeDType* virtRefDTypep() const override { return refDTypep(); } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } AstNodeModule* packagep() const { return m_packagep; } void packagep(AstNodeModule* nodep) { m_packagep = nodep; } AstNode* typeofp() const { return op2p(); } @@ -1236,7 +1261,7 @@ public: AstStructDType(FileLine* fl, VSigning numericUnpack) : ASTGEN_SUPER(fl, numericUnpack) {} ASTNODE_NODE_FUNCS(StructDType) - virtual string verilogKwd() const { return "struct"; } + virtual string verilogKwd() const override { return "struct"; } }; class AstUnionDType : public AstNodeUOrStructDType { @@ -1246,7 +1271,7 @@ public: AstUnionDType(FileLine* fl, VSigning numericUnpack) : ASTGEN_SUPER(fl, numericUnpack) {} ASTNODE_NODE_FUNCS(UnionDType) - virtual string verilogKwd() const { return "union"; } + virtual string verilogKwd() const override { return "union"; } }; class AstMemberDType : public AstNodeDType { @@ -1277,35 +1302,39 @@ public: widthFromSub(subDTypep()); } ASTNODE_NODE_FUNCS(MemberDType) - virtual string name() const { return m_name; } // * = Var name - virtual bool hasDType() const { return true; } - virtual bool maybePointedTo() const { return true; } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual string name() const override { return m_name; } // * = Var name + virtual bool hasDType() const override { return true; } + virtual bool maybePointedTo() const override { return true; } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } - virtual bool similarDType(AstNodeDType* samep) const { return this == samep; } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; } // // (Slow) recurse down to find basic data type (Note don't need virtual - // AstVar isn't a NodeDType) - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } // op1 = Range of variable (Note don't need virtual - AstVar isn't a NodeDType) AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); } - virtual AstNodeDType* skipRefp() const { return subDTypep()->skipRefp(); } - virtual AstNodeDType* skipRefToConstp() const { return subDTypep()->skipRefToConstp(); } - virtual AstNodeDType* skipRefToEnump() const { return subDTypep()->skipRefToEnump(); } + virtual AstNodeDType* skipRefp() const override { return subDTypep()->skipRefp(); } + virtual AstNodeDType* skipRefToConstp() const override { + return subDTypep()->skipRefToConstp(); + } + virtual AstNodeDType* skipRefToEnump() const override { return subDTypep()->skipRefToEnump(); } // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this) - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,... - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } // METHODS - virtual void name(const string& name) { m_name = name; } - virtual void tag(const string& text) { m_tag = text; } - virtual string tag() const { return m_tag; } + virtual void name(const string& name) override { m_name = name; } + virtual void tag(const string& text) override { m_tag = text; } + virtual string tag() const override { return m_tag; } int lsb() const { return m_lsb; } void lsb(int lsb) { m_lsb = lsb; } }; @@ -1318,23 +1347,23 @@ public: dtypep(this); } ASTNODE_NODE_FUNCS(VoidDType) - virtual void dumpSmall(std::ostream& str) const; - virtual bool hasDType() const { return true; } - virtual bool maybePointedTo() const { return true; } - virtual AstNodeDType* subDTypep() const { return nullptr; } - virtual AstNodeDType* virtRefDTypep() const { return nullptr; } - virtual void virtRefDTypep(AstNodeDType* nodep) {} - virtual bool similarDType(AstNodeDType* samep) const { return this == samep; } - virtual AstBasicDType* basicp() const { return nullptr; } + virtual void dumpSmall(std::ostream& str) const override; + virtual bool hasDType() const override { return true; } + virtual bool maybePointedTo() const override { return true; } + virtual AstNodeDType* subDTypep() const override { return nullptr; } + virtual AstNodeDType* virtRefDTypep() const override { return nullptr; } + virtual void virtRefDTypep(AstNodeDType* nodep) override {} + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; } + virtual AstBasicDType* basicp() const override { return nullptr; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefp() const override { return (AstNodeDType*)this; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return 1; } - virtual int widthTotalBytes() const { return 1; } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return 1; } + virtual int widthTotalBytes() const override { return 1; } + virtual V3Hash sameHash() const override { return V3Hash(); } }; class AstEnumItem : public AstNode { @@ -1350,10 +1379,10 @@ public: addNOp2p(initp); } ASTNODE_NODE_FUNCS(EnumItem) - virtual string name() const { return m_name; } - virtual bool maybePointedTo() const { return true; } - virtual bool hasDType() const { return true; } - void name(const string& flag) { m_name = flag; } + virtual string name() const override { return m_name; } + virtual bool maybePointedTo() const override { return true; } + virtual bool hasDType() const override { return true; } + virtual void name(const string& flag) override { m_name = flag; } AstRange* rangep() const { return VN_CAST(op1p(), Range); } // op1 = Range for name appending void rangep(AstNode* nodep) { addOp1p(nodep); } AstNode* valuep() const { return op2p(); } // op2 = Value @@ -1372,24 +1401,24 @@ public: dtypeFrom(m_itemp); } ASTNODE_NODE_FUNCS(EnumItemRef) - virtual void dump(std::ostream& str) const; - virtual string name() const { return itemp()->name(); } - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return itemp()->name(); } + virtual const char* broken() const override { BROKEN_RTN(!VN_IS(itemp(), EnumItem)); return nullptr; } - virtual int instrCount() const { return 0; } - virtual void cloneRelink() { + virtual int instrCount() const override { return 0; } + virtual void cloneRelink() override { if (m_itemp->clonep()) m_itemp = VN_CAST(m_itemp->clonep(), EnumItem); } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstEnumItemRef* sp = static_cast(samep); return itemp() == sp->itemp(); } AstEnumItem* itemp() const { return m_itemp; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } AstNodeModule* packagep() const { return m_packagep; } void packagep(AstNodeModule* nodep) { m_packagep = nodep; } }; @@ -1413,40 +1442,44 @@ public: m_uniqueNum = uniqueNumInc(); } ASTNODE_NODE_FUNCS(EnumDType) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists()) || (!m_refDTypep && childDTypep()))); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_refDTypep && m_refDTypep->clonep()) { m_refDTypep = m_refDTypep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { const AstEnumDType* sp = static_cast(samep); return m_uniqueNum == sp->m_uniqueNum; } - virtual bool similarDType(AstNodeDType* samep) const { return this == samep; } - virtual V3Hash sameHash() const { return V3Hash(m_uniqueNum); } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; } + virtual V3Hash sameHash() const override { return V3Hash(m_uniqueNum); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } // op1 = Data type void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); } // op1 = Range of variable - virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); } + virtual AstNodeDType* subDTypep() const override { + return m_refDTypep ? m_refDTypep : childDTypep(); + } void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; } - virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; } - virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); } - virtual string name() const { return m_name; } - void name(const string& flag) { m_name = flag; } + virtual AstNodeDType* virtRefDTypep() const override { return m_refDTypep; } + virtual void virtRefDTypep(AstNodeDType* nodep) override { refDTypep(nodep); } + virtual string name() const override { return m_name; } + virtual void name(const string& flag) override { m_name = flag; } AstEnumItem* itemsp() const { return VN_CAST(op2p(), EnumItem); } // op2 = AstEnumItem's void addValuesp(AstNode* nodep) { addOp2p(nodep); } // METHODS - virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); } - virtual AstNodeDType* skipRefp() const { return subDTypep()->skipRefp(); } - virtual AstNodeDType* skipRefToConstp() const { return subDTypep()->skipRefToConstp(); } + virtual AstBasicDType* basicp() const override { return subDTypep()->basicp(); } + virtual AstNodeDType* skipRefp() const override { return subDTypep()->skipRefp(); } + virtual AstNodeDType* skipRefToConstp() const override { + return subDTypep()->skipRefToConstp(); + } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); } - virtual int widthTotalBytes() const { return subDTypep()->widthTotalBytes(); } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return subDTypep()->widthAlignBytes(); } + virtual int widthTotalBytes() const override { return subDTypep()->widthTotalBytes(); } }; class AstParseTypeDType : public AstNodeDType { @@ -1459,15 +1492,15 @@ public: ASTNODE_NODE_FUNCS(ParseTypeDType) AstNodeDType* dtypep() const { return nullptr; } // METHODS - virtual bool similarDType(AstNodeDType* samep) const { return this == samep; } - virtual AstBasicDType* basicp() const { return nullptr; } - virtual AstNodeDType* skipRefp() const { return nullptr; } + virtual bool similarDType(AstNodeDType* samep) const override { return this == samep; } + virtual AstBasicDType* basicp() const override { return nullptr; } + virtual AstNodeDType* skipRefp() const override { return nullptr; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; } + virtual AstNodeDType* skipRefToConstp() const override { return (AstNodeDType*)this; } // cppcheck-suppress csyleCast - virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; } - virtual int widthAlignBytes() const { return 0; } - virtual int widthTotalBytes() const { return 0; } + virtual AstNodeDType* skipRefToEnump() const override { return (AstNodeDType*)this; } + virtual int widthAlignBytes() const override { return 0; } + virtual int widthTotalBytes() const override { return 0; } }; //###################################################################### @@ -1493,24 +1526,26 @@ public: init(fromp); } ASTNODE_NODE_FUNCS(ArraySel) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstArraySel(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; /* How can from be a const? */ } - virtual string emitVerilog() { return "%k(%l%f[%r])"; } - virtual string emitC() { return "%li%k[%ri]"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool isGateOptimizable() const { return true; } // esp for V3Const::ifSameAssign - virtual bool isPredictOptimizable() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "%k(%l%f[%r])"; } + virtual string emitC() override { return "%li%k[%ri]"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool isGateOptimizable() const override { + return true; + } // esp for V3Const::ifSameAssign + virtual bool isPredictOptimizable() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } // Special operators static AstNode* baseFromp(AstNode* nodep); ///< What is the base variable (or const) this dereferences? @@ -1533,24 +1568,26 @@ public: init(fromp); } ASTNODE_NODE_FUNCS(AssocSel) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssocSel(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } - virtual string emitVerilog() { return "%k(%l%f[%r])"; } - virtual string emitC() { return "%li%k[%ri]"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool isGateOptimizable() const { return true; } // esp for V3Const::ifSameAssign - virtual bool isPredictOptimizable() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "%k(%l%f[%r])"; } + virtual string emitC() override { return "%li%k[%ri]"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool isGateOptimizable() const override { + return true; + } // esp for V3Const::ifSameAssign + virtual bool isPredictOptimizable() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } }; class AstWordSel : public AstNodeSel { @@ -1561,21 +1598,23 @@ public: dtypeSetUInt32(); // Always used on WData arrays so returns edata size } ASTNODE_NODE_FUNCS(WordSel) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstWordSel(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit) { + virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit) override { V3ERROR_NA; } - virtual string emitVerilog() { return "%k(%l%f[%r])"; } - virtual string emitC() { return "%li[%ri]"; } // Not %k, as usually it's a small constant rhsp - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string emitVerilog() override { return "%k(%l%f[%r])"; } + virtual string emitC() override { + return "%li[%ri]"; + } // Not %k, as usually it's a small constant rhsp + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstSelLoopVars : public AstNode { @@ -1588,11 +1627,9 @@ public: addNOp2p(elementsp); } ASTNODE_NODE_FUNCS(SelLoopVars) - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual bool maybePointedTo() const { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual bool maybePointedTo() const override { return false; } AstNode* fromp() const { return op1p(); } AstNode* elementsp() const { return op2p(); } }; @@ -1665,26 +1702,28 @@ public: dtypeSetLogicSized(bitwidth, VSigning::UNSIGNED); } ASTNODE_NODE_FUNCS(Sel) - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit, - const V3Number& width) { + const V3Number& width) override { out.opSel(from, bit.toUInt() + width.toUInt() - 1, bit.toUInt()); } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { return this->widthp()->isOne() ? "VL_BITSEL_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri)" : "VL_SEL_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri, %ti)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool cleanThs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } - virtual int instrCount() const { return widthInstrs() * (VN_CAST(lsbp(), Const) ? 3 : 10); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool cleanThs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } + virtual int instrCount() const override { + return widthInstrs() * (VN_CAST(lsbp(), Const) ? 3 : 10); + } AstNode* fromp() const { return op1p(); } // op1 = Extracting what (nullptr=TBD during parsing) @@ -1712,23 +1751,23 @@ public: new AstConst(fl, declRange.elements())) , m_declRange(declRange) {} ASTNODE_NODE_FUNCS(SliceSel) - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& lo, - const V3Number& width) { + const V3Number& width) override { V3ERROR_NA; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } // Removed before EmitC - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return true; } - virtual bool cleanThs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } - virtual int instrCount() const { return 10; } // Removed before matters + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } // Removed before EmitC + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return true; } + virtual bool cleanThs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } + virtual int instrCount() const override { return 10; } // Removed before matters AstNode* fromp() const { return op1p(); } // op1 = Extracting what (nullptr=TBD during parsing) @@ -1755,13 +1794,13 @@ public: setOp2p(fromp); } ASTNODE_NODE_FUNCS(MethodCall) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_BASE_RTN(AstNodeFTaskRef::broken()); BROKEN_RTN(!fromp()); return nullptr; } - virtual void dump(std::ostream& str) const; - virtual bool hasDType() const { return true; } + virtual void dump(std::ostream& str) const override; + virtual bool hasDType() const override { return true; } void makeStatement() { statement(true); dtypeSetVoid(); @@ -1797,15 +1836,15 @@ public: addNOp2p(pinsp); } ASTNODE_NODE_FUNCS(CMethodHard) - virtual string name() const { return m_name; } // * = Var name - virtual bool hasDType() const { return true; } - virtual void name(const string& name) { m_name = name; } - virtual V3Hash sameHash() const { return V3Hash(m_name); } - virtual bool same(const AstNode* samep) const { + virtual string name() const override { return m_name; } // * = Var name + virtual bool hasDType() const override { return true; } + virtual void name(const string& name) override { m_name = name; } + virtual V3Hash sameHash() const override { return V3Hash(m_name); } + virtual bool same(const AstNode* samep) const override { const AstCMethodHard* asamep = static_cast(samep); return (m_name == asamep->m_name); } - virtual bool isPure() const { return m_pure; } + virtual bool isPure() const override { return m_pure; } void pure(bool flag) { m_pure = flag; } void makeStatement() { statement(true); @@ -1959,11 +1998,11 @@ public: m_declKwd = examplep->declKwd(); } ASTNODE_NODE_FUNCS(Var) - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } // * = Var name - virtual bool hasDType() const { return true; } - virtual bool maybePointedTo() const { return true; } - virtual string origName() const { return m_origName; } // * = Original name + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } // * = Var name + virtual bool hasDType() const override { return true; } + virtual bool maybePointedTo() const override { return true; } + virtual string origName() const override { return m_origName; } // * = Original name void origName(const string& name) { m_origName = name; } AstVarType varType() const { return m_varType; } // * = Type of variable void direction(const VDirection& flag) { @@ -1994,7 +2033,7 @@ public: string vlEnumDir() const; // Return VerilatorVarDir: VLVD_INOUT, etc string vlPropDecl(string propName) const; // Return VerilatorVarProps declaration void combineType(AstVarType type); - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } // op1 = Range of variable AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } AstNodeDType* dtypeSkipRefp() const { return subDTypep()->skipRefp(); } @@ -2050,9 +2089,9 @@ public: bool overriddenParam() const { return m_overridenParam; } void trace(bool flag) { m_trace = flag; } // METHODS - virtual void name(const string& name) { m_name = name; } - virtual void tag(const string& text) { m_tag = text; } - virtual string tag() const { return m_tag; } + virtual void name(const string& name) override { m_name = name; } + virtual void tag(const string& text) override { m_tag = text; } + virtual string tag() const override { return m_tag; } bool isAnsi() const { return m_ansi; } bool isDeclTyped() const { return m_declTyped; } bool isInoutish() const { return m_direction.isInoutish(); } @@ -2113,7 +2152,7 @@ public: bool attrSplitVar() const { return m_attrSplitVar; } bool attrIsolateAssign() const { return m_attrIsolateAssign; } VVarAttrClocker attrClocker() const { return m_attrClocker; } - virtual string verilogKwd() const; + virtual string verilogKwd() const override; void lifetime(const VLifetime& flag) { m_lifetime = flag; } VLifetime lifetime() const { return m_lifetime; } void propagateAttrFrom(AstVar* fromp) { @@ -2171,11 +2210,10 @@ public: m_name = name; m_path = path; } - virtual string name() const { return m_name; } // * = Scope name + virtual string name() const override { return m_name; } // * = Scope name ASTNODE_NODE_FUNCS(DefParam) - virtual bool cleanRhs() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode*) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode*) const override { return true; } AstNode* rhsp() const { return op1p(); } // op1 = Assign from string path() const { return m_path; } }; @@ -2211,11 +2249,11 @@ public: , m_aboveCellp(aboveCellp) , m_modp(modp) {} ASTNODE_NODE_FUNCS(Scope) - virtual void cloneRelink(); - virtual const char* broken() const; - virtual bool maybePointedTo() const { return true; } - virtual string name() const { return m_name; } // * = Scope name - virtual void name(const string& name) { m_name = name; } + virtual void cloneRelink() override; + virtual const char* broken() const override; + virtual bool maybePointedTo() const override { return true; } + virtual string name() const override { return m_name; } // * = Scope name + virtual void name(const string& name) override { m_name = name; } string nameDotless() const; string nameVlSym() const { return ((string("vlSymsp->")) + nameDotless()); } AstNodeModule* modp() const { return m_modp; } @@ -2267,22 +2305,22 @@ public: dtypeFrom(varp); } ASTNODE_NODE_FUNCS(VarScope) - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep(); UASSERT(m_scopep->clonep(), "No clone cross link: " << this); m_scopep = m_scopep->clonep(); } } - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_varp && !m_varp->brokeExists()); BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return nullptr; } - virtual bool maybePointedTo() const { return true; } - virtual string name() const { return scopep()->name() + "->" + varp()->name(); } - virtual void dump(std::ostream& str) const; - virtual bool hasDType() const { return true; } + virtual bool maybePointedTo() const override { return true; } + virtual string name() const override { return scopep()->name() + "->" + varp()->name(); } + virtual void dump(std::ostream& str) const override; + virtual bool hasDType() const override { return true; } AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable AstScope* scopep() const { return m_scopep; } // Pointer to scope it's under // op1 = Calculation of value of variable, nullptr=complicated @@ -2309,9 +2347,11 @@ public: varScopep(varscp); } ASTNODE_NODE_FUNCS(VarRef) - virtual void dump(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(V3Hash(varp()->name()), V3Hash(hiername())); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual V3Hash sameHash() const override { + return V3Hash(V3Hash(varp()->name()), V3Hash(hiername())); + } + virtual bool same(const AstNode* samep) const override { return same(static_cast(samep)); } inline bool same(const AstVarRef* samep) const { @@ -2329,10 +2369,12 @@ public: return (hiername() == samep->hiername() && varp()->name() == samep->varp()->name()); } } - virtual int instrCount() const { return widthInstrs() * (lvalue() ? 1 : instrCountLd()); } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual int instrCount() const override { + return widthInstrs() * (lvalue() ? 1 : instrCountLd()); + } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } }; class AstVarXRef : public AstNodeVarRef { @@ -2351,18 +2393,18 @@ public: dtypeFrom(varp); } ASTNODE_NODE_FUNCS(VarXRef) - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; string dotted() const { return m_dotted; } void dotted(const string& dotted) { m_dotted = dotted; } string prettyDotted() const { return prettyName(dotted()); } string inlinedDots() const { return m_inlinedDots; } void inlinedDots(const string& flag) { m_inlinedDots = flag; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(V3Hash(varp()), V3Hash(dotted())); } - virtual bool same(const AstNode* samep) const { + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(V3Hash(varp()), V3Hash(dotted())); } + virtual bool same(const AstNode* samep) const override { const AstVarXRef* asamep = static_cast(samep); return (hiername() == asamep->hiername() && varp() == asamep->varp() && name() == asamep->name() && dotted() == asamep->dotted()); @@ -2400,15 +2442,15 @@ public: setNOp1p(exprp); } ASTNODE_NODE_FUNCS(Pin) - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_RTN(m_modVarp && !m_modVarp->brokeExists()); BROKEN_RTN(m_modPTypep && !m_modPTypep->brokeExists()); return nullptr; } - virtual string name() const { return m_name; } // * = Pin name, ""=go by number - virtual void name(const string& name) { m_name = name; } - virtual string prettyOperatorName() const { + virtual string name() const override { return m_name; } // * = Pin name, ""=go by number + virtual void name(const string& name) override { m_name = name; } + virtual string prettyOperatorName() const override { return modVarp() ? ((modVarp()->direction().isAny() ? modVarp()->direction().prettyName() + " " : "") @@ -2442,9 +2484,9 @@ public: setNOp1p(exprp); } ASTNODE_NODE_FUNCS(Arg) - virtual string name() const { return m_name; } // * = Pin name, ""=go by number - virtual void name(const string& name) { m_name = name; } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual string name() const override { return m_name; } // * = Pin name, ""=go by number + virtual void name(const string& name) override { m_name = name; } + virtual V3Hash sameHash() const override { return V3Hash(); } void exprp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expression connected to pin, nullptr if unconnected AstNode* exprp() const { return op1p(); } @@ -2460,7 +2502,7 @@ public: : ASTGEN_SUPER(fl, name) , m_isProgram(program) {} ASTNODE_NODE_FUNCS(Module) - virtual string verilogKwd() const { return m_isProgram ? "program" : "module"; } + virtual string verilogKwd() const override { return m_isProgram ? "program" : "module"; } }; class AstNotFoundModule : public AstNodeModule { @@ -2469,7 +2511,7 @@ public: AstNotFoundModule(FileLine* fl, const string& name) : ASTGEN_SUPER(fl, name) {} ASTNODE_NODE_FUNCS(NotFoundModule) - virtual string verilogKwd() const { return "/*not-found-*/ module"; } + virtual string verilogKwd() const override { return "/*not-found-*/ module"; } }; class AstPackage : public AstNodeModule { @@ -2478,7 +2520,7 @@ public: AstPackage(FileLine* fl, const string& name) : ASTGEN_SUPER(fl, name) {} ASTNODE_NODE_FUNCS(Package) - virtual string verilogKwd() const { return "package"; } + virtual string verilogKwd() const override { return "package"; } static string dollarUnitName() { return AstNode::encodeName("$unit"); } bool isDollarUnit() const { return name() == dollarUnitName(); } }; @@ -2489,7 +2531,7 @@ public: AstPrimitive(FileLine* fl, const string& name) : ASTGEN_SUPER(fl, name) {} ASTNODE_NODE_FUNCS(Primitive) - virtual string verilogKwd() const { return "primitive"; } + virtual string verilogKwd() const override { return "primitive"; } }; class AstPackageExportStarStar : public AstNode { @@ -2512,15 +2554,15 @@ public: , m_name(name) , m_packagep(packagep) {} ASTNODE_NODE_FUNCS(PackageExport) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); } - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } AstPackage* packagep() const { return m_packagep; } void packagep(AstPackage* nodep) { m_packagep = nodep; } }; @@ -2536,15 +2578,15 @@ public: , m_name(name) , m_packagep(packagep) {} ASTNODE_NODE_FUNCS(PackageImport) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); } - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } AstPackage* packagep() const { return m_packagep; } void packagep(AstPackage* nodep) { m_packagep = nodep; } }; @@ -2580,24 +2622,23 @@ public: dtypep(dtp); } ASTNODE_NODE_FUNCS(MemberSel) - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep(); } } - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return nullptr; } - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } - virtual V3Hash sameHash() const { return V3Hash(m_name); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; /* How can from be a const? */ - } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool same(const AstNode* samep) const { return true; } // dtype comparison does it - virtual int instrCount() const { return widthInstrs(); } + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } + virtual V3Hash sameHash() const override { return V3Hash(m_name); } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool same(const AstNode* samep) const override { + return true; + } // dtype comparison does it + virtual int instrCount() const override { return widthInstrs(); } AstNode* fromp() const { return op1p(); } // op1 = Extracting what (nullptr=TBD during parsing) @@ -2622,13 +2663,13 @@ public: , m_export(isExport) , m_ftaskp(nullptr) {} ASTNODE_NODE_FUNCS(ModportFTaskRef) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_ftaskp && !m_ftaskp->brokeExists()); return nullptr; } - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } - virtual void cloneRelink() { + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } + virtual void cloneRelink() override { if (m_ftaskp && m_ftaskp->clonep()) m_ftaskp = m_ftaskp->clonep(); } bool isImport() const { return !m_export; } @@ -2652,15 +2693,15 @@ public: , m_direction(direction) , m_varp(nullptr) {} ASTNODE_NODE_FUNCS(ModportVarRef) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return nullptr; } - virtual void dump(std::ostream& str) const; - virtual void cloneRelink() { + virtual void dump(std::ostream& str) const override; + virtual void cloneRelink() override { if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep(); } - virtual string name() const { return m_name; } + virtual string name() const override { return m_name; } void direction(const VDirection& flag) { m_direction = flag; } VDirection direction() const { return m_direction; } AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable @@ -2677,8 +2718,8 @@ public: , m_name(name) { addNOp1p(varsp); } - virtual string name() const { return m_name; } - virtual bool maybePointedTo() const { return true; } + virtual string name() const override { return m_name; } + virtual bool maybePointedTo() const override { return true; } ASTNODE_NODE_FUNCS(Modport) AstNode* varsp() const { return op1p(); } // op1 = List of Vars }; @@ -2691,7 +2732,7 @@ public: AstIntfRef(FileLine* fl, const string& name) : ASTGEN_SUPER(fl) , m_name(name) {} - virtual string name() const { return m_name; } + virtual string name() const override { return m_name; } ASTNODE_NODE_FUNCS(IntfRef) }; @@ -2724,16 +2765,16 @@ public: } ASTNODE_NODE_FUNCS(Cell) // No cloneRelink, we presume cloneee's want the same module linkages - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_RTN(m_modp && !m_modp->brokeExists()); return nullptr; } - virtual bool maybePointedTo() const { return true; } + virtual bool maybePointedTo() const override { return true; } // ACCESSORS - virtual string name() const { return m_name; } // * = Cell name - virtual void name(const string& name) { m_name = name; } - virtual string origName() const { return m_origName; } // * = Original name + virtual string name() const override { return m_name; } // * = Cell name + virtual void name(const string& name) override { m_name = name; } + virtual string origName() const override { return m_origName; } // * = Original name void origName(const string& name) { m_origName = name; } string modName() const { return m_modName; } // * = Instance name void modName(const string& name) { m_modName = name; } @@ -2778,15 +2819,15 @@ public: , m_scopep(nullptr) , m_timeunit(timeunit) {} ASTNODE_NODE_FUNCS(CellInline) - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return nullptr; } // ACCESSORS - virtual string name() const { return m_name; } // * = Cell name + virtual string name() const override { return m_name; } // * = Cell name string origModName() const { return m_origModName; } // * = modp()->origName() before inlining - virtual void name(const string& name) { m_name = name; } + virtual void name(const string& name) override { m_name = name; } void scopep(AstScope* scp) { m_scopep = scp; } AstScope* scopep() const { return m_scopep; } void timeunit(const VTimescale& flag) { m_timeunit = flag; } @@ -2806,7 +2847,7 @@ public: } ASTNODE_NODE_FUNCS(CellRef) // ACCESSORS - virtual string name() const { return m_name; } // * = Array name + virtual string name() const override { return m_name; } // * = Array name AstNode* cellp() const { return op1p(); } // op1 = Cell AstNode* exprp() const { return op2p(); } // op2 = Expression }; @@ -2823,7 +2864,7 @@ public: } ASTNODE_NODE_FUNCS(CellArrayRef) // ACCESSORS - virtual string name() const { return m_name; } // * = Array name + virtual string name() const override { return m_name; } // * = Array name AstNode* selp() const { return op1p(); } // op1 = Select expression }; @@ -2840,7 +2881,7 @@ public: } ASTNODE_NODE_FUNCS(UnlinkedRef) // ACCESSORS - virtual string name() const { return m_name; } // * = Var name + virtual string name() const override { return m_name; } // * = Var name AstNode* refp() const { return op1p(); } // op1 = VarXRef or AstNodeFTaskRef AstNode* cellrefp() const { return op2p(); } // op2 = CellArrayRef or CellRef }; @@ -2859,8 +2900,8 @@ public: } ASTNODE_NODE_FUNCS(Bind) // ACCESSORS - virtual string name() const { return m_name; } // * = Bind Target name - virtual void name(const string& name) { m_name = name; } + virtual string name() const override { return m_name; } // * = Bind Target name + virtual void name(const string& name) override { m_name = name; } AstNode* cellsp() const { return op1p(); } // op1 = cells }; @@ -2875,7 +2916,7 @@ public: , m_pinNum(pinnum) , m_name(name) {} ASTNODE_NODE_FUNCS(Port) - virtual string name() const { return m_name; } // * = Port name + virtual string name() const override { return m_name; } // * = Port name int pinNum() const { return m_pinNum; } // * = Pin number, for order based instantiation AstNode* exprp() const { return op1p(); } // op1 = Expression connected to port }; @@ -2902,16 +2943,14 @@ public: setNOp2p(ftaskrefp); } ASTNODE_NODE_FUNCS(ParseRef) - virtual void dump(std::ostream& str) const; - virtual string name() const { return m_name; } // * = Var name - virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_expect), V3Hash(m_name)); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual string name() const override { return m_name; } // * = Var name + virtual V3Hash sameHash() const override { return V3Hash(V3Hash(m_expect), V3Hash(m_name)); } + virtual bool same(const AstNode* samep) const override { const AstParseRef* asamep = static_cast(samep); return (expect() == asamep->expect() && m_name == asamep->m_name); } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual void name(const string& name) { m_name = name; } + virtual void name(const string& name) override { m_name = name; } VParseRefExp expect() const { return m_expect; } void expect(VParseRefExp exp) { m_expect = exp; } // op1 = Components @@ -2934,22 +2973,22 @@ public: } ASTNODE_NODE_FUNCS(ClassOrPackageRef) // METHODS - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_classOrPackagep && !m_classOrPackagep->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_classOrPackagep && m_classOrPackagep->clonep()) { m_classOrPackagep = m_classOrPackagep->clonep(); } } - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { return (m_classOrPackagep == static_cast(samep)->m_classOrPackagep); } - virtual V3Hash sameHash() const { return V3Hash(m_classOrPackagep); } - virtual void dump(std::ostream& str = std::cout) const; - virtual string name() const { return m_name; } // * = Var name + virtual V3Hash sameHash() const override { return V3Hash(m_classOrPackagep); } + virtual void dump(std::ostream& str = std::cout) const override; + virtual string name() const override { return m_name; } // * = Var name AstNode* classOrPackagep() const { return m_classOrPackagep; } AstPackage* packagep() const { return VN_CAST(classOrPackagep(), Package); } void classOrPackagep(AstNode* nodep) { m_classOrPackagep = nodep; } @@ -2973,9 +3012,7 @@ public: if (!packageOrClassp) return rhsp; return new AstDot(fl, true, packageOrClassp, rhsp); } - virtual void dump(std::ostream& str) const; - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } + virtual void dump(std::ostream& str) const override; AstNode* lhsp() const { return op1p(); } AstNode* rhsp() const { return op2p(); } bool colon() const { return m_colon; } @@ -2990,9 +3027,9 @@ public: dtypeSetSigned32(); } ASTNODE_NODE_FUNCS(Unbounded) - virtual string emitVerilog() { return "$"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual string emitVerilog() override { return "$"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } }; //###################################################################### @@ -3013,7 +3050,7 @@ public: addNOp1p(fvarsp); } ASTNODE_NODE_FUNCS(Func) - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } }; class AstTaskRef : public AstNodeFTaskRef { @@ -3036,7 +3073,7 @@ public: AstFuncRef(FileLine* fl, const string& name, AstNode* pinsp) : ASTGEN_SUPER(fl, false, name, pinsp) {} ASTNODE_NODE_FUNCS(FuncRef) - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } }; class AstDpiExport : public AstNode { @@ -3052,8 +3089,8 @@ public: , m_name(vname) , m_cname(cname) {} ASTNODE_NODE_FUNCS(DpiExport) - virtual string name() const { return m_name; } - virtual void name(const string& name) { m_name = name; } + virtual string name() const override { return m_name; } + virtual void name(const string& name) override { m_name = name; } string cname() const { return m_cname; } void cname(const string& cname) { m_cname = cname; } }; @@ -3067,8 +3104,8 @@ public: addNOp2p(argsp); } ASTNODE_NODE_FUNCS(With) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // AstNode* funcrefp() const { return op1p(); } }; @@ -3112,9 +3149,9 @@ public: m_edgeType = VEdgeType::ET_NEVER; } ASTNODE_NODE_FUNCS(SenItem) - virtual void dump(std::ostream& str) const; - virtual V3Hash sameHash() const { return V3Hash(edgeType()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual V3Hash sameHash() const override { return V3Hash(edgeType()); } + virtual bool same(const AstNode* samep) const override { return edgeType() == static_cast(samep)->edgeType(); } VEdgeType edgeType() const { return m_edgeType; } // * = Posedge/negedge @@ -3149,9 +3186,9 @@ public: addNOp1p(sensesp); } ASTNODE_NODE_FUNCS(SenTree) - virtual void dump(std::ostream& str) const; - virtual bool maybePointedTo() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual void dump(std::ostream& str) const override; + virtual bool maybePointedTo() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } bool isMulti() const { return m_multi; } // op1 = Sensitivity list AstSenItem* sensesp() const { return VN_CAST(op1p(), SenItem); } @@ -3189,7 +3226,7 @@ public: } ASTNODE_NODE_FUNCS(Always) // - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); } // op1 = Sensitivity list void sensesp(AstSenTree* nodep) { setOp1p(nodep); } VAlwaysKwd keyword() const { return m_keyword; } @@ -3205,8 +3242,8 @@ public: addNOp2p(bodysp); } ASTNODE_NODE_FUNCS(AlwaysPublic) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); } // op1 = Sensitivity list AstNode* bodysp() const { return op2p(); } // op2 = Statements to evaluate @@ -3236,10 +3273,10 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Assign) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssign(this->fileline(), lhsp, rhsp); } - virtual bool brokeLhsMustBeLvalue() const { return true; } + virtual bool brokeLhsMustBeLvalue() const override { return true; } }; class AstAssignAlias : public AstNodeAssign { @@ -3249,8 +3286,10 @@ public: AstAssignAlias(FileLine* fl, AstVarRef* lhsp, AstVarRef* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(AssignAlias) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { V3ERROR_NA_RETURN(nullptr); } - virtual bool brokeLhsMustBeLvalue() const { return false; } + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { + V3ERROR_NA_RETURN(nullptr); + } + virtual bool brokeLhsMustBeLvalue() const override { return false; } }; class AstAssignDly : public AstNodeAssign { @@ -3258,12 +3297,12 @@ public: AstAssignDly(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(AssignDly) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignDly(this->fileline(), lhsp, rhsp); } - virtual bool isGateOptimizable() const { return false; } - virtual string verilogKwd() const { return "<="; } - virtual bool brokeLhsMustBeLvalue() const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual string verilogKwd() const override { return "<="; } + virtual bool brokeLhsMustBeLvalue() const override { return true; } }; class AstAssignW : public AstNodeAssign { @@ -3272,10 +3311,10 @@ public: AstAssignW(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(AssignW) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignW(this->fileline(), lhsp, rhsp); } - virtual bool brokeLhsMustBeLvalue() const { return true; } + virtual bool brokeLhsMustBeLvalue() const override { return true; } AstAlways* convertToAlways() { AstNode* lhs1p = lhsp()->unlinkFrBack(); AstNode* rhs1p = rhsp()->unlinkFrBack(); @@ -3294,10 +3333,10 @@ public: dtypeFrom(rhsp); } ASTNODE_NODE_FUNCS(AssignVarScope) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignVarScope(this->fileline(), lhsp, rhsp); } - virtual bool brokeLhsMustBeLvalue() const { return false; } + virtual bool brokeLhsMustBeLvalue() const override { return false; } }; class AstPull : public AstNode { @@ -3311,7 +3350,7 @@ public: m_direction = direction; } ASTNODE_NODE_FUNCS(Pull) - virtual bool same(const AstNode* samep) const { + virtual bool same(const AstNode* samep) const override { return direction() == static_cast(samep)->direction(); } void lhsp(AstNode* np) { setOp1p(np); } @@ -3325,10 +3364,10 @@ public: AstAssignPre(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(AssignPre) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignPre(this->fileline(), lhsp, rhsp); } - virtual bool brokeLhsMustBeLvalue() const { return true; } + virtual bool brokeLhsMustBeLvalue() const override { return true; } }; class AstAssignPost : public AstNodeAssign { @@ -3337,10 +3376,10 @@ public: AstAssignPost(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(AssignPost) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAssignPost(this->fileline(), lhsp, rhsp); } - virtual bool brokeLhsMustBeLvalue() const { return true; } + virtual bool brokeLhsMustBeLvalue() const override { return true; } }; class AstComment : public AstNodeStmt { @@ -3356,9 +3395,11 @@ public: , m_showAt(showAt) , m_name(name) {} ASTNODE_NODE_FUNCS(Comment) - virtual string name() const { return m_name; } // * = Text - virtual V3Hash sameHash() const { return V3Hash(); } // Ignore name in comments - virtual bool same(const AstNode* samep) const { return true; } // Ignore name in comments + virtual string name() const override { return m_name; } // * = Text + virtual V3Hash sameHash() const override { return V3Hash(); } // Ignore name in comments + virtual bool same(const AstNode* samep) const override { + return true; + } // Ignore name in comments virtual bool showAt() const { return m_showAt; } }; @@ -3370,7 +3411,7 @@ public: AstCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p) : ASTGEN_SUPER(fl, condp, expr1p, expr2p) {} ASTNODE_NODE_FUNCS(Cond) - virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) { + virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) override { return new AstCond(this->fileline(), condp, expr1p, expr2p); } }; @@ -3383,7 +3424,7 @@ public: AstCondBound(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p) : ASTGEN_SUPER(fl, condp, expr1p, expr2p) {} ASTNODE_NODE_FUNCS(CondBound) - virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) { + virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) override { return new AstCondBound(this->fileline(), condp, expr1p, expr2p); } }; @@ -3413,19 +3454,19 @@ public: m_dataDeclp = nullptr; } ASTNODE_NODE_FUNCS(CoverDecl) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_dataDeclp && !m_dataDeclp->brokeExists()); if (m_dataDeclp && m_dataDeclp->m_dataDeclp) { // Avoid O(n^2) accessing v3fatalSrc("dataDeclp should point to real data, not be a list"); } return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_dataDeclp && m_dataDeclp->clonep()) m_dataDeclp = m_dataDeclp->clonep(); } - virtual void dump(std::ostream& str) const; - virtual int instrCount() const { return 1 + 2 * instrCountLd(); } - virtual bool maybePointedTo() const { return true; } + virtual void dump(std::ostream& str) const override; + virtual int instrCount() const override { return 1 + 2 * instrCountLd(); } + virtual bool maybePointedTo() const override { return true; } void binNum(int flag) { m_binNum = flag; } int binNum() const { return m_binNum; } int offset() const { return m_offset; } @@ -3435,13 +3476,13 @@ public: const string& hier() const { return m_hier; } void hier(const string& flag) { m_hier = flag; } void comment(const string& flag) { m_text = flag; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { const AstCoverDecl* asamep = static_cast(samep); return (fileline() == asamep->fileline() && linescov() == asamep->linescov() && hier() == asamep->hier() && comment() == asamep->comment()); } - virtual bool isPredictOptimizable() const { return false; } + virtual bool isPredictOptimizable() const override { return false; } void dataDeclp(AstCoverDecl* nodep) { m_dataDeclp = nodep; } // dataDecl nullptr means "use this one", but often you want "this" to // indicate to get data from here @@ -3461,22 +3502,22 @@ public: m_declp = declp; } ASTNODE_NODE_FUNCS(CoverInc) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!declp()->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_declp->clonep()) m_declp = m_declp->clonep(); } - virtual void dump(std::ostream& str) const; - virtual int instrCount() const { return 1 + 2 * instrCountLd(); } - virtual V3Hash sameHash() const { return V3Hash(declp()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual int instrCount() const override { return 1 + 2 * instrCountLd(); } + virtual V3Hash sameHash() const override { return V3Hash(declp()); } + virtual bool same(const AstNode* samep) const override { return declp() == static_cast(samep)->declp(); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isOutputter() const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isOutputter() const override { return true; } // but isPure() true AstCoverDecl* declp() const { return m_declp; } // Where defined }; @@ -3493,12 +3534,12 @@ public: setOp3p(changep); } ASTNODE_NODE_FUNCS(CoverToggle) - virtual int instrCount() const { return 3 + instrCountBranch() + instrCountLd(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return true; } - virtual bool isOutputter() const { + virtual int instrCount() const override { return 3 + instrCountBranch() + instrCountLd(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return true; } + virtual bool isOutputter() const override { return false; // Though the AstCoverInc under this is an outputter } // but isPure() true @@ -3516,8 +3557,8 @@ public: setOp1p(lhsp); } ASTNODE_NODE_FUNCS(Delay) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // AstNode* lhsp() const { return op1p(); } // op2 = Statements to evaluate void lhsp(AstNode* nodep) { setOp1p(nodep); } @@ -3557,8 +3598,10 @@ public: m_priorityPragma = false; } ASTNODE_NODE_FUNCS(Case) - virtual string verilogKwd() const { return casez() ? "casez" : casex() ? "casex" : "case"; } - virtual bool same(const AstNode* samep) const { + virtual string verilogKwd() const override { + return casez() ? "casez" : casex() ? "casex" : "case"; + } + virtual bool same(const AstNode* samep) const override { return m_casex == static_cast(samep)->m_casex; } bool casex() const { return m_casex == VCaseType::CT_CASEX; } @@ -3593,7 +3636,7 @@ public: m_ignoreOverlap = false; } ASTNODE_NODE_FUNCS(CaseItem) - virtual int instrCount() const { return widthInstrs() + instrCountBranch(); } + virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } AstNode* condsp() const { return op1p(); } // op1 = list of possible matching expressions AstNode* bodysp() const { return op2p(); } // op2 = what to do void condsp(AstNode* nodep) { setOp1p(nodep); } @@ -3636,14 +3679,14 @@ public: addNOp2p(nullptr); } ASTNODE_NODE_FUNCS(SFormatF) - virtual string name() const { return m_text; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(text()); } - virtual bool hasDType() const { return true; } - virtual bool same(const AstNode* samep) const { + virtual string name() const override { return m_text; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(text()); } + virtual bool hasDType() const override { return true; } + virtual bool same(const AstNode* samep) const override { return text() == static_cast(samep)->text(); } - virtual string verilogKwd() const { return "$sformatf"; } + virtual string verilogKwd() const override { return "$sformatf"; } void addExprsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to output AstNode* exprsp() const { return op1p(); } // op1 = Expressions to output string text() const { return m_text; } // * = Text to display @@ -3684,25 +3727,27 @@ public: m_displayType = dispType; } ASTNODE_NODE_FUNCS(Display) - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { BROKEN_RTN(!fmtp()); return nullptr; } - virtual string verilogKwd() const { + virtual string verilogKwd() const override { return (filep() ? string("$f") + string(displayType().ascii()) : string("$") + string(displayType().ascii())); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: $display makes output - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(displayType()); } - virtual bool same(const AstNode* samep) const { + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: $display makes output + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(displayType()); } + virtual bool same(const AstNode* samep) const override { return displayType() == static_cast(samep)->displayType(); } - virtual int instrCount() const { return instrCountPli(); } + virtual int instrCount() const override { return instrCountPli(); } AstDisplayType displayType() const { return m_displayType; } void displayType(AstDisplayType type) { m_displayType = type; } // * = Add a newline for $display @@ -3725,16 +3770,14 @@ public: setNOp1p(exprp); } ASTNODE_NODE_FUNCS(DumpCtl) - virtual string verilogKwd() const { return ctlType().ascii(); } - virtual string emitVerilog() { return "%f" + verilogKwd() + "(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isHeavy() const { return true; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isOutputter() const { return true; } + virtual string verilogKwd() const override { return ctlType().ascii(); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isHeavy() const override { return true; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isOutputter() const override { return true; } virtual bool cleanOut() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } VDumpCtlType ctlType() const { return m_ctlType; } AstNode* exprp() const { return op1p(); } // op2 = Expressions to output void exprp(AstNode* nodep) { setOp1p(nodep); } @@ -3753,21 +3796,25 @@ public: m_displayType = dispType; } ASTNODE_NODE_FUNCS(ElabDisplay) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!fmtp()); return nullptr; } - virtual string verilogKwd() const { return (string("$") + string(displayType().ascii())); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: $display makes output - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(displayType()); } - virtual bool same(const AstNode* samep) const { + virtual string verilogKwd() const override { + return (string("$") + string(displayType().ascii())); + } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: $display makes output + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(displayType()); } + virtual bool same(const AstNode* samep) const override { return displayType() == static_cast(samep)->displayType(); } - virtual int instrCount() const { return instrCountPli(); } + virtual int instrCount() const override { return instrCountPli(); } AstDisplayType displayType() const { return m_displayType; } void displayType(AstDisplayType type) { m_displayType = type; } void fmtp(AstSFormatF* nodep) { addOp1p(nodep); } // op1 = To-String formatter @@ -3791,21 +3838,19 @@ public: setOp3p(lhsp); } ASTNODE_NODE_FUNCS(SFormat) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!fmtp()); return nullptr; } - virtual string verilogKwd() const { return "$sformat"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return true; } - virtual bool isPure() const { return true; } - virtual bool isOutputter() const { return false; } + virtual string verilogKwd() const override { return "$sformat"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return true; } + virtual bool isPure() const override { return true; } + virtual bool isOutputter() const override { return false; } virtual bool cleanOut() const { return false; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } void fmtp(AstSFormatF* nodep) { addOp1p(nodep); } // op1 = To-String formatter AstSFormatF* fmtp() const { return VN_CAST(op1p(), SFormatF); } AstNode* lhsp() const { return op3p(); } @@ -3822,14 +3867,14 @@ public: addNOp1p(exprsp); } ASTNODE_NODE_FUNCS(SysFuncAsTask) - virtual string verilogKwd() const { return ""; } - virtual bool isGateOptimizable() const { return true; } - virtual bool isPredictOptimizable() const { return true; } - virtual bool isPure() const { return true; } - virtual bool isOutputter() const { return false; } - virtual int instrCount() const { return 0; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return ""; } + virtual bool isGateOptimizable() const override { return true; } + virtual bool isPredictOptimizable() const override { return true; } + virtual bool isPure() const override { return true; } + virtual bool isOutputter() const override { return false; } + virtual int instrCount() const override { return 0; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* lhsp() const { return op1p(); } // op1 = Expressions to eval void lhsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to eval }; @@ -3843,12 +3888,14 @@ public: addNOp1p(exprsp); } ASTNODE_NODE_FUNCS(SysIgnore) - virtual string verilogKwd() const { return "$ignored"; } - virtual bool isGateOptimizable() const { return false; } // Though deleted before opt - virtual bool isPredictOptimizable() const { return false; } // Though deleted before opt - virtual bool isPure() const { return false; } // Though deleted before opt - virtual bool isOutputter() const { return true; } // Though deleted before opt - virtual int instrCount() const { return instrCountPli(); } + virtual string verilogKwd() const override { return "$ignored"; } + virtual bool isGateOptimizable() const override { return false; } // Though deleted before opt + virtual bool isPredictOptimizable() const override { + return false; + } // Though deleted before opt + virtual bool isPure() const override { return false; } // Though deleted before opt + virtual bool isOutputter() const override { return true; } // Though deleted before opt + virtual int instrCount() const override { return instrCountPli(); } AstNode* exprsp() const { return op1p(); } // op1 = Expressions to output void exprsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to output }; @@ -3862,14 +3909,14 @@ public: setNOp2p(filep); } ASTNODE_NODE_FUNCS(FClose) - virtual string verilogKwd() const { return "$fclose"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fclose"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op2p(); } void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; @@ -3884,15 +3931,15 @@ public: setOp3p(modep); } ASTNODE_NODE_FUNCS(FOpen) - virtual string verilogKwd() const { return "$fopen"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isHeavy() const { return true; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fopen"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isHeavy() const override { return true; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op1p(); } AstNode* filenamep() const { return op2p(); } AstNode* modep() const { return op3p(); } @@ -3907,15 +3954,15 @@ public: setOp2p(filenamep); } ASTNODE_NODE_FUNCS(FOpenMcd) - virtual string verilogKwd() const { return "$fopen"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isHeavy() const { return true; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fopen"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isHeavy() const override { return true; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op1p(); } AstNode* filenamep() const { return op2p(); } }; @@ -3929,14 +3976,14 @@ public: setNOp2p(filep); } ASTNODE_NODE_FUNCS(FFlush) - virtual string verilogKwd() const { return "$fflush"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fflush"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op2p(); } void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; @@ -3956,16 +4003,16 @@ public: setNOp4p(countp); } ASTNODE_NODE_FUNCS(FRead) - virtual string verilogKwd() const { return "$fread"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: makes output - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fread"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: makes output + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* memp() const { return op1p(); } void memp(AstNode* nodep) { setOp1p(nodep); } AstNode* filep() const { return op2p(); } @@ -3985,17 +4032,17 @@ public: setNOp2p(filep); } ASTNODE_NODE_FUNCS(FRewind) - virtual string verilogKwd() const { return "$frewind"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$frewind"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op2p(); } void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; @@ -4009,17 +4056,17 @@ public: setNOp2p(filep); } ASTNODE_NODE_FUNCS(FTell) - virtual string verilogKwd() const { return "$ftell"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$ftell"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op2p(); } void filep(AstNodeVarRef* nodep) { setNOp2p(nodep); } }; @@ -4037,16 +4084,16 @@ public: setNOp4p(operation); } ASTNODE_NODE_FUNCS(FSeek) - virtual string verilogKwd() const { return "$fseek"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: makes output - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$fseek"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: makes output + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* filep() const { return op2p(); } void filep(AstNode* nodep) { setOp2p(nodep); } AstNode* offset() const { return op3p(); } @@ -4070,17 +4117,17 @@ public: setNOp2p(filep); } ASTNODE_NODE_FUNCS(FScanF) - virtual string name() const { return m_text; } - virtual string verilogKwd() const { return "$fscanf"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: makes output - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(text()); } - virtual bool same(const AstNode* samep) const { + virtual string name() const override { return m_text; } + virtual string verilogKwd() const override { return "$fscanf"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: makes output + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(text()); } + virtual bool same(const AstNode* samep) const override { return text() == static_cast(samep)->text(); } AstNode* exprsp() const { return op1p(); } // op1 = Expressions to output @@ -4106,17 +4153,17 @@ public: setOp2p(fromp); } ASTNODE_NODE_FUNCS(SScanF) - virtual string name() const { return m_text; } - virtual string verilogKwd() const { return "$sscanf"; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: makes output - virtual bool cleanOut() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(text()); } - virtual bool same(const AstNode* samep) const { + virtual string name() const override { return m_text; } + virtual string verilogKwd() const override { return "$sscanf"; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } // SPECIAL: has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: makes output + virtual bool cleanOut() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(text()); } + virtual bool same(const AstNode* samep) const override { return text() == static_cast(samep)->text(); } AstNode* exprsp() const { return op1p(); } // op1 = Expressions to output @@ -4140,14 +4187,14 @@ public: setNOp3p(lsbp); setNOp4p(msbp); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isHeavy() const { return true; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual bool isGateOptimizable() const override { return false; } + virtual bool isHeavy() const override { return true; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return isHex() == static_cast(samep)->isHex(); } bool isHex() const { return m_isHex; } @@ -4164,8 +4211,8 @@ public: AstNode* msbp) : ASTGEN_SUPER(fl, hex, filenamep, memp, lsbp, msbp) {} ASTNODE_NODE_FUNCS(ReadMem); - virtual string verilogKwd() const { return (isHex() ? "$readmemh" : "$readmemb"); } - virtual const char* cFuncPrefixp() const { return "VL_READMEM_"; } + virtual string verilogKwd() const override { return (isHex() ? "$readmemh" : "$readmemb"); } + virtual const char* cFuncPrefixp() const override { return "VL_READMEM_"; } }; class AstWriteMem : public AstNodeReadWriteMem { @@ -4174,8 +4221,8 @@ public: AstNode* msbp) : ASTGEN_SUPER(fl, hex, filenamep, memp, lsbp, msbp) {} ASTNODE_NODE_FUNCS(WriteMem) - virtual string verilogKwd() const { return (isHex() ? "$writememh" : "$writememb"); } - virtual const char* cFuncPrefixp() const { return "VL_WRITEMEM_"; } + virtual string verilogKwd() const override { return (isHex() ? "$writememh" : "$writememb"); } + virtual const char* cFuncPrefixp() const override { return "VL_WRITEMEM_"; } }; class AstSystemT : public AstNodeStmt { @@ -4186,14 +4233,14 @@ public: setOp1p(lhsp); } ASTNODE_NODE_FUNCS(SystemT) - virtual string verilogKwd() const { return "$system"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$system"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* lhsp() const { return op1p(); } }; @@ -4205,17 +4252,17 @@ public: setOp1p(lhsp); } ASTNODE_NODE_FUNCS(SystemF) - virtual string verilogKwd() const { return "$system"; } - virtual string emitVerilog() { return verilogKwd(); } - virtual string emitC() { return "VL_SYSTEM_%nq(%lw, %P)"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual bool isUnlikely() const { return true; } - virtual bool cleanOut() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$system"; } + virtual string emitVerilog() override { return verilogKwd(); } + virtual string emitC() override { return "VL_SYSTEM_%nq(%lw, %P)"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual bool isUnlikely() const override { return true; } + virtual bool cleanOut() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* lhsp() const { return op1p(); } }; @@ -4229,15 +4276,15 @@ public: setOp2p(outp); } ASTNODE_NODE_FUNCS(ValuePlusArgs) - virtual string verilogKwd() const { return "$value$plusargs"; } - virtual string emitVerilog() { return "%f$value$plusargs(%l, %k%r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isHeavy() const { return true; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool cleanOut() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string verilogKwd() const override { return "$value$plusargs"; } + virtual string emitVerilog() override { return "%f$value$plusargs(%l, %k%r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isHeavy() const override { return true; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool cleanOut() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstNode* searchp() const { return op1p(); } // op1 = Search expression void searchp(AstNode* nodep) { setOp1p(nodep); } AstNode* outp() const { return op2p(); } // op2 = Expressions to output @@ -4255,15 +4302,15 @@ public: : ASTGEN_SUPER(fl) , m_text(text) {} ASTNODE_NODE_FUNCS(TestPlusArgs) - virtual string name() const { return m_text; } - virtual string verilogKwd() const { return "$test$plusargs"; } - virtual string emitVerilog() { return verilogKwd(); } - virtual string emitC() { return "VL_VALUEPLUSARGS_%nq(%lw, %P, nullptr)"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool cleanOut() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(text()); } - virtual bool same(const AstNode* samep) const { + virtual string name() const override { return m_text; } + virtual string verilogKwd() const override { return "$test$plusargs"; } + virtual string emitVerilog() override { return verilogKwd(); } + virtual string emitC() override { return "VL_VALUEPLUSARGS_%nq(%lw, %P, nullptr)"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool cleanOut() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(text()); } + virtual bool same(const AstNode* samep) const override { return text() == static_cast(samep)->text(); } string text() const { return m_text; } // * = Text to display @@ -4287,10 +4334,10 @@ public: ASTNODE_NODE_FUNCS(Foreach) AstNode* arrayp() const { return op1p(); } // op1 = array and index vars AstNode* bodysp() const { return op4p(); } // op4 = body of loop - virtual bool isGateOptimizable() const { return false; } - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstRepeat : public AstNodeStmt { @@ -4303,10 +4350,12 @@ public: ASTNODE_NODE_FUNCS(Repeat) AstNode* countp() const { return op2p(); } // op2 = condition to continue AstNode* bodysp() const { return op3p(); } // op3 = body of loop - virtual bool isGateOptimizable() const { return false; } // Not relevant - converted to FOR - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { + return false; + } // Not relevant - converted to FOR + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstWait : public AstNodeStmt { @@ -4337,12 +4386,14 @@ public: void addPrecondsp(AstNode* newp) { addOp1p(newp); } void addBodysp(AstNode* newp) { addOp3p(newp); } void addIncsp(AstNode* newp) { addOp4p(newp); } - virtual bool isGateOptimizable() const { return false; } - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual void addBeforeStmt(AstNode* newp, AstNode* belowp); // Stop statement searchback here - virtual void addNextStmt(AstNode* newp, AstNode* belowp); // Stop statement searchback here + virtual bool isGateOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + // Stop statement searchback here + virtual void addBeforeStmt(AstNode* newp, AstNode* belowp) override; + // Stop statement searchback here + virtual void addNextStmt(AstNode* newp, AstNode* belowp) override; }; class AstBreak : public AstNodeStmt { @@ -4350,9 +4401,9 @@ public: explicit AstBreak(FileLine* fl) : ASTGEN_SUPER(fl) {} ASTNODE_NODE_FUNCS(Break) - virtual string verilogKwd() const { return "break"; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool isBrancher() const { + virtual string verilogKwd() const override { return "break"; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks } }; @@ -4362,9 +4413,9 @@ public: explicit AstContinue(FileLine* fl) : ASTGEN_SUPER(fl) {} ASTNODE_NODE_FUNCS(Continue) - virtual string verilogKwd() const { return "continue"; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool isBrancher() const { + virtual string verilogKwd() const override { return "continue"; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks } }; @@ -4377,9 +4428,9 @@ public: : ASTGEN_SUPER(fl) , m_name(name) {} ASTNODE_NODE_FUNCS(Disable) - virtual string name() const { return m_name; } // * = Block name - void name(const string& flag) { m_name = flag; } - virtual bool isBrancher() const { + virtual string name() const override { return m_name; } // * = Block name + virtual void name(const string& flag) override { m_name = flag; } + virtual bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks } }; @@ -4407,10 +4458,10 @@ public: setNOp1p(lhsp); } ASTNODE_NODE_FUNCS(Return) - virtual string verilogKwd() const { return "return"; } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual string verilogKwd() const override { return "return"; } + virtual V3Hash sameHash() const override { return V3Hash(); } AstNode* lhsp() const { return op1p(); } - virtual bool isBrancher() const { + virtual bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks } }; @@ -4457,13 +4508,13 @@ public: , m_labelNum(0) { addNOp1p(stmtsp); } - virtual const char* broken() const; - virtual void cloneRelink(); + virtual const char* broken() const override; + virtual void cloneRelink() override; ASTNODE_NODE_FUNCS(JumpBlock) - virtual int instrCount() const { return 0; } - virtual bool maybePointedTo() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual int instrCount() const override { return 0; } + virtual bool maybePointedTo() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // op1 = Statements AstNode* stmtsp() const { return op1p(); } // op1 = List of statements void addStmtsp(AstNode* nodep) { addNOp1p(nodep); } @@ -4486,19 +4537,19 @@ public: : ASTGEN_SUPER(fl) , m_blockp(blockp) {} ASTNODE_NODE_FUNCS(JumpLabel) - virtual bool maybePointedTo() const { return true; } - virtual const char* broken() const { + virtual bool maybePointedTo() const override { return true; } + virtual const char* broken() const override { BROKEN_RTN(!blockp()->brokeExistsAbove()); BROKEN_RTN(blockp()->labelp() != this); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_blockp->clonep()) m_blockp = m_blockp->clonep(); } - virtual void dump(std::ostream& str) const; - virtual int instrCount() const { return 0; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual int instrCount() const override { return 0; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return blockp() == static_cast(samep)->blockp(); } AstJumpBlock* blockp() const { return m_blockp; } @@ -4516,21 +4567,21 @@ public: : ASTGEN_SUPER(fl) , m_labelp(labelp) {} ASTNODE_NODE_FUNCS(JumpGo); - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!labelp()->brokeExistsBelow()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_labelp->clonep()) m_labelp = m_labelp->clonep(); } - virtual void dump(std::ostream& str) const; - virtual int instrCount() const { return instrCountBranch(); } - virtual V3Hash sameHash() const { return V3Hash(labelp()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual int instrCount() const override { return instrCountBranch(); } + virtual V3Hash sameHash() const override { return V3Hash(labelp()); } + virtual bool same(const AstNode* samep) const override { return labelp() == static_cast(samep)->labelp(); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isBrancher() const { + virtual bool isGateOptimizable() const override { return false; } + virtual bool isBrancher() const override { return true; // SPECIAL: We don't process code after breaks } AstJumpLabel* labelp() const { return m_labelp; } @@ -4547,21 +4598,21 @@ public: dtypeSetUInt32(); // Always used on, and returns word entities } ASTNODE_NODE_FUNCS(ChangeXor) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstChangeXor(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opChangeXor(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f^ %r)"; } - virtual string emitC() { return "VL_CHANGEXOR_%li(%lw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "^"; } - virtual bool cleanOut() const { return false; } // Lclean && Rclean - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "%k(%l %f^ %r)"; } + virtual string emitC() override { return "VL_CHANGEXOR_%li(%lw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "^"; } + virtual bool cleanOut() const override { return false; } // Lclean && Rclean + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs(); } }; class AstChangeDet : public AstNodeStmt { @@ -4580,11 +4631,11 @@ public: AstNode* lhsp() const { return op1p(); } AstNode* rhsp() const { return op2p(); } bool isClockReq() const { return m_clockReq; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstBegin : public AstNodeBlock { @@ -4603,7 +4654,7 @@ public: m_implied = implied; } ASTNODE_NODE_FUNCS(Begin) - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; // op1p is statements in NodeBlock AstNode* genforp() const { return op2p(); } // op2 = GENFOR, if applicable, // might NOT be a GenFor, as loop unrolling replaces with Begin @@ -4624,7 +4675,7 @@ public: AstFork(FileLine* fl, const string& name, AstNode* stmtsp) : ASTGEN_SUPER(fl, name, stmtsp) {} ASTNODE_NODE_FUNCS(Fork) - virtual void dump(std::ostream& str) const; + virtual void dump(std::ostream& str) const override; VJoinType joinType() const { return m_joinType; } void joinType(const VJoinType& flag) { m_joinType = flag; } }; @@ -4641,9 +4692,9 @@ public: AstNode* exprp() const { return op1p(); } // op1 = LHS expression to compare with // op2 = RHS, possibly a list of expr or AstInsideRange AstNode* itemsp() const { return op2p(); } - virtual string emitVerilog() { return "%l inside { %r }"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } // NA + virtual string emitVerilog() override { return "%l inside { %r }"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } // NA }; class AstInsideRange : public AstNodeMath { @@ -4656,9 +4707,9 @@ public: ASTNODE_NODE_FUNCS(InsideRange) AstNode* lhsp() const { return op1p(); } // op1 = LHS AstNode* rhsp() const { return op2p(); } // op2 = RHS - virtual string emitVerilog() { return "[%l:%r]"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } // NA + virtual string emitVerilog() override { return "[%l:%r]"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } // NA // Create AstAnd(AstGte(...), AstLte(...)) AstNode* newAndFromInside(AstNode* exprp, AstNode* lhsp, AstNode* rhsp); }; @@ -4674,9 +4725,9 @@ public: addOp1p(valuep); } ASTNODE_NODE_FUNCS(InitItem) - virtual bool maybePointedTo() const { return true; } - virtual bool hasDType() const { return false; } // See valuep()'s dtype instead - virtual V3Hash sameHash() const { return V3Hash(); } + virtual bool maybePointedTo() const override { return true; } + virtual bool hasDType() const override { return false; } // See valuep()'s dtype instead + virtual V3Hash sameHash() const override { return V3Hash(); } AstNode* valuep() const { return op1p(); } // op1 = Value void valuep(AstNode* nodep) { addOp1p(nodep); } }; @@ -4700,22 +4751,22 @@ public: addNOp1p(defaultp); } ASTNODE_NODE_FUNCS(InitArray) - virtual void dump(std::ostream& str) const; - virtual const char* broken() const { + virtual void dump(std::ostream& str) const override; + virtual const char* broken() const override { for (KeyItemMap::const_iterator it = m_map.begin(); it != m_map.end(); ++it) { BROKEN_RTN(!VN_IS(it->second, InitItem)); BROKEN_RTN(!it->second->brokeExists()); } return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { for (KeyItemMap::iterator it = m_map.begin(); it != m_map.end(); ++it) { if (it->second->clonep()) it->second = it->second->clonep(); } } - virtual bool hasDType() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual bool hasDType() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { // Only works if exact same children, instead should override comparison // of children list, and instead use map-vs-map key/value compare return m_map == static_cast(samep)->m_map; @@ -4763,13 +4814,11 @@ public: AstNew(FileLine* fl, AstNode* pinsp) : ASTGEN_SUPER(fl, false, "new", pinsp) {} ASTNODE_NODE_FUNCS(New) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual string emitVerilog() { return "new"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } + virtual V3Hash sameHash() const override { return V3Hash(); } virtual bool cleanOut() const { return true; } - virtual bool same(const AstNode* samep) const { return true; } - virtual bool hasDType() const { return true; } - virtual int instrCount() const { return widthInstrs(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual bool hasDType() const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } }; class AstNewCopy : public AstNodeMath { @@ -4783,12 +4832,12 @@ public: setNOp1p(rhsp); } ASTNODE_NODE_FUNCS(NewCopy) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual string emitVerilog() { return "new"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool same(const AstNode* samep) const { return true; } - virtual int instrCount() const { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual string emitVerilog() override { return "new"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool same(const AstNode* samep) const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } AstNode* rhsp() const { return op1p(); } }; @@ -4804,12 +4853,12 @@ public: setNOp2p(rhsp); } ASTNODE_NODE_FUNCS(NewDynamic) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual string emitVerilog() { return "new"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool same(const AstNode* samep) const { return true; } - virtual int instrCount() const { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual string emitVerilog() override { return "new"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool same(const AstNode* samep) const override { return true; } + virtual int instrCount() const override { return widthInstrs(); } AstNode* sizep() const { return op1p(); } AstNode* rhsp() const { return op2p(); } }; @@ -4826,9 +4875,9 @@ public: } ASTNODE_NODE_FUNCS(Pragma) AstPragmaType pragType() const { return m_pragType; } // *=type of the pragma - virtual V3Hash sameHash() const { return V3Hash(pragType()); } - virtual bool isPredictOptimizable() const { return false; } - virtual bool same(const AstNode* samep) const { + virtual V3Hash sameHash() const override { return V3Hash(pragType()); } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool same(const AstNode* samep) const override { return pragType() == static_cast(samep)->pragType(); } }; @@ -4841,16 +4890,16 @@ public: AstPrintTimeScale(FileLine* fl) : ASTGEN_SUPER(fl) {} ASTNODE_NODE_FUNCS(PrintTimeScale) - virtual void name(const string& name) { m_name = name; } - virtual string name() const { return m_name; } // * = Var name - virtual void dump(std::ostream& str) const; - virtual string verilogKwd() const { return "$printtimescale"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual void name(const string& name) override { m_name = name; } + virtual string name() const override { return m_name; } // * = Var name + virtual void dump(std::ostream& str) const override; + virtual string verilogKwd() const override { return "$printtimescale"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(); } void timeunit(const VTimescale& flag) { m_timeunit = flag; } VTimescale timeunit() const { return m_timeunit; } }; @@ -4860,14 +4909,18 @@ public: AstStop(FileLine* fl, bool maybe) : ASTGEN_SUPER(fl) {} ASTNODE_NODE_FUNCS(Stop) - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: $display makes output - virtual bool isUnlikely() const { return true; } - virtual int instrCount() const { return 0; } // Rarely executes - virtual V3Hash sameHash() const { return V3Hash(fileline()->lineno()); } - virtual bool same(const AstNode* samep) const { return fileline() == samep->fileline(); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: $display makes output + virtual bool isUnlikely() const override { return true; } + virtual int instrCount() const override { return 0; } // Rarely executes + virtual V3Hash sameHash() const override { return V3Hash(fileline()->lineno()); } + virtual bool same(const AstNode* samep) const override { + return fileline() == samep->fileline(); + } }; class AstFinish : public AstNodeStmt { @@ -4875,14 +4928,18 @@ public: explicit AstFinish(FileLine* fl) : ASTGEN_SUPER(fl) {} ASTNODE_NODE_FUNCS(Finish) - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering - virtual bool isOutputter() const { return true; } // SPECIAL: $display makes output - virtual bool isUnlikely() const { return true; } - virtual int instrCount() const { return 0; } // Rarely executes - virtual V3Hash sameHash() const { return V3Hash(fileline()->lineno()); } - virtual bool same(const AstNode* samep) const { return fileline() == samep->fileline(); } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering + virtual bool isOutputter() const override { return true; } // SPECIAL: $display makes output + virtual bool isUnlikely() const override { return true; } + virtual int instrCount() const override { return 0; } // Rarely executes + virtual V3Hash sameHash() const override { return V3Hash(fileline()->lineno()); } + virtual bool same(const AstNode* samep) const override { + return fileline() == samep->fileline(); + } }; class AstNullCheck : public AstNodeUniop { @@ -4894,16 +4951,18 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(NullCheck) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual int instrCount() const { return 1; } // Rarely executes - virtual string emitVerilog() { return "%l"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(fileline()->lineno()); } - virtual bool same(const AstNode* samep) const { return fileline() == samep->fileline(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } + virtual int instrCount() const override { return 1; } // Rarely executes + virtual string emitVerilog() override { return "%l"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(fileline()->lineno()); } + virtual bool same(const AstNode* samep) const override { + return fileline() == samep->fileline(); + } }; class AstTimingControl : public AstNodeStmt { @@ -4915,13 +4974,13 @@ public: setNOp2p(stmtsp); } ASTNODE_NODE_FUNCS(TimingControl) - virtual string verilogKwd() const { return "@(%l) %r"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return false; } - virtual int instrCount() const { return 0; } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual string verilogKwd() const override { return "@(%l) %r"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return false; } + virtual int instrCount() const override { return 0; } + virtual V3Hash sameHash() const override { return V3Hash(); } AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); } AstNode* stmtsp() const { return op2p(); } }; @@ -4938,13 +4997,13 @@ public: setOp4p(widthp); } ASTNODE_NODE_FUNCS(TimeFormat) - virtual string verilogKwd() const { return "$timeformat"; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(); } + virtual string verilogKwd() const override { return "$timeformat"; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(); } AstNode* unitsp() const { return op1p(); } AstNode* precisionp() const { return op2p(); } AstNode* suffixp() const { return op3p(); } @@ -4986,12 +5045,12 @@ public: dtypeFrom(valuep); addNOp1p(valuep); } - virtual int instrCount() const { return 100; } // Large... + virtual int instrCount() const override { return 100; } // Large... ASTNODE_NODE_FUNCS(TraceDecl) - virtual string name() const { return m_showname; } - virtual bool maybePointedTo() const { return true; } - virtual bool hasDType() const { return true; } - virtual bool same(const AstNode* samep) const { return false; } + virtual string name() const override { return m_showname; } + virtual bool maybePointedTo() const override { return true; } + virtual bool hasDType() const override { return true; } + virtual bool same(const AstNode* samep) const override { return false; } string showname() const { return m_showname; } // * = Var name // Details on what we're tracing uint32_t code() const { return m_code; } @@ -5024,23 +5083,23 @@ public: addOp2p(declp->valuep()->cloneTree(true)); } ASTNODE_NODE_FUNCS(TraceInc) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!declp()->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_declp->clonep()) m_declp = m_declp->clonep(); } - virtual void dump(std::ostream& str) const; - virtual int instrCount() const { return 10 + 2 * instrCountLd(); } - virtual bool hasDType() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(declp()); } - virtual bool same(const AstNode* samep) const { + virtual void dump(std::ostream& str) const override; + virtual int instrCount() const override { return 10 + 2 * instrCountLd(); } + virtual bool hasDType() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(declp()); } + virtual bool same(const AstNode* samep) const override { return declp() == static_cast(samep)->declp(); } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isOutputter() const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isOutputter() const override { return true; } // but isPure() true // op1 = Statements before the value AstNode* precondsp() const { return op1p(); } @@ -5066,13 +5125,13 @@ public: m_sensesp = sensesp; } ASTNODE_NODE_FUNCS(Active) - virtual void dump(std::ostream& str = std::cout) const; - virtual string name() const { return m_name; } - virtual const char* broken() const { + virtual void dump(std::ostream& str = std::cout) const override; + virtual string name() const override { return m_name; } + virtual const char* broken() const override { BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists()); return nullptr; } - virtual void cloneRelink() { + virtual void cloneRelink() override { if (m_sensesp->clonep()) { m_sensesp = m_sensesp->clonep(); UASSERT(m_sensesp, "Bad clone cross link: " << this); @@ -5109,8 +5168,8 @@ public: AstNode* fromp() const { return op1p(); } AstNode* dimp() const { return op2p(); } AstAttrType attrType() const { return m_attrType; } - virtual V3Hash sameHash() const { return V3Hash(m_attrType); } - virtual void dump(std::ostream& str = std::cout) const; + virtual V3Hash sameHash() const override { return V3Hash(m_attrType); } + virtual void dump(std::ostream& str = std::cout) const override; }; class AstScopeName : public AstNodeMath { @@ -5129,13 +5188,13 @@ public: dtypeSetUInt64(); } ASTNODE_NODE_FUNCS(ScopeName) - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return m_dpiExport == static_cast(samep)->m_dpiExport; } - virtual string emitVerilog() { return ""; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual string emitVerilog() override { return ""; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } AstText* scopeAttrp() const { return VN_CAST(op1p(), Text); } void scopeAttrp(AstNode* nodep) { addOp1p(nodep); } AstText* scopeEntrp() const { return VN_CAST(op2p(), Text); } @@ -5175,7 +5234,7 @@ public: : ASTGEN_SUPER(fl) , m_text(text) {} ASTNODE_NODE_FUNCS(UdpTableLine) - virtual string name() const { return m_text; } + virtual string name() const override { return m_text; } string text() const { return m_text; } }; @@ -5196,16 +5255,16 @@ public: : ASTGEN_SUPER(fl) , m_reset(false) {} ASTNODE_NODE_FUNCS(Rand) - virtual string emitVerilog() { return "%f$random"; } - virtual string emitC() { + virtual string emitVerilog() override { return "%f$random"; } + virtual string emitC() override { return (m_reset ? "VL_RAND_RESET_%nq(%nw, %P)" : "VL_RANDOM_%nq(%nw, %P)"); } - virtual bool cleanOut() const { return true; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool cleanOut() const override { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstTime : public AstNodeTermop { @@ -5217,15 +5276,15 @@ public: dtypeSetUInt64(); } ASTNODE_NODE_FUNCS(Time) - virtual string emitVerilog() { return "%f$time"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual int instrCount() const { return instrCountTime(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual void dump(std::ostream& str = std::cout) const; + virtual string emitVerilog() override { return "%f$time"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountTime(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual void dump(std::ostream& str = std::cout) const override; void timeunit(const VTimescale& flag) { m_timeunit = flag; } VTimescale timeunit() const { return m_timeunit; } }; @@ -5239,15 +5298,15 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(TimeD) - virtual string emitVerilog() { return "%f$realtime"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual int instrCount() const { return instrCountTime(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } - virtual void dump(std::ostream& str = std::cout) const; + virtual string emitVerilog() override { return "%f$realtime"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountTime(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } + virtual void dump(std::ostream& str = std::cout) const override; void timeunit(const VTimescale& flag) { m_timeunit = flag; } VTimescale timeunit() const { return m_timeunit; } }; @@ -5261,18 +5320,18 @@ public: addNOp1p(exprsp); } ASTNODE_NODE_FUNCS(UCFunc) - virtual bool cleanOut() const { return false; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } AstNode* bodysp() const { return op1p(); } // op1 = expressions to print - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } - virtual bool isGateOptimizable() const { return false; } - virtual bool isSubstOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual int instrCount() const { return instrCountPli(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isSubstOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual int instrCount() const override { return instrCountPli(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; //====================================================================== @@ -5285,13 +5344,13 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Negate) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegate(lhs); } - virtual string emitVerilog() { return "%f(- %l)"; } - virtual string emitC() { return "VL_NEGATE_%lq(%lW, %P, %li)"; } - virtual string emitSimpleOperator() { return "-"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegate(lhs); } + virtual string emitVerilog() override { return "%f(- %l)"; } + virtual string emitC() override { return "VL_NEGATE_%lq(%lW, %P, %li)"; } + virtual string emitSimpleOperator() override { return "-"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } }; class AstNegateD : public AstNodeUniop { public: @@ -5300,15 +5359,15 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(NegateD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNegateD(lhs); } - virtual string emitVerilog() { return "%f(- %l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "-"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNegateD(lhs); } + virtual string emitVerilog() override { return "%f(- %l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "-"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstRedAnd : public AstNodeUniop { public: @@ -5317,12 +5376,12 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(RedAnd) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedAnd(lhs); } - virtual string emitVerilog() { return "%f(& %l)"; } - virtual string emitC() { return "VL_REDAND_%nq%lq(%nw,%lw, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedAnd(lhs); } + virtual string emitVerilog() override { return "%f(& %l)"; } + virtual string emitC() override { return "VL_REDAND_%nq%lq(%nw,%lw, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstRedOr : public AstNodeUniop { public: @@ -5331,12 +5390,12 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(RedOr) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedOr(lhs); } - virtual string emitVerilog() { return "%f(| %l)"; } - virtual string emitC() { return "VL_REDOR_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedOr(lhs); } + virtual string emitVerilog() override { return "%f(| %l)"; } + virtual string emitC() override { return "VL_REDOR_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstRedXor : public AstNodeUniop { public: @@ -5345,16 +5404,16 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(RedXor) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedXor(lhs); } - virtual string emitVerilog() { return "%f(^ %l)"; } - virtual string emitC() { return "VL_REDXOR_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedXor(lhs); } + virtual string emitVerilog() override { return "%f(^ %l)"; } + virtual string emitC() override { return "VL_REDXOR_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { int w = lhsp()->width(); return (w != 1 && w != 2 && w != 4 && w != 8 && w != 16); } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return 1 + V3Number::log2b(width()); } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return 1 + V3Number::log2b(width()); } }; class AstRedXnor : public AstNodeUniop { // AstRedXnors are replaced with AstRedXors in V3Const. @@ -5364,16 +5423,16 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(RedXnor) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRedXnor(lhs); } - virtual string emitVerilog() { return "%f(~^ %l)"; } - virtual string emitC() { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRedXnor(lhs); } + virtual string emitVerilog() override { return "%f(~^ %l)"; } + virtual string emitC() override { v3fatalSrc("REDXNOR should have became REDXOR"); return ""; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return 1 + V3Number::log2b(width()); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return 1 + V3Number::log2b(width()); } }; class AstLenN : public AstNodeUniop { @@ -5384,12 +5443,12 @@ public: dtypeSetSigned32(); } ASTNODE_NODE_FUNCS(LenN) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opLenN(lhs); } - virtual string emitVerilog() { return "%f(%l)"; } - virtual string emitC() { return "VL_LEN_IN(%li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLenN(lhs); } + virtual string emitVerilog() override { return "%f(%l)"; } + virtual string emitC() override { return "VL_LEN_IN(%li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstLogNot : public AstNodeUniop { public: @@ -5398,13 +5457,13 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LogNot) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opLogNot(lhs); } - virtual string emitVerilog() { return "%f(! %l)"; } - virtual string emitC() { return "VL_LOGNOT_%nq%lq(%nw,%lw, %P, %li)"; } - virtual string emitSimpleOperator() { return "!"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opLogNot(lhs); } + virtual string emitVerilog() override { return "%f(! %l)"; } + virtual string emitC() override { return "VL_LOGNOT_%nq%lq(%nw,%lw, %P, %li)"; } + virtual string emitSimpleOperator() override { return "!"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstNot : public AstNodeUniop { public: @@ -5413,13 +5472,13 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Not) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opNot(lhs); } - virtual string emitVerilog() { return "%f(~ %l)"; } - virtual string emitC() { return "VL_NOT_%lq(%lW, %P, %li)"; } - virtual string emitSimpleOperator() { return "~"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opNot(lhs); } + virtual string emitVerilog() override { return "%f(~ %l)"; } + virtual string emitC() override { return "VL_NOT_%lq(%lW, %P, %li)"; } + virtual string emitSimpleOperator() override { return "~"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } }; class AstExtend : public AstNodeUniop { // Expand a value into a wider entity by 0 extension. Width is implied from nodep->width() @@ -5431,15 +5490,15 @@ public: dtypeSetLogicSized(width, VSigning::UNSIGNED); } ASTNODE_NODE_FUNCS(Extend) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); } - virtual string emitVerilog() { return "%l"; } - virtual string emitC() { return "VL_EXTEND_%nq%lq(%nw,%lw, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); } + virtual string emitVerilog() override { return "%l"; } + virtual string emitC() override { return "VL_EXTEND_%nq%lq(%nw,%lw, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; // Because the EXTEND operator self-casts } - virtual int instrCount() const { return 0; } + virtual int instrCount() const override { return 0; } }; class AstExtendS : public AstNodeUniop { // Expand a value into a wider entity by sign extension. Width is implied from nodep->width() @@ -5452,18 +5511,18 @@ public: dtypeSetLogicSized(width, VSigning::UNSIGNED); } ASTNODE_NODE_FUNCS(ExtendS) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opExtendS(lhs, lhsp()->widthMinV()); } - virtual string emitVerilog() { return "%l"; } - virtual string emitC() { return "VL_EXTENDS_%nq%lq(%nw,%lw, %P, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { + virtual string emitVerilog() override { return "%l"; } + virtual string emitC() override { return "VL_EXTENDS_%nq%lq(%nw,%lw, %P, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; // Because the EXTEND operator self-casts } - virtual int instrCount() const { return 0; } - virtual bool signedFlavor() const { return true; } + virtual int instrCount() const override { return 0; } + virtual bool signedFlavor() const override { return true; } }; class AstSigned : public AstNodeUniop { // $signed(lhs) @@ -5474,16 +5533,16 @@ public: "not coded to create after dtypes resolved"); } ASTNODE_NODE_FUNCS(Signed) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); out.isSigned(false); } - virtual string emitVerilog() { return "%f$signed(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } // Eliminated before matters - virtual bool sizeMattersLhs() const { return true; } // Eliminated before matters - virtual int instrCount() const { return 0; } + virtual string emitVerilog() override { return "%f$signed(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } // Eliminated before matters + virtual bool sizeMattersLhs() const override { return true; } // Eliminated before matters + virtual int instrCount() const override { return 0; } }; class AstUnsigned : public AstNodeUniop { // $unsigned(lhs) @@ -5494,16 +5553,16 @@ public: "not coded to create after dtypes resolved"); } ASTNODE_NODE_FUNCS(Unsigned) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); out.isSigned(false); } - virtual string emitVerilog() { return "%f$unsigned(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } // Eliminated before matters - virtual bool sizeMattersLhs() const { return true; } // Eliminated before matters - virtual int instrCount() const { return 0; } + virtual string emitVerilog() override { return "%f$unsigned(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } // Eliminated before matters + virtual bool sizeMattersLhs() const override { return true; } // Eliminated before matters + virtual int instrCount() const override { return 0; } }; class AstRToIS : public AstNodeUniop { // $rtoi(lhs) @@ -5513,13 +5572,13 @@ public: dtypeSetSigned32(); } ASTNODE_NODE_FUNCS(RToIS) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRToIS(lhs); } - virtual string emitVerilog() { return "%f$rtoi(%l)"; } - virtual string emitC() { return "VL_RTOI_I_D(%li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } // Eliminated before matters - virtual bool sizeMattersLhs() const { return false; } // Eliminated before matters - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opRToIS(lhs); } + virtual string emitVerilog() override { return "%f$rtoi(%l)"; } + virtual string emitC() override { return "VL_RTOI_I_D(%li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } // Eliminated before matters + virtual bool sizeMattersLhs() const override { return false; } // Eliminated before matters + virtual int instrCount() const override { return instrCountDouble(); } }; class AstRToIRoundS : public AstNodeUniop { // Convert real to integer, with arbitrary sized output (not just "integer" format) @@ -5529,13 +5588,15 @@ public: dtypeSetSigned32(); } ASTNODE_NODE_FUNCS(RToIRoundS) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRToIRoundS(lhs); } - virtual string emitVerilog() { return "%f$rtoi_rounded(%l)"; } - virtual string emitC() { return "VL_RTOIROUND_%nq_D(%nw, %P, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opRToIRoundS(lhs); + } + virtual string emitVerilog() override { return "%f$rtoi_rounded(%l)"; } + virtual string emitC() override { return "VL_RTOIROUND_%nq_D(%nw, %P, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } }; class AstIToRD : public AstNodeUniop { // $itor where lhs is unsigned @@ -5545,13 +5606,13 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(IToRD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opIToRD(lhs); } - virtual string emitVerilog() { return "%f$itor(%l)"; } - virtual string emitC() { return "VL_ITOR_D_%lq(%lw, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opIToRD(lhs); } + virtual string emitVerilog() override { return "%f$itor(%l)"; } + virtual string emitC() override { return "VL_ITOR_D_%lq(%lw, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } }; class AstISToRD : public AstNodeUniop { // $itor where lhs is signed @@ -5561,14 +5622,14 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(ISToRD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opISToRD(lhs); } - virtual string emitVerilog() { return "%f$itor($signed(%l))"; } - virtual string emitC() { return "VL_ISTOR_D_%lq(%lw, %li)"; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opISToRD(lhs); } + virtual string emitVerilog() override { return "%f$itor($signed(%l))"; } + virtual string emitC() override { return "VL_ISTOR_D_%lq(%lw, %li)"; } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } }; class AstRealToBits : public AstNodeUniop { public: @@ -5577,13 +5638,15 @@ public: dtypeSetUInt64(); } ASTNODE_NODE_FUNCS(RealToBits) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opRealToBits(lhs); } - virtual string emitVerilog() { return "%f$realtobits(%l)"; } - virtual string emitC() { return "VL_CVT_Q_D(%li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } // Eliminated before matters - virtual bool sizeMattersLhs() const { return false; } // Eliminated before matters - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opRealToBits(lhs); + } + virtual string emitVerilog() override { return "%f$realtobits(%l)"; } + virtual string emitC() override { return "VL_CVT_Q_D(%li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } // Eliminated before matters + virtual bool sizeMattersLhs() const override { return false; } // Eliminated before matters + virtual int instrCount() const override { return instrCountDouble(); } }; class AstBitsToRealD : public AstNodeUniop { public: @@ -5592,13 +5655,15 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(BitsToRealD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opBitsToRealD(lhs); } - virtual string emitVerilog() { return "%f$bitstoreal(%l)"; } - virtual string emitC() { return "VL_CVT_D_Q(%li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } // Eliminated before matters - virtual bool sizeMattersLhs() const { return false; } // Eliminated before matters - virtual int instrCount() const { return instrCountDouble(); } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opBitsToRealD(lhs); + } + virtual string emitVerilog() override { return "%f$bitstoreal(%l)"; } + virtual string emitC() override { return "VL_CVT_D_Q(%li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } // Eliminated before matters + virtual bool sizeMattersLhs() const override { return false; } // Eliminated before matters + virtual int instrCount() const override { return instrCountDouble(); } }; class AstCLog2 : public AstNodeUniop { @@ -5606,13 +5671,13 @@ public: AstCLog2(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(CLog2) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opCLog2(lhs); } - virtual string emitVerilog() { return "%f$clog2(%l)"; } - virtual string emitC() { return "VL_CLOG2_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 16; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opCLog2(lhs); } + virtual string emitVerilog() override { return "%f$clog2(%l)"; } + virtual string emitC() override { return "VL_CLOG2_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 16; } }; class AstCountBits : public AstNodeQuadop { // Number of bits set in vector @@ -5625,21 +5690,21 @@ public: : ASTGEN_SUPER(fl, exprp, ctrl1p, ctrl2p, ctrl3p) {} ASTNODE_NODE_FUNCS(CountBits) virtual void numberOperate(V3Number& out, const V3Number& expr, const V3Number& ctrl1, - const V3Number& ctrl2, const V3Number& ctrl3) { + const V3Number& ctrl2, const V3Number& ctrl3) override { out.opCountBits(expr, ctrl1, ctrl2, ctrl3); } - virtual string emitVerilog() { return "%f$countbits(%l, %r, %f, %o)"; } - virtual string emitC() { return ""; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool cleanThs() const { return true; } - virtual bool cleanFhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual bool sizeMattersFhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 16; } + virtual string emitVerilog() override { return "%f$countbits(%l, %r, %f, %o)"; } + virtual string emitC() override { return ""; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool cleanThs() const override { return true; } + virtual bool cleanFhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual bool sizeMattersFhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 16; } }; class AstCountOnes : public AstNodeUniop { // Number of bits set in vector @@ -5647,13 +5712,15 @@ public: AstCountOnes(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(CountOnes) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opCountOnes(lhs); } - virtual string emitVerilog() { return "%f$countones(%l)"; } - virtual string emitC() { return "VL_COUNTONES_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 16; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opCountOnes(lhs); + } + virtual string emitVerilog() override { return "%f$countones(%l)"; } + virtual string emitC() override { return "VL_COUNTONES_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 16; } }; class AstIsUnknown : public AstNodeUniop { // True if any unknown bits @@ -5663,12 +5730,14 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(IsUnknown) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opIsUnknown(lhs); } - virtual string emitVerilog() { return "%f$isunknown(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opIsUnknown(lhs); + } + virtual string emitVerilog() override { return "%f$isunknown(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstIsUnbounded : public AstNodeUniop { // True if is unmbounded ($) @@ -5678,15 +5747,15 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(IsUnbounded) - virtual void numberOperate(V3Number& out, const V3Number&) { + virtual void numberOperate(V3Number& out, const V3Number&) override { // Any constant isn't unbounded out.setZero(); } - virtual string emitVerilog() { return "%f$isunbounded(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } + virtual string emitVerilog() override { return "%f$isunbounded(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstOneHot : public AstNodeUniop { // True if only single bit set in vector @@ -5696,13 +5765,13 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(OneHot) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opOneHot(lhs); } - virtual string emitVerilog() { return "%f$onehot(%l)"; } - virtual string emitC() { return "VL_ONEHOT_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 4; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot(lhs); } + virtual string emitVerilog() override { return "%f$onehot(%l)"; } + virtual string emitC() override { return "VL_ONEHOT_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 4; } }; class AstOneHot0 : public AstNodeUniop { // True if only single bit, or no bits set in vector @@ -5712,13 +5781,13 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(OneHot0) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opOneHot0(lhs); } - virtual string emitVerilog() { return "%f$onehot0(%l)"; } - virtual string emitC() { return "VL_ONEHOT0_%lq(%lW, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 3; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opOneHot0(lhs); } + virtual string emitVerilog() override { return "%f$onehot0(%l)"; } + virtual string emitC() override { return "VL_ONEHOT0_%lq(%lW, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 3; } }; class AstCast : public AstNode { @@ -5731,14 +5800,13 @@ public: dtypeFrom(dtp); } ASTNODE_NODE_FUNCS(Cast) - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } virtual string emitVerilog() { return "((%d)'(%l))"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); } virtual bool cleanLhs() const { return true; } virtual bool sizeMattersLhs() const { return false; } AstNode* lhsp() const { return op1p(); } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } AstNodeDType* childDTypep() const { return VN_CAST(op2p(), NodeDType); } virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } }; @@ -5748,22 +5816,22 @@ public: AstCastDynamic(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(CastDynamic) - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstCastDynamic(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f$cast(%r, %l)"; } + virtual string emitVerilog() override { return "%f$cast(%r, %l)"; } // Non-existent filehandle returns EOF - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 20; } - virtual bool isPure() const { return true; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 20; } + virtual bool isPure() const override { return true; } }; class AstCastParse : public AstNode { @@ -5795,7 +5863,6 @@ public: ASTNODE_NODE_FUNCS(CastSize) // No hasDType because widthing removes this node before the hasDType check virtual string emitVerilog() { return "((%r)'(%l))"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } virtual bool cleanOut() const { V3ERROR_NA_RETURN(true); } virtual bool cleanLhs() const { return true; } virtual bool sizeMattersLhs() const { return false; } @@ -5823,17 +5890,17 @@ public: m_size = width(); } ASTNODE_NODE_FUNCS(CCast) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAssign(lhs); } - virtual string emitVerilog() { return "%f$_CAST(%l)"; } - virtual string emitC() { return "VL_CAST_%nq%lq(%nw,%lw, %P, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } // Special cased in V3Cast - virtual V3Hash sameHash() const { return V3Hash(size()); } - virtual bool same(const AstNode* samep) const { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.opAssign(lhs); } + virtual string emitVerilog() override { return "%f$_CAST(%l)"; } + virtual string emitC() override { return "VL_CAST_%nq%lq(%nw,%lw, %P, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } // Special cased in V3Cast + virtual V3Hash sameHash() const override { return V3Hash(size()); } + virtual bool same(const AstNode* samep) const override { return size() == static_cast(samep)->size(); } - virtual void dump(std::ostream& str = std::cout) const; + virtual void dump(std::ostream& str = std::cout) const override; // int size() const { return m_size; } }; @@ -5846,14 +5913,14 @@ public: dtypeSetString(); } ASTNODE_NODE_FUNCS(CvtPackString) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual string emitVerilog() { return "%f$_CAST(%l)"; } - virtual string emitC() { return "VL_CVT_PACK_STR_N%lq(%lW, %li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } + virtual string emitVerilog() override { return "%f$_CAST(%l)"; } + virtual string emitC() override { return "VL_CVT_PACK_STR_N%lq(%lW, %li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstFEof : public AstNodeUniop { @@ -5861,14 +5928,16 @@ public: AstFEof(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(FEof) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual string emitVerilog() { return "%f$feof(%l)"; } - virtual string emitC() { return "(%li ? feof(VL_CVT_I_FP(%li)) : true)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 16; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } + virtual string emitVerilog() override { return "%f$feof(%l)"; } + virtual string emitC() override { return "(%li ? feof(VL_CVT_I_FP(%li)) : true)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 16; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering AstNode* filep() const { return lhsp(); } }; @@ -5880,20 +5949,21 @@ public: setOp2p(strp); } ASTNODE_NODE_FUNCS(FError) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual string emitVerilog() { return "%f$ferror(%l, %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return true; } + virtual string emitVerilog() override { return "%f$ferror(%l, %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return true; } virtual bool cleanLhs() const { return true; } virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 64; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering + virtual int instrCount() const override { return widthInstrs() * 64; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering void filep(AstNode* nodep) { setOp1p(nodep); } AstNode* filep() const { return op1p(); } void strp(AstNode* nodep) { setOp2p(nodep); } AstNode* strp() const { return op2p(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstFGetC : public AstNodeUniop { @@ -5901,15 +5971,17 @@ public: AstFGetC(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(FGetC) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual string emitVerilog() { return "%f$fgetc(%l)"; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } + virtual string emitVerilog() override { return "%f$fgetc(%l)"; } // Non-existent filehandle returns EOF - virtual string emitC() { return "(%li ? fgetc(VL_CVT_I_FP(%li)) : -1)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 64; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering + virtual string emitC() override { return "(%li ? fgetc(VL_CVT_I_FP(%li)) : -1)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 64; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering AstNode* filep() const { return lhsp(); } }; @@ -5918,22 +5990,26 @@ public: AstFUngetC(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(FUngetC) - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstFUngetC(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f$ungetc(%r, %l)"; } + virtual string emitVerilog() override { return "%f$ungetc(%r, %l)"; } // Non-existent filehandle returns EOF - virtual string emitC() { return "(%li ? (ungetc(%ri, VL_CVT_I_FP(%li)) >= 0 ? 0 : -1) : -1)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 64; } - virtual bool isPure() const { return false; } // SPECIAL: $display has 'visual' ordering + virtual string emitC() override { + return "(%li ? (ungetc(%ri, VL_CVT_I_FP(%li)) >= 0 ? 0 : -1) : -1)"; + } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 64; } + virtual bool isPure() const override { + return false; + } // SPECIAL: $display has 'visual' ordering AstNode* filep() const { return lhsp(); } AstNode* charp() const { return rhsp(); } }; @@ -5945,11 +6021,11 @@ public: dtypeSetDouble(); } ASTNODE_BASE_FUNCS(NodeSystemUniop) - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual int instrCount() const { return instrCountDoubleTrig(); } - virtual bool doubleFlavor() const { return true; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual int instrCount() const override { return instrCountDoubleTrig(); } + virtual bool doubleFlavor() const override { return true; } }; class AstLogD : public AstNodeSystemUniop { @@ -5957,22 +6033,22 @@ public: AstLogD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(LogD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(log(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$ln(%l)"; } - virtual string emitC() { return "log(%li)"; } + virtual string emitVerilog() override { return "%f$ln(%l)"; } + virtual string emitC() override { return "log(%li)"; } }; class AstLog10D : public AstNodeSystemUniop { public: AstLog10D(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(Log10D) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(log10(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$log10(%l)"; } - virtual string emitC() { return "log10(%li)"; } + virtual string emitVerilog() override { return "%f$log10(%l)"; } + virtual string emitC() override { return "log10(%li)"; } }; class AstExpD : public AstNodeSystemUniop { @@ -5980,11 +6056,11 @@ public: AstExpD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(ExpD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(exp(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$exp(%l)"; } - virtual string emitC() { return "exp(%li)"; } + virtual string emitVerilog() override { return "%f$exp(%l)"; } + virtual string emitC() override { return "exp(%li)"; } }; class AstSqrtD : public AstNodeSystemUniop { @@ -5992,11 +6068,11 @@ public: AstSqrtD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(SqrtD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(sqrt(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$sqrt(%l)"; } - virtual string emitC() { return "sqrt(%li)"; } + virtual string emitVerilog() override { return "%f$sqrt(%l)"; } + virtual string emitC() override { return "sqrt(%li)"; } }; class AstFloorD : public AstNodeSystemUniop { @@ -6004,11 +6080,11 @@ public: AstFloorD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(FloorD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(floor(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$floor(%l)"; } - virtual string emitC() { return "floor(%li)"; } + virtual string emitVerilog() override { return "%f$floor(%l)"; } + virtual string emitC() override { return "floor(%li)"; } }; class AstCeilD : public AstNodeSystemUniop { @@ -6016,11 +6092,11 @@ public: AstCeilD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(CeilD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(ceil(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$ceil(%l)"; } - virtual string emitC() { return "ceil(%li)"; } + virtual string emitVerilog() override { return "%f$ceil(%l)"; } + virtual string emitC() override { return "ceil(%li)"; } }; class AstSinD : public AstNodeSystemUniop { @@ -6028,11 +6104,11 @@ public: AstSinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(SinD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(sin(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$sin(%l)"; } - virtual string emitC() { return "sin(%li)"; } + virtual string emitVerilog() override { return "%f$sin(%l)"; } + virtual string emitC() override { return "sin(%li)"; } }; class AstCosD : public AstNodeSystemUniop { @@ -6040,11 +6116,11 @@ public: AstCosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(CosD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(cos(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$cos(%l)"; } - virtual string emitC() { return "cos(%li)"; } + virtual string emitVerilog() override { return "%f$cos(%l)"; } + virtual string emitC() override { return "cos(%li)"; } }; class AstTanD : public AstNodeSystemUniop { @@ -6052,11 +6128,11 @@ public: AstTanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(TanD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(tan(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$tan(%l)"; } - virtual string emitC() { return "tan(%li)"; } + virtual string emitVerilog() override { return "%f$tan(%l)"; } + virtual string emitC() override { return "tan(%li)"; } }; class AstAsinD : public AstNodeSystemUniop { @@ -6064,11 +6140,11 @@ public: AstAsinD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AsinD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(asin(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$asin(%l)"; } - virtual string emitC() { return "asin(%li)"; } + virtual string emitVerilog() override { return "%f$asin(%l)"; } + virtual string emitC() override { return "asin(%li)"; } }; class AstAcosD : public AstNodeSystemUniop { @@ -6076,11 +6152,11 @@ public: AstAcosD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AcosD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(acos(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$acos(%l)"; } - virtual string emitC() { return "acos(%li)"; } + virtual string emitVerilog() override { return "%f$acos(%l)"; } + virtual string emitC() override { return "acos(%li)"; } }; class AstAtanD : public AstNodeSystemUniop { @@ -6088,11 +6164,11 @@ public: AstAtanD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AtanD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(atan(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$atan(%l)"; } - virtual string emitC() { return "atan(%li)"; } + virtual string emitVerilog() override { return "%f$atan(%l)"; } + virtual string emitC() override { return "atan(%li)"; } }; class AstSinhD : public AstNodeSystemUniop { @@ -6100,11 +6176,11 @@ public: AstSinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(SinhD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(sinh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$sinh(%l)"; } - virtual string emitC() { return "sinh(%li)"; } + virtual string emitVerilog() override { return "%f$sinh(%l)"; } + virtual string emitC() override { return "sinh(%li)"; } }; class AstCoshD : public AstNodeSystemUniop { @@ -6112,11 +6188,11 @@ public: AstCoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(CoshD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(cosh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$cosh(%l)"; } - virtual string emitC() { return "cosh(%li)"; } + virtual string emitVerilog() override { return "%f$cosh(%l)"; } + virtual string emitC() override { return "cosh(%li)"; } }; class AstTanhD : public AstNodeSystemUniop { @@ -6124,11 +6200,11 @@ public: AstTanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(TanhD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(tanh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$tanh(%l)"; } - virtual string emitC() { return "tanh(%li)"; } + virtual string emitVerilog() override { return "%f$tanh(%l)"; } + virtual string emitC() override { return "tanh(%li)"; } }; class AstAsinhD : public AstNodeSystemUniop { @@ -6136,11 +6212,11 @@ public: AstAsinhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AsinhD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(asinh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$asinh(%l)"; } - virtual string emitC() { return "asinh(%li)"; } + virtual string emitVerilog() override { return "%f$asinh(%l)"; } + virtual string emitC() override { return "asinh(%li)"; } }; class AstAcoshD : public AstNodeSystemUniop { @@ -6148,11 +6224,11 @@ public: AstAcoshD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AcoshD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(acosh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$acosh(%l)"; } - virtual string emitC() { return "acosh(%li)"; } + virtual string emitVerilog() override { return "%f$acosh(%l)"; } + virtual string emitC() override { return "acosh(%li)"; } }; class AstAtanhD : public AstNodeSystemUniop { @@ -6160,11 +6236,11 @@ public: AstAtanhD(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(AtanhD) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { out.setDouble(atanh(lhs.toDouble())); } - virtual string emitVerilog() { return "%f$atanh(%l)"; } - virtual string emitC() { return "atanh(%li)"; } + virtual string emitVerilog() override { return "%f$atanh(%l)"; } + virtual string emitC() override { return "atanh(%li)"; } }; class AstToLowerN : public AstNodeUniop { // string.tolower() @@ -6174,12 +6250,14 @@ public: dtypeSetString(); } ASTNODE_NODE_FUNCS(ToLowerN) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opToLowerN(lhs); } - virtual string emitVerilog() { return "%l.tolower()"; } - virtual string emitC() { return "VL_TOLOWER_NN(%li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opToLowerN(lhs); + } + virtual string emitVerilog() override { return "%l.tolower()"; } + virtual string emitC() override { return "VL_TOLOWER_NN(%li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstToUpperN : public AstNodeUniop { // string.toupper() @@ -6189,12 +6267,14 @@ public: dtypeSetString(); } ASTNODE_NODE_FUNCS(ToUpperN) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opToUpperN(lhs); } - virtual string emitVerilog() { return "%l.toupper()"; } - virtual string emitC() { return "VL_TOUPPER_NN(%li)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opToUpperN(lhs); + } + virtual string emitVerilog() override { return "%l.toupper()"; } + virtual string emitC() override { return "VL_TOUPPER_NN(%li)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } }; class AstTimeImport : public AstNodeUniop { // Take a constant that represents a time and needs conversion based on time units @@ -6203,13 +6283,13 @@ public: AstTimeImport(FileLine* fl, AstNode* lhsp) : ASTGEN_SUPER(fl, lhsp) {} ASTNODE_NODE_FUNCS(TimeImport) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { V3ERROR_NA; } - virtual string emitVerilog() { return "%l"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual void dump(std::ostream& str = std::cout) const; + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { V3ERROR_NA; } + virtual string emitVerilog() override { return "%l"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual void dump(std::ostream& str = std::cout) const override; void timeunit(const VTimescale& flag) { m_timeunit = flag; } VTimescale timeunit() const { return m_timeunit; } }; @@ -6228,8 +6308,10 @@ public: fmt == ATOREAL ? dtypeSetDouble() : dtypeSetSigned32(); } ASTNODE_NODE_FUNCS(AtoN) - virtual void numberOperate(V3Number& out, const V3Number& lhs) { out.opAtoN(lhs, m_fmt); } - virtual string name() const { + virtual void numberOperate(V3Number& out, const V3Number& lhs) override { + out.opAtoN(lhs, m_fmt); + } + virtual string name() const override { switch (m_fmt) { case ATOI: return "atoi"; case ATOHEX: return "atohex"; @@ -6239,8 +6321,8 @@ public: default: V3ERROR_NA; } } - virtual string emitVerilog() { return "%l." + name() + "()"; } - virtual string emitC() { + virtual string emitVerilog() override { return "%l." + name() + "()"; } + virtual string emitC() override { switch (m_fmt) { case ATOI: return "VL_ATOI_N(%li, 10)"; case ATOHEX: return "VL_ATOI_N(%li, 16)"; @@ -6250,10 +6332,10 @@ public: default: V3ERROR_NA; } } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool isHeavy() const override { return true; } FmtType format() const { return m_fmt; } }; @@ -6267,21 +6349,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LogOr) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogOr(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLogOr(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f|| %r)"; } - virtual string emitC() { return "VL_LOGOR_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "||"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() + instrCountBranch(); } + virtual string emitVerilog() override { return "%k(%l %f|| %r)"; } + virtual string emitC() override { return "VL_LOGOR_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "||"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; class AstLogAnd : public AstNodeBiop { public: @@ -6290,21 +6372,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LogAnd) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogAnd(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLogAnd(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f&& %r)"; } - virtual string emitC() { return "VL_LOGAND_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "&&"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() + instrCountBranch(); } + virtual string emitVerilog() override { return "%k(%l %f&& %r)"; } + virtual string emitC() override { return "VL_LOGAND_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "&&"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; class AstLogEq : public AstNodeBiCom { public: @@ -6313,21 +6395,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LogEq) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogEq(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLogEq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<-> %r)"; } - virtual string emitC() { return "VL_LOGEQ_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "<->"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() + instrCountBranch(); } + virtual string emitVerilog() override { return "%k(%l %f<-> %r)"; } + virtual string emitC() override { return "VL_LOGEQ_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "<->"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; class AstLogIf : public AstNodeBiop { public: @@ -6336,21 +6418,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LogIf) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLogIf(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLogIf(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f-> %r)"; } - virtual string emitC() { return "VL_LOGIF_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "->"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() + instrCountBranch(); } + virtual string emitVerilog() override { return "%k(%l %f-> %r)"; } + virtual string emitC() override { return "VL_LOGIF_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "->"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() + instrCountBranch(); } }; class AstOr : public AstNodeBiComAsv { public: @@ -6359,20 +6441,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Or) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstOr(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opOr(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f| %r)"; } - virtual string emitC() { return "VL_OR_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "|"; } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(false); } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f| %r)"; } + virtual string emitC() override { return "VL_OR_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "|"; } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(false); } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstAnd : public AstNodeBiComAsv { public: @@ -6381,20 +6463,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(And) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAnd(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opAnd(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f& %r)"; } - virtual string emitC() { return "VL_AND_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "&"; } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(false); } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f& %r)"; } + virtual string emitC() override { return "VL_AND_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "&"; } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(false); } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstXor : public AstNodeBiComAsv { public: @@ -6403,20 +6485,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Xor) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstXor(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opXor(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f^ %r)"; } - virtual string emitC() { return "VL_XOR_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "^"; } - virtual bool cleanOut() const { return false; } // Lclean && Rclean - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f^ %r)"; } + virtual string emitC() override { return "VL_XOR_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "^"; } + virtual bool cleanOut() const override { return false; } // Lclean && Rclean + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstXnor : public AstNodeBiComAsv { public: @@ -6425,20 +6507,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Xnor) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstXnor(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opXnor(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f^ ~ %r)"; } - virtual string emitC() { return "VL_XNOR_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "^ ~"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f^ ~ %r)"; } + virtual string emitC() override { return "VL_XNOR_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "^ ~"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } }; class AstEq : public AstNodeBiCom { public: @@ -6447,22 +6529,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Eq) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEq(this->fileline(), lhsp, rhsp); } static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp); // Return AstEq/AstEqD - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opEq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f== %r)"; } - virtual string emitC() { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "=="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f== %r)"; } + virtual string emitC() override { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "=="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstEqD : public AstNodeBiCom { public: @@ -6471,22 +6553,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(EqD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opEqD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f== %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "=="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f== %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "=="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstEqN : public AstNodeBiCom { public: @@ -6495,22 +6577,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(EqN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opEqN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f== %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "=="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f== %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "=="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstNeq : public AstNodeBiCom { public: @@ -6519,20 +6601,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Neq) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeq(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opNeq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f!= %r)"; } - virtual string emitC() { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "!="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f!= %r)"; } + virtual string emitC() override { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "!="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstNeqD : public AstNodeBiCom { public: @@ -6541,22 +6623,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(NeqD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opNeqD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f!= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "!="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f!= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "!="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstNeqN : public AstNodeBiCom { public: @@ -6565,22 +6647,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(NeqN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opNeqN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f!= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "!="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f!= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "!="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstLt : public AstNodeBiop { public: @@ -6589,20 +6671,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Lt) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLt(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLt(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f< %r)"; } - virtual string emitC() { return "VL_LT_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "<"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f< %r)"; } + virtual string emitC() override { return "VL_LT_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "<"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstLtD : public AstNodeBiop { public: @@ -6611,22 +6693,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LtD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLtD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f< %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "<"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f< %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "<"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstLtS : public AstNodeBiop { public: @@ -6635,21 +6717,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LtS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLtS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f< %r)"; } - virtual string emitC() { return "VL_LTS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f< %r)"; } + virtual string emitC() override { return "VL_LTS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool signedFlavor() const override { return true; } }; class AstLtN : public AstNodeBiop { public: @@ -6658,22 +6740,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LtN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLtN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLtN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f< %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "<"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f< %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "<"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstGt : public AstNodeBiop { public: @@ -6682,20 +6764,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Gt) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGt(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGt(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f> %r)"; } - virtual string emitC() { return "VL_GT_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ">"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f> %r)"; } + virtual string emitC() override { return "VL_GT_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ">"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstGtD : public AstNodeBiop { public: @@ -6704,22 +6786,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GtD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGtD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f> %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return ">"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f> %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return ">"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstGtS : public AstNodeBiop { public: @@ -6728,21 +6810,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GtS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGtS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f> %r)"; } - virtual string emitC() { return "VL_GTS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f> %r)"; } + virtual string emitC() override { return "VL_GTS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool signedFlavor() const override { return true; } }; class AstGtN : public AstNodeBiop { public: @@ -6751,22 +6833,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GtN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGtN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGtN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f> %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return ">"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f> %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return ">"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstGte : public AstNodeBiop { public: @@ -6775,22 +6857,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Gte) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGte(this->fileline(), lhsp, rhsp); } static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp); // Return AstGte/AstGteS/AstGteD - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGte(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f>= %r)"; } - virtual string emitC() { return "VL_GTE_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ">="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f>= %r)"; } + virtual string emitC() override { return "VL_GTE_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ">="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstGteD : public AstNodeBiop { public: @@ -6799,22 +6881,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GteD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGteD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f>= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return ">="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f>= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return ">="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstGteS : public AstNodeBiop { public: @@ -6823,21 +6905,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GteS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGteS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f>= %r)"; } - virtual string emitC() { return "VL_GTES_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f>= %r)"; } + virtual string emitC() override { return "VL_GTES_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool signedFlavor() const override { return true; } }; class AstGteN : public AstNodeBiop { public: @@ -6846,22 +6928,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(GteN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGteN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGteN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f>= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return ">="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f>= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return ">="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstLte : public AstNodeBiop { public: @@ -6870,22 +6952,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(Lte) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLte(this->fileline(), lhsp, rhsp); } static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp); // Return AstLte/AstLteS/AstLteD - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLte(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<= %r)"; } - virtual string emitC() { return "VL_LTE_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "<="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f<= %r)"; } + virtual string emitC() override { return "VL_LTE_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "<="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstLteD : public AstNodeBiop { public: @@ -6894,22 +6976,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LteD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLteD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "<="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f<= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "<="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstLteS : public AstNodeBiop { public: @@ -6918,21 +7000,21 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LteS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLteS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<= %r)"; } - virtual string emitC() { return "VL_LTES_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f<= %r)"; } + virtual string emitC() override { return "VL_LTES_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool signedFlavor() const override { return true; } }; class AstLteN : public AstNodeBiop { public: @@ -6941,22 +7023,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(LteN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstLteN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opLteN(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<= %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "<="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f<= %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "<="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstShiftL : public AstNodeBiop { public: @@ -6965,20 +7047,20 @@ public: if (setwidth) { dtypeSetLogicSized(setwidth, VSigning::UNSIGNED); } } ASTNODE_NODE_FUNCS(ShiftL) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftL(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opShiftL(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f<< %r)"; } - virtual string emitC() { return "VL_SHIFTL_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "<<"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f<< %r)"; } + virtual string emitC() override { return "VL_SHIFTL_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "<<"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstShiftR : public AstNodeBiop { public: @@ -6987,21 +7069,21 @@ public: if (setwidth) { dtypeSetLogicSized(setwidth, VSigning::UNSIGNED); } } ASTNODE_NODE_FUNCS(ShiftR) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftR(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opShiftR(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f>> %r)"; } - virtual string emitC() { return "VL_SHIFTR_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ">>"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f>> %r)"; } + virtual string emitC() override { return "VL_SHIFTR_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ">>"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } // LHS size might be > output size, so don't want to force size - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstShiftRS : public AstNodeBiop { // Shift right with sign extension, >>> operator @@ -7013,21 +7095,21 @@ public: if (setwidth) { dtypeSetLogicSized(setwidth, VSigning::SIGNED); } } ASTNODE_NODE_FUNCS(ShiftRS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstShiftRS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opShiftRS(lhs, rhs, lhsp()->widthMinV()); } - virtual string emitVerilog() { return "%k(%l %f>>> %r)"; } - virtual string emitC() { return "VL_SHIFTRS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f>>> %r)"; } + virtual string emitC() override { return "VL_SHIFTRS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool signedFlavor() const override { return true; } }; class AstAdd : public AstNodeBiComAsv { public: @@ -7036,20 +7118,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Add) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAdd(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opAdd(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f+ %r)"; } - virtual string emitC() { return "VL_ADD_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "+"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f+ %r)"; } + virtual string emitC() override { return "VL_ADD_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "+"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } }; class AstAddD : public AstNodeBiComAsv { public: @@ -7058,22 +7140,22 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(AddD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAddD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opAddD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f+ %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "+"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f+ %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "+"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstSub : public AstNodeBiop { public: @@ -7082,20 +7164,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Sub) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstSub(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opSub(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f- %r)"; } - virtual string emitC() { return "VL_SUB_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "-"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f- %r)"; } + virtual string emitC() override { return "VL_SUB_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "-"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } }; class AstSubD : public AstNodeBiop { public: @@ -7104,22 +7186,22 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(SubD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstSubD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opSubD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f- %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "-"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f- %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "-"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstMul : public AstNodeBiComAsv { public: @@ -7128,21 +7210,21 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Mul) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMul(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opMul(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f* %r)"; } - virtual string emitC() { return "VL_MUL_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "*"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountMul(); } + virtual string emitVerilog() override { return "%k(%l %f* %r)"; } + virtual string emitC() override { return "VL_MUL_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "*"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul(); } }; class AstMulD : public AstNodeBiComAsv { public: @@ -7151,22 +7233,22 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(MulD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMulD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opMulD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f* %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "*"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return instrCountDouble(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f* %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "*"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return instrCountDouble(); } + virtual bool doubleFlavor() const override { return true; } }; class AstMulS : public AstNodeBiComAsv { public: @@ -7175,23 +7257,23 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(MulS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstMulS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opMulS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f* %r)"; } - virtual string emitC() { return "VL_MULS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountMul(); } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f* %r)"; } + virtual string emitC() override { return "VL_MULS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul(); } + virtual bool signedFlavor() const override { return true; } }; class AstDiv : public AstNodeBiop { public: @@ -7200,20 +7282,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Div) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDiv(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opDiv(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f/ %r)"; } - virtual string emitC() { return "VL_DIV_%nq%lq%rq(%lw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountDiv(); } + virtual string emitVerilog() override { return "%k(%l %f/ %r)"; } + virtual string emitC() override { return "VL_DIV_%nq%lq%rq(%lw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } }; class AstDivD : public AstNodeBiop { public: @@ -7222,22 +7304,22 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(DivD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDivD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opDivD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f/ %r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return "/"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDoubleDiv(); } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f/ %r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return "/"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDoubleDiv(); } + virtual bool doubleFlavor() const override { return true; } }; class AstDivS : public AstNodeBiop { public: @@ -7246,21 +7328,21 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(DivS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstDivS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opDivS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f/ %r)"; } - virtual string emitC() { return "VL_DIVS_%nq%lq%rq(%lw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountDiv(); } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f/ %r)"; } + virtual string emitC() override { return "VL_DIVS_%nq%lq%rq(%lw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } + virtual bool signedFlavor() const override { return true; } }; class AstModDiv : public AstNodeBiop { public: @@ -7269,20 +7351,20 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(ModDiv) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstModDiv(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opModDiv(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f%% %r)"; } - virtual string emitC() { return "VL_MODDIV_%nq%lq%rq(%lw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountDiv(); } + virtual string emitVerilog() override { return "%k(%l %f%% %r)"; } + virtual string emitC() override { return "VL_MODDIV_%nq%lq%rq(%lw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } }; class AstModDivS : public AstNodeBiop { public: @@ -7291,21 +7373,21 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(ModDivS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstModDivS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opModDivS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f%% %r)"; } - virtual string emitC() { return "VL_MODDIVS_%nq%lq%rq(%lw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual int instrCount() const { return widthInstrs() * instrCountDiv(); } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f%% %r)"; } + virtual string emitC() override { return "VL_MODDIVS_%nq%lq%rq(%lw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual int instrCount() const override { return widthInstrs() * instrCountDiv(); } + virtual bool signedFlavor() const override { return true; } }; class AstPow : public AstNodeBiop { public: @@ -7314,21 +7396,21 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(Pow) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPow(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opPow(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f** %r)"; } - virtual string emitC() { return "VL_POW_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * instrCountMul() * 10; } + virtual string emitVerilog() override { return "%k(%l %f** %r)"; } + virtual string emitC() override { return "VL_POW_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } }; class AstPowD : public AstNodeBiop { public: @@ -7337,21 +7419,21 @@ public: dtypeSetDouble(); } ASTNODE_NODE_FUNCS(PowD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opPowD(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f** %r)"; } - virtual string emitC() { return "pow(%li,%ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDoubleDiv() * 5; } - virtual bool doubleFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f** %r)"; } + virtual string emitC() override { return "pow(%li,%ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDoubleDiv() * 5; } + virtual bool doubleFlavor() const override { return true; } }; class AstPowSU : public AstNodeBiop { public: @@ -7360,22 +7442,24 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(PowSU) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowSU(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opPowSU(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f** %r)"; } - virtual string emitC() { return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 1,0)"; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * instrCountMul() * 10; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f** %r)"; } + virtual string emitC() override { + return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 1,0)"; + } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } + virtual bool signedFlavor() const override { return true; } }; class AstPowSS : public AstNodeBiop { public: @@ -7384,22 +7468,24 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(PowSS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowSS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opPowSS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f** %r)"; } - virtual string emitC() { return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 1,1)"; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * instrCountMul() * 10; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f** %r)"; } + virtual string emitC() override { + return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 1,1)"; + } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } + virtual bool signedFlavor() const override { return true; } }; class AstPowUS : public AstNodeBiop { public: @@ -7408,22 +7494,24 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(PowUS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstPowUS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opPowUS(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f** %r)"; } - virtual string emitC() { return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 0,1)"; } - virtual bool emitCheckMaxWords() { return true; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * instrCountMul() * 10; } - virtual bool signedFlavor() const { return true; } + virtual string emitVerilog() override { return "%k(%l %f** %r)"; } + virtual string emitC() override { + return "VL_POWSS_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri, 0,1)"; + } + virtual bool emitCheckMaxWords() override { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * instrCountMul() * 10; } + virtual bool signedFlavor() const override { return true; } }; class AstPreAdd : public AstNodeTriop { // Pre-increment/add @@ -7436,19 +7524,19 @@ public: : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {} ASTNODE_NODE_FUNCS(PreAdd) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs } - virtual string emitVerilog() { return "%k(++%r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool cleanThs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual bool sizeMattersThs() const { return true; } + virtual string emitVerilog() override { return "%k(++%r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool cleanThs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual bool sizeMattersThs() const override { return true; } }; class AstPreSub : public AstNodeTriop { // Pre-decrement/subtract @@ -7461,19 +7549,19 @@ public: : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {} ASTNODE_NODE_FUNCS(PreSub) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs } - virtual string emitVerilog() { return "%k(--%r)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool cleanThs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual bool sizeMattersThs() const { return true; } + virtual string emitVerilog() override { return "%k(--%r)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool cleanThs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual bool sizeMattersThs() const override { return true; } }; class AstPostAdd : public AstNodeTriop { // Post-increment/add @@ -7486,19 +7574,19 @@ public: : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {} ASTNODE_NODE_FUNCS(PostAdd) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs } - virtual string emitVerilog() { return "%k(%r++)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool cleanThs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual bool sizeMattersThs() const { return true; } + virtual string emitVerilog() override { return "%k(%r++)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool cleanThs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual bool sizeMattersThs() const override { return true; } }; class AstPostSub : public AstNodeTriop { // Post-decrement/subtract @@ -7511,19 +7599,19 @@ public: : ASTGEN_SUPER(fl, lhsp, rhsp, thsp) {} ASTNODE_NODE_FUNCS(PostSub) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { V3ERROR_NA; // Need to modify lhs } - virtual string emitVerilog() { return "%k(%r--)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool cleanThs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return true; } - virtual bool sizeMattersThs() const { return true; } + virtual string emitVerilog() override { return "%k(%r--)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool cleanThs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return true; } + virtual bool sizeMattersThs() const override { return true; } }; class AstEqCase : public AstNodeBiCom { public: @@ -7532,20 +7620,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(EqCase) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqCase(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opCaseEq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f=== %r)"; } - virtual string emitC() { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "=="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f=== %r)"; } + virtual string emitC() override { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "=="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstNeqCase : public AstNodeBiCom { public: @@ -7554,20 +7642,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(NeqCase) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqCase(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opCaseNeq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f!== %r)"; } - virtual string emitC() { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "!="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f!== %r)"; } + virtual string emitC() override { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "!="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstEqWild : public AstNodeBiop { // Note wildcard operator rhs differs from lhs @@ -7577,22 +7665,22 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(EqWild) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstEqWild(this->fileline(), lhsp, rhsp); } static AstNodeBiop* newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp); // Return AstEqWild/AstEqD - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opWildEq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f==? %r)"; } - virtual string emitC() { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "=="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f==? %r)"; } + virtual string emitC() override { return "VL_EQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "=="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstNeqWild : public AstNodeBiop { public: @@ -7601,20 +7689,20 @@ public: dtypeSetLogicBool(); } ASTNODE_NODE_FUNCS(NeqWild) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstNeqWild(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opWildNeq(lhs, rhs); } - virtual string emitVerilog() { return "%k(%l %f!=? %r)"; } - virtual string emitC() { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } - virtual string emitSimpleOperator() { return "!="; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "%k(%l %f!=? %r)"; } + virtual string emitC() override { return "VL_NEQ_%lq(%lW, %P, %li, %ri)"; } + virtual string emitSimpleOperator() override { return "!="; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstConcat : public AstNodeBiop { // If you're looking for {#{}}, see AstReplicate @@ -7627,20 +7715,20 @@ public: } } ASTNODE_NODE_FUNCS(Concat) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstConcat(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f{%l, %k%r}"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual string emitVerilog() override { return "%f{%l, %k%r}"; } + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opConcat(lhs, rhs); } - virtual string emitC() { return "VL_CONCAT_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 2; } + virtual string emitC() override { return "VL_CONCAT_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 2; } }; class AstConcatN : public AstNodeBiop { // String concatenate @@ -7650,21 +7738,21 @@ public: dtypeSetString(); } ASTNODE_NODE_FUNCS(ConcatN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstConcatN(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f{%l, %k%r}"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual string emitVerilog() override { return "%f{%l, %k%r}"; } + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opConcatN(lhs, rhs); } - virtual string emitC() { return "VL_CONCATN_NNN(%li, %ri)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountString(); } - virtual bool stringFlavor() const { return true; } + virtual string emitC() override { return "VL_CONCATN_NNN(%li, %ri)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountString(); } + virtual bool stringFlavor() const override { return true; } }; class AstReplicate : public AstNodeBiop { // Also used as a "Uniop" flavor of Concat, e.g. "{a}" @@ -7681,20 +7769,20 @@ public: AstReplicate(FileLine* fl, AstNode* lhsp, uint32_t repCount) : AstReplicate(fl, lhsp, new AstConst(fl, repCount)) {} ASTNODE_NODE_FUNCS(Replicate) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstReplicate(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opRepl(lhs, rhs); } - virtual string emitVerilog() { return "%f{%r{%k%l}}"; } - virtual string emitC() { return "VL_REPLICATE_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 2; } + virtual string emitVerilog() override { return "%f{%r{%k%l}}"; } + virtual string emitC() override { return "VL_REPLICATE_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 2; } }; class AstReplicateN : public AstNodeBiop { // String replicate @@ -7706,21 +7794,21 @@ public: AstReplicateN(FileLine* fl, AstNode* lhsp, uint32_t repCount) : AstReplicateN(fl, lhsp, new AstConst(fl, repCount)) {} ASTNODE_NODE_FUNCS(ReplicateN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstReplicateN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opReplN(lhs, rhs); } - virtual string emitVerilog() { return "%f{%r{%k%l}}"; } - virtual string emitC() { return "VL_REPLICATEN_NN%rq(0,0,%rw, %li, %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 2; } - virtual bool stringFlavor() const { return true; } + virtual string emitVerilog() override { return "%f{%r{%k%l}}"; } + virtual string emitC() override { return "VL_REPLICATEN_NN%rq(0,0,%rw, %li, %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 2; } + virtual bool stringFlavor() const override { return true; } }; class AstStreamL : public AstNodeStream { // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp() @@ -7728,20 +7816,20 @@ public: AstStreamL(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(StreamL) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstStreamL(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f{ << %r %k{%l} }"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual string emitVerilog() override { return "%f{ << %r %k{%l} }"; } + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opStreamL(lhs, rhs); } - virtual string emitC() { return "VL_STREAML_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 2; } + virtual string emitC() override { return "VL_STREAML_%nq%lq%rq(%nw,%lw,%rw, %P, %li, %ri)"; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 2; } }; class AstStreamR : public AstNodeStream { // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp() @@ -7749,20 +7837,20 @@ public: AstStreamR(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(StreamR) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstStreamR(this->fileline(), lhsp, rhsp); } - virtual string emitVerilog() { return "%f{ >> %r %k{%l} }"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual string emitVerilog() override { return "%f{ >> %r %k{%l} }"; } + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opAssign(lhs); } - virtual string emitC() { return isWide() ? "VL_ASSIGN_W(%nw, %P, %li)" : "%li"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return true; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 2; } + virtual string emitC() override { return isWide() ? "VL_ASSIGN_W(%nw, %P, %li)" : "%li"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return true; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 2; } }; class AstBufIf1 : public AstNodeBiop { // lhs is enable, rhs is data to drive @@ -7774,40 +7862,40 @@ public: dtypeFrom(lhsp); } ASTNODE_NODE_FUNCS(BufIf1) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstBufIf1(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opBufIf1(lhs, rhs); } - virtual string emitVerilog() { return "bufif(%r,%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } // Lclean || Rclean - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } // Lclean || Rclean - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } // Lclean || Rclean - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } + virtual string emitVerilog() override { return "bufif(%r,%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } // Lclean || Rclean + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } // Lclean || Rclean + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } // Lclean || Rclean + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } }; class AstFGetS : public AstNodeBiop { public: AstFGetS(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(FGetS) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstFGetS(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } - virtual string emitVerilog() { return "%f$fgets(%l,%r)"; } - virtual string emitC() { return "VL_FGETS_%nqX%rq(%lw, %P, &(%li), %ri)"; } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return widthInstrs() * 64; } + virtual string emitVerilog() override { return "%f$fgets(%l,%r)"; } + virtual string emitC() override { return "VL_FGETS_%nqX%rq(%lw, %P, &(%li), %ri)"; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return widthInstrs() * 64; } AstNode* strgp() const { return lhsp(); } AstNode* filep() const { return rhsp(); } }; @@ -7818,13 +7906,13 @@ public: : AstNodeBiop(t, fl, lhsp, rhsp) { dtypeSetDouble(); } - virtual bool cleanOut() const { return false; } - virtual bool cleanLhs() const { return false; } - virtual bool cleanRhs() const { return false; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual int instrCount() const { return instrCountDoubleTrig(); } - virtual bool doubleFlavor() const { return true; } + virtual bool cleanOut() const override { return false; } + virtual bool cleanLhs() const override { return false; } + virtual bool cleanRhs() const override { return false; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual int instrCount() const override { return instrCountDoubleTrig(); } + virtual bool doubleFlavor() const override { return true; } }; class AstAtan2D : public AstNodeSystemBiop { @@ -7832,14 +7920,14 @@ public: AstAtan2D(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(Atan2D) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstAtan2D(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.setDouble(atan2(lhs.toDouble(), rhs.toDouble())); } - virtual string emitVerilog() { return "%f$atan2(%l,%r)"; } - virtual string emitC() { return "atan2(%li,%ri)"; } + virtual string emitVerilog() override { return "%f$atan2(%l,%r)"; } + virtual string emitC() override { return "atan2(%li,%ri)"; } }; class AstHypotD : public AstNodeSystemBiop { @@ -7847,14 +7935,14 @@ public: AstHypotD(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : ASTGEN_SUPER(fl, lhsp, rhsp) {} ASTNODE_NODE_FUNCS(HypotD) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstHypotD(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.setDouble(hypot(lhs.toDouble(), rhs.toDouble())); } - virtual string emitVerilog() { return "%f$hypot(%l,%r)"; } - virtual string emitC() { return "hypot(%li,%ri)"; } + virtual string emitVerilog() override { return "%f$hypot(%l,%r)"; } + virtual string emitC() override { return "hypot(%li,%ri)"; } }; class AstPutcN : public AstNodeTriop { @@ -7866,21 +7954,21 @@ public: } ASTNODE_NODE_FUNCS(PutcN) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { out.opPutcN(lhs, rhs, ths); } - virtual string name() const { return "putc"; } - virtual string emitVerilog() { return "%k(%l.putc(%r,%t))"; } - virtual string emitC() { return "VL_PUTC_N(%li,%ri,%ti)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool cleanThs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual string name() const override { return "putc"; } + virtual string emitVerilog() override { return "%k(%l.putc(%r,%t))"; } + virtual string emitC() override { return "VL_PUTC_N(%li,%ri,%ti)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool cleanThs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual bool isHeavy() const override { return true; } }; class AstGetcN : public AstNodeBiop { @@ -7891,22 +7979,22 @@ public: dtypeSetBitSized(8, VSigning::UNSIGNED); } ASTNODE_NODE_FUNCS(GetcN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGetcN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opGetcN(lhs, rhs); } - virtual string name() const { return "getc"; } - virtual string emitVerilog() { return "%k(%l.getc(%r))"; } - virtual string emitC() { return "VL_GETC_N(%li,%ri)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual string name() const override { return "getc"; } + virtual string emitVerilog() override { return "%k(%l.getc(%r))"; } + virtual string emitC() override { return "VL_GETC_N(%li,%ri)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool isHeavy() const override { return true; } }; class AstGetcRefN : public AstNodeBiop { @@ -7918,21 +8006,21 @@ public: dtypeSetBitSized(8, VSigning::UNSIGNED); } ASTNODE_NODE_FUNCS(GetcRefN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstGetcRefN(this->fileline(), lhsp, rhsp); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { V3ERROR_NA; } - virtual string emitVerilog() { return "%k%l[%r]"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual string emitVerilog() override { return "%k%l[%r]"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool isHeavy() const override { return true; } }; class AstSubstrN : public AstNodeTriop { @@ -7944,21 +8032,21 @@ public: } ASTNODE_NODE_FUNCS(SubstrN) virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, - const V3Number& ths) { + const V3Number& ths) override { out.opSubstrN(lhs, rhs, ths); } - virtual string name() const { return "substr"; } - virtual string emitVerilog() { return "%k(%l.substr(%r,%t))"; } - virtual string emitC() { return "VL_SUBSTR_N(%li,%ri,%ti)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool cleanThs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool sizeMattersThs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual string name() const override { return "substr"; } + virtual string emitVerilog() override { return "%k(%l.substr(%r,%t))"; } + virtual string emitC() override { return "VL_SUBSTR_N(%li,%ri,%ti)"; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool cleanThs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool sizeMattersThs() const override { return false; } + virtual bool isHeavy() const override { return true; } }; class AstCompareNN : public AstNodeBiop { @@ -7972,26 +8060,26 @@ public: dtypeSetUInt32(); } ASTNODE_NODE_FUNCS(CompareNN) - virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) { + virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp) override { return new AstCompareNN(this->fileline(), lhsp, rhsp, m_ignoreCase); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { + virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override { out.opCompareNN(lhs, rhs, m_ignoreCase); } - virtual string name() const { return m_ignoreCase ? "icompare" : "compare"; } - virtual string emitVerilog() { + virtual string name() const override { return m_ignoreCase ? "icompare" : "compare"; } + virtual string emitVerilog() override { return m_ignoreCase ? "%k(%l.icompare(%r))" : "%k(%l.compare(%r))"; } - virtual string emitC() { + virtual string emitC() override { return m_ignoreCase ? "VL_CMP_NN(%li,%ri,true)" : "VL_CMP_NN(%li,%ri,false)"; } - virtual string emitSimpleOperator() { return ""; } - virtual bool cleanOut() const { return true; } - virtual bool cleanLhs() const { return true; } - virtual bool cleanRhs() const { return true; } - virtual bool sizeMattersLhs() const { return false; } - virtual bool sizeMattersRhs() const { return false; } - virtual bool isHeavy() const { return true; } + virtual string emitSimpleOperator() override { return ""; } + virtual bool cleanOut() const override { return true; } + virtual bool cleanLhs() const override { return true; } + virtual bool cleanRhs() const override { return true; } + virtual bool sizeMattersLhs() const override { return false; } + virtual bool sizeMattersRhs() const override { return false; } + virtual bool isHeavy() const override { return true; } }; class AstFell : public AstNodeMath { @@ -8004,19 +8092,16 @@ public: addOp1p(exprp); } ASTNODE_NODE_FUNCS(Fell) - virtual string emitVerilog() { return "$fell(%l)"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "$fell(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs(); } AstNode* exprp() const { return op1p(); } // op1 = expression AstSenTree* sentreep() const { return VN_CAST(op2p(), SenTree); } // op2 = clock domain void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstPast : public AstNodeMath { @@ -8030,20 +8115,17 @@ public: addNOp2p(ticksp); } ASTNODE_NODE_FUNCS(Past) - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs(); } AstNode* exprp() const { return op1p(); } // op1 = expression AstNode* ticksp() const { return op2p(); } // op2 = ticks or nullptr means 1 AstSenTree* sentreep() const { return VN_CAST(op4p(), SenTree); } // op4 = clock domain void sentreep(AstSenTree* sentreep) { addOp4p(sentreep); } // op4 = clock domain - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstRose : public AstNodeMath { @@ -8056,19 +8138,16 @@ public: addOp1p(exprp); } ASTNODE_NODE_FUNCS(Rose) - virtual string emitVerilog() { return "$rose(%l)"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "$rose(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs(); } AstNode* exprp() const { return op1p(); } // op1 = expression AstSenTree* sentreep() const { return VN_CAST(op2p(), SenTree); } // op2 = clock domain void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstSampled : public AstNodeMath { @@ -8081,14 +8160,14 @@ public: addOp1p(exprp); } ASTNODE_NODE_FUNCS(Sampled) - virtual string emitVerilog() { return "$sampled(%l)"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return 0; } + virtual string emitVerilog() override { return "$sampled(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return 0; } AstNode* exprp() const { return op1p(); } // op1 = expression - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstStable : public AstNodeMath { @@ -8101,19 +8180,16 @@ public: addOp1p(exprp); } ASTNODE_NODE_FUNCS(Stable) - virtual string emitVerilog() { return "$stable(%l)"; } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs(); } + virtual string emitVerilog() override { return "$stable(%l)"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs(); } AstNode* exprp() const { return op1p(); } // op1 = expression AstSenTree* sentreep() const { return VN_CAST(op2p(), SenTree); } // op2 = clock domain void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; class AstPattern : public AstNodeMath { @@ -8126,15 +8202,12 @@ public: addNOp2p(itemsp); } ASTNODE_NODE_FUNCS(Pattern) - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs(); } - AstNodeDType* getChildDTypep() const { return childDTypep(); } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs(); } + virtual AstNodeDType* getChildDTypep() const override { return childDTypep(); } virtual AstNodeDType* subDTypep() const { return dtypep() ? dtypep() : childDTypep(); } // op1 = Type assigning to AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } @@ -8155,14 +8228,11 @@ public: m_default = false; } ASTNODE_NODE_FUNCS(PatMember) - virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) { - V3ERROR_NA; - } - virtual string emitVerilog() { return lhssp() ? "%f{%r{%k%l}}" : "%l"; } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual string emitSimpleOperator() { V3ERROR_NA_RETURN(""); } - virtual bool cleanOut() const { V3ERROR_NA_RETURN(""); } - virtual int instrCount() const { return widthInstrs() * 2; } + virtual string emitVerilog() override { return lhssp() ? "%f{%r{%k%l}}" : "%l"; } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual string emitSimpleOperator() override { V3ERROR_NA_RETURN(""); } + virtual bool cleanOut() const override { V3ERROR_NA_RETURN(""); } + virtual int instrCount() const override { return widthInstrs() * 2; } // op1 = expression to assign or another AstPattern (list if replicated) AstNode* lhssp() const { return op1p(); } AstNode* keyp() const { return op2p(); } // op2 = assignment key (Const, id Text) @@ -8205,7 +8275,9 @@ public: addOp3p(propp); } ASTNODE_NODE_FUNCS(PropClocked) - virtual bool hasDType() const { return true; } // Used under Cover, which expects a bool child + virtual bool hasDType() const override { + return true; + } // Used under Cover, which expects a bool child AstSenItem* sensesp() const { return VN_CAST(op1p(), SenItem); } // op1 = Sensitivity list AstNode* disablep() const { return op2p(); } // op2 = disable AstNode* propp() const { return op3p(); } // op3 = property @@ -8228,11 +8300,11 @@ public: addNOp4p(passsp); } ASTNODE_BASE_FUNCS(NodeCoverOrAssert) - virtual string name() const { return m_name; } // * = Var name - virtual V3Hash sameHash() const { return V3Hash(name()); } - virtual bool same(const AstNode* samep) const { return samep->name() == name(); } - virtual void name(const string& name) { m_name = name; } - virtual void dump(std::ostream& str = std::cout) const; + virtual string name() const override { return m_name; } // * = Var name + virtual V3Hash sameHash() const override { return V3Hash(name()); } + virtual bool same(const AstNode* samep) const override { return samep->name() == name(); } + virtual void name(const string& name) override { m_name = name; } + virtual void dump(std::ostream& str = std::cout) const override; AstNode* propp() const { return op1p(); } // op1 = property AstSenTree* sentreep() const { return VN_CAST(op2p(), SenTree); } // op2 = clock domain void sentreep(AstSenTree* sentreep) { addOp2p(sentreep); } // op2 = clock domain @@ -8314,8 +8386,8 @@ public: AstScCtor(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScCtor) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstScDtor : public AstNodeText { @@ -8323,8 +8395,8 @@ public: AstScDtor(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScDtor) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstScHdr : public AstNodeText { @@ -8332,8 +8404,8 @@ public: AstScHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScHdr) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstScImp : public AstNodeText { @@ -8341,8 +8413,8 @@ public: AstScImp(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScImp) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstScImpHdr : public AstNodeText { @@ -8350,8 +8422,8 @@ public: AstScImpHdr(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScImpHdr) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstScInt : public AstNodeText { @@ -8359,8 +8431,8 @@ public: AstScInt(FileLine* fl, const string& textp) : ASTGEN_SUPER(fl, textp) {} ASTNODE_NODE_FUNCS(ScInt) - virtual bool isPure() const { return false; } // SPECIAL: User may order w/other sigs - virtual bool isOutputter() const { return true; } + virtual bool isPure() const override { return false; } // SPECIAL: User may order w/other sigs + virtual bool isOutputter() const override { return true; } }; class AstUCStmt : public AstNodeStmt { @@ -8372,12 +8444,12 @@ public: } ASTNODE_NODE_FUNCS(UCStmt) AstNode* bodysp() const { return op1p(); } // op1 = expressions to print - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual bool isPure() const { return false; } - virtual bool isOutputter() const { return true; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual bool isPure() const override { return false; } + virtual bool isOutputter() const override { return true; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } }; //====================================================================== @@ -8395,9 +8467,9 @@ public: m_name = name; } ASTNODE_BASE_FUNCS(NodeFile) - virtual string name() const { return m_name; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual string name() const override { return m_name; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } void tblockp(AstTextBlock* tblockp) { setOp1p(tblockp); } AstTextBlock* tblockp() { return VN_CAST(op1p(), TextBlock); } }; @@ -8412,7 +8484,7 @@ public: AstVFile(FileLine* fl, const string& name) : ASTGEN_SUPER(fl, name) {} ASTNODE_NODE_FUNCS(VFile) - virtual void dump(std::ostream& str = std::cout) const; + virtual void dump(std::ostream& str = std::cout) const override; }; //====================================================================== @@ -8433,7 +8505,7 @@ public: m_support = false; } ASTNODE_NODE_FUNCS(CFile) - virtual void dump(std::ostream& str = std::cout) const; + virtual void dump(std::ostream& str = std::cout) const override; bool slow() const { return m_slow; } void slow(bool flag) { m_slow = flag; } bool source() const { return m_source; } @@ -8503,23 +8575,23 @@ public: m_dpiImportWrapper = false; } ASTNODE_NODE_FUNCS(CFunc) - virtual string name() const { return m_name; } - virtual const char* broken() const { + virtual string name() const override { return m_name; } + virtual const char* broken() const override { BROKEN_RTN((m_scopep && !m_scopep->brokeExists())); return nullptr; } - virtual bool maybePointedTo() const { return true; } - virtual void dump(std::ostream& str = std::cout) const; - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { + virtual bool maybePointedTo() const override { return true; } + virtual void dump(std::ostream& str = std::cout) const override; + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { const AstCFunc* asamep = static_cast(samep); return ((funcType() == asamep->funcType()) && (rtnTypeVoid() == asamep->rtnTypeVoid()) && (argTypes() == asamep->argTypes()) && (!(dpiImport() || dpiExport()) || name() == asamep->name())); } // - virtual void name(const string& name) { m_name = name; } - virtual int instrCount() const { return dpiImport() ? instrCountDpi() : 0; } + virtual void name(const string& name) override { m_name = name; } + virtual int instrCount() const override { return dpiImport() ? instrCountDpi() : 0; } VBoolOrUnknown isConst() const { return m_isConst; } void isConst(bool flag) { m_isConst.setTrueOrFalse(flag); } void isConst(VBoolOrUnknown flag) { m_isConst = flag; } @@ -8615,7 +8687,7 @@ public: setOp1p(fromp); } ASTNODE_NODE_FUNCS(CMethodCall) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_BASE_RTN(AstNodeCCall::broken()); BROKEN_RTN(!fromp()); return nullptr; @@ -8639,7 +8711,7 @@ public: // Note this removes old attachments from the oldp AstCNew(AstCCall* oldp, AstCFunc* funcp) : ASTGEN_SUPER(oldp, funcp) {} - virtual bool hasDType() const { return true; } + virtual bool hasDType() const override { return true; } ASTNODE_NODE_FUNCS(CNew) }; @@ -8653,9 +8725,9 @@ public: setOp1p(lhsp); } ASTNODE_NODE_FUNCS(CReturn) - virtual int instrCount() const { return widthInstrs(); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual int instrCount() const override { return widthInstrs(); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } // AstNode* lhsp() const { return op1p(); } }; @@ -8681,13 +8753,13 @@ public: if (setwidth) { dtypeSetLogicSized(setwidth, VSigning::UNSIGNED); } } ASTNODE_NODE_FUNCS(CMath) - virtual bool isGateOptimizable() const { return m_pure; } - virtual bool isPredictOptimizable() const { return m_pure; } - virtual bool cleanOut() const { return m_cleanOut; } - virtual string emitVerilog() { V3ERROR_NA_RETURN(""); } - virtual string emitC() { V3ERROR_NA_RETURN(""); } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return m_pure; } + virtual bool isPredictOptimizable() const override { return m_pure; } + virtual bool cleanOut() const override { return m_cleanOut; } + virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); } + virtual string emitC() override { V3ERROR_NA_RETURN(""); } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } void addBodysp(AstNode* nodep) { addNOp1p(nodep); } AstNode* bodysp() const { return op1p(); } // op1 = expressions to print bool pure() const { return m_pure; } @@ -8702,10 +8774,10 @@ public: addNOp1p(exprsp); } ASTNODE_NODE_FUNCS(CReset) - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } AstVarRef* varrefp() const { return VN_CAST(op1p(), VarRef); } // op1 = varref to reset }; @@ -8721,10 +8793,10 @@ public: addNOp1p(new AstText(fl, textStmt, true)); } ASTNODE_NODE_FUNCS(CStmt) - virtual bool isGateOptimizable() const { return false; } - virtual bool isPredictOptimizable() const { return false; } - virtual V3Hash sameHash() const { return V3Hash(); } - virtual bool same(const AstNode* samep) const { return true; } + virtual bool isGateOptimizable() const override { return false; } + virtual bool isPredictOptimizable() const override { return false; } + virtual V3Hash sameHash() const override { return V3Hash(); } + virtual bool same(const AstNode* samep) const override { return true; } void addBodysp(AstNode* nodep) { addNOp1p(nodep); } AstNode* bodysp() const { return op1p(); } // op1 = expressions to print }; @@ -8742,8 +8814,8 @@ public: , m_useType(useType) , m_name(name) {} ASTNODE_NODE_FUNCS(CUse) - virtual string name() const { return m_name; } - virtual void dump(std::ostream& str = std::cout) const; + virtual string name() const override { return m_name; } + virtual void dump(std::ostream& str = std::cout) const override; VUseType useType() const { return m_useType; } void useType(VUseType useType) { m_useType = useType; } }; @@ -8758,7 +8830,7 @@ public: : ASTGEN_SUPER(fl) , m_execMTaskp(nullptr) {} ASTNODE_NODE_FUNCS(MTaskBody); - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(!m_execMTaskp); return nullptr; } @@ -8766,7 +8838,7 @@ public: void addStmtsp(AstNode* nodep) { addOp1p(nodep); } ExecMTask* execMTaskp() const { return m_execMTaskp; } void execMTaskp(ExecMTask* execMTaskp) { m_execMTaskp = execMTaskp; } - virtual void dump(std::ostream& str = std::cout) const; + virtual void dump(std::ostream& str = std::cout) const override; }; class AstExecGraph : public AstNode { @@ -8783,8 +8855,8 @@ private: public: explicit AstExecGraph(FileLine* fl); ASTNODE_NODE_FUNCS_NO_DTOR(ExecGraph) - virtual ~AstExecGraph(); - virtual const char* broken() const { + virtual ~AstExecGraph() override; + virtual const char* broken() const override { BROKEN_RTN(!m_depGraphp); return nullptr; } @@ -8831,7 +8903,7 @@ public: AstBasicDType* findInsertSameDType(AstBasicDType* nodep); void clearCache(); void repairCache(); - virtual void dump(std::ostream& str = std::cout) const; + virtual void dump(std::ostream& str = std::cout) const override; }; //###################################################################### @@ -8856,13 +8928,13 @@ public: , m_evalp(nullptr) , m_execGraphp(nullptr) {} ASTNODE_NODE_FUNCS(Netlist) - virtual const char* broken() const { + virtual const char* broken() const override { BROKEN_RTN(m_dollarUnitPkgp && !m_dollarUnitPkgp->brokeExists()); BROKEN_RTN(m_evalp && !m_evalp->brokeExists()); return nullptr; } - virtual string name() const { return "$root"; } - virtual void dump(std::ostream& str) const; + virtual string name() const override { return "$root"; } + virtual void dump(std::ostream& str) const override; AstNodeModule* modulesp() const { // op1 = List of modules return VN_CAST(op1p(), NodeModule); } diff --git a/src/V3Begin.cpp b/src/V3Begin.cpp index f27269546..726e07bba 100644 --- a/src/V3Begin.cpp +++ b/src/V3Begin.cpp @@ -257,7 +257,7 @@ public: m_ifDepth = 0; iterate(nodep); } - virtual ~BeginVisitor() {} + virtual ~BeginVisitor() override {} }; //###################################################################### @@ -298,7 +298,7 @@ private: public: // CONSTRUCTORS BeginRelinkVisitor(AstNetlist* nodep, BeginState*) { iterate(nodep); } - virtual ~BeginRelinkVisitor() {} + virtual ~BeginRelinkVisitor() override {} }; //###################################################################### diff --git a/src/V3Branch.cpp b/src/V3Branch.cpp index c5d247937..0b7de7552 100644 --- a/src/V3Branch.cpp +++ b/src/V3Branch.cpp @@ -121,7 +121,7 @@ public: iterateChildren(nodep); calc_tasks(); } - virtual ~BranchVisitor() {} + virtual ~BranchVisitor() override {} }; //###################################################################### diff --git a/src/V3Broken.cpp b/src/V3Broken.cpp index c40c9888b..fc4de04cf 100644 --- a/src/V3Broken.cpp +++ b/src/V3Broken.cpp @@ -191,7 +191,7 @@ public: public: // CONSTRUCTORS BrokenTable() {} - virtual ~BrokenTable() {} + virtual ~BrokenTable() override {} }; BrokenTable::NodeMap BrokenTable::s_nodes; @@ -231,7 +231,7 @@ private: public: // CONSTRUCTORS explicit BrokenMarkVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~BrokenMarkVisitor() {} + virtual ~BrokenMarkVisitor() override {} }; //###################################################################### @@ -286,7 +286,7 @@ private: public: // CONSTRUCTORS explicit BrokenCheckVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~BrokenCheckVisitor() {} + virtual ~BrokenCheckVisitor() override {} }; //###################################################################### diff --git a/src/V3CUse.cpp b/src/V3CUse.cpp index 0b7247fcc..6153d04c6 100644 --- a/src/V3CUse.cpp +++ b/src/V3CUse.cpp @@ -111,7 +111,7 @@ public: , m_impOnly(false) { iterate(nodep); } - virtual ~CUseDTypeVisitor() {} + virtual ~CUseDTypeVisitor() override {} VL_UNCOPYABLE(CUseDTypeVisitor); }; @@ -212,7 +212,7 @@ public: : m_state(nodep) { iterate(nodep); } - virtual ~CUseVisitor() {} + virtual ~CUseVisitor() override {} VL_UNCOPYABLE(CUseVisitor); }; diff --git a/src/V3Case.cpp b/src/V3Case.cpp index a96837fbb..dd0fe6a03 100644 --- a/src/V3Case.cpp +++ b/src/V3Case.cpp @@ -113,7 +113,7 @@ public: m_caseExprp = nullptr; iterate(nodep); } - virtual ~CaseLintVisitor() {} + virtual ~CaseLintVisitor() override {} }; //###################################################################### @@ -494,7 +494,7 @@ public: for (uint32_t i = 0; i < (1UL << CASE_OVERLAP_WIDTH); ++i) m_valueItem[i] = nullptr; iterate(nodep); } - virtual ~CaseVisitor() { + virtual ~CaseVisitor() override { V3Stats::addStat("Optimizations, Cases parallelized", m_statCaseFast); V3Stats::addStat("Optimizations, Cases complex", m_statCaseSlow); } diff --git a/src/V3Cast.cpp b/src/V3Cast.cpp index cc74d2da6..66fb537c0 100644 --- a/src/V3Cast.cpp +++ b/src/V3Cast.cpp @@ -193,7 +193,7 @@ private: public: // CONSTRUCTORS explicit CastVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~CastVisitor() {} + virtual ~CastVisitor() override {} }; //###################################################################### diff --git a/src/V3Cdc.cpp b/src/V3Cdc.cpp index 0d8c0668c..a2396c765 100644 --- a/src/V3Cdc.cpp +++ b/src/V3Cdc.cpp @@ -68,9 +68,9 @@ public: , m_srcDomainSet(false) , m_dstDomainSet(false) , m_asyncPath(false) {} - virtual ~CdcEitherVertex() {} + virtual ~CdcEitherVertex() override {} // ACCESSORS - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual FileLine* fileline() const override { return nodep()->fileline(); } AstScope* scopep() const { return m_scopep; } AstNode* nodep() const { return m_nodep; } AstSenTree* srcDomainp() const { return m_srcDomainp; } @@ -96,11 +96,11 @@ public: , m_varScp(varScp) , m_cntAsyncRst(0) , m_fromFlop(false) {} - virtual ~CdcVarVertex() {} + virtual ~CdcVarVertex() override {} // ACCESSORS AstVarScope* varScp() const { return m_varScp; } - virtual string name() const { return (cvtToHex(m_varScp) + " " + varScp()->name()); } - virtual string dotColor() const { + virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); } + virtual string dotColor() const override { return fromFlop() ? "green" : cntAsyncRst() ? "red" : "blue"; } int cntAsyncRst() const { return m_cntAsyncRst; } @@ -121,10 +121,12 @@ public: srcDomainp(sensenodep); dstDomainp(sensenodep); } - virtual ~CdcLogicVertex() {} + virtual ~CdcLogicVertex() override {} // ACCESSORS - virtual string name() const { return (cvtToHex(nodep()) + "@" + scopep()->prettyName()); } - virtual string dotColor() const { return hazard() ? "black" : "yellow"; } + virtual string name() const override { + return (cvtToHex(nodep()) + "@" + scopep()->prettyName()); + } + virtual string dotColor() const override { return hazard() ? "black" : "yellow"; } bool hazard() const { return m_hazard; } void setHazard(AstNode* nodep) { m_hazard = true; @@ -172,7 +174,7 @@ public: m_prefix = prefix; iterate(nodep); } - virtual ~CdcDumpVisitor() {} + virtual ~CdcDumpVisitor() override {} }; //###################################################################### @@ -200,7 +202,7 @@ public: m_maxFilenameLen = 0; iterate(nodep); } - virtual ~CdcWidthVisitor() {} + virtual ~CdcWidthVisitor() override {} // ACCESSORS int maxWidth() { size_t width = 1; @@ -767,7 +769,7 @@ public: *m_ofp << endl; } } - virtual ~CdcVisitor() { + virtual ~CdcVisitor() override { if (m_ofp) VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr); } }; diff --git a/src/V3Changed.cpp b/src/V3Changed.cpp index d290fd5be..2132773f2 100644 --- a/src/V3Changed.cpp +++ b/src/V3Changed.cpp @@ -216,7 +216,7 @@ public: m_newLvEqnp->deleteTree(); m_newRvEqnp->deleteTree(); } - virtual ~ChangedInsertVisitor() {} + virtual ~ChangedInsertVisitor() override {} VL_UNCOPYABLE(ChangedInsertVisitor); }; @@ -288,7 +288,7 @@ public: m_statep = statep; iterate(nodep); } - virtual ~ChangedVisitor() {} + virtual ~ChangedVisitor() override {} }; //###################################################################### diff --git a/src/V3Class.cpp b/src/V3Class.cpp index 96c125bb4..36532b7e1 100644 --- a/src/V3Class.cpp +++ b/src/V3Class.cpp @@ -120,7 +120,7 @@ public: : m_classScopep(nullptr) { iterate(nodep); } - virtual ~ClassVisitor() { + virtual ~ClassVisitor() override { for (MoveVector::iterator it = m_moves.begin(); it != m_moves.end(); ++it) { it->second->addVarp(it->first->unlinkFrBack()); } diff --git a/src/V3Clean.cpp b/src/V3Clean.cpp index 22fcdf336..4981e38cd 100644 --- a/src/V3Clean.cpp +++ b/src/V3Clean.cpp @@ -304,7 +304,7 @@ public: m_modp = nullptr; iterate(nodep); } - virtual ~CleanVisitor() {} + virtual ~CleanVisitor() override {} }; //###################################################################### diff --git a/src/V3Clock.cpp b/src/V3Clock.cpp index 5fe6f51c0..a00348211 100644 --- a/src/V3Clock.cpp +++ b/src/V3Clock.cpp @@ -418,7 +418,7 @@ public: // easily without iterating through the tree. nodep->evalp(m_evalFuncp); } - virtual ~ClockVisitor() {} + virtual ~ClockVisitor() override {} }; //###################################################################### diff --git a/src/V3Combine.cpp b/src/V3Combine.cpp index b713b7b39..1deb9ed40 100644 --- a/src/V3Combine.cpp +++ b/src/V3Combine.cpp @@ -54,7 +54,7 @@ protected: // STATE // METHODS - virtual ~CombBaseVisitor() {} + virtual ~CombBaseVisitor() override {} VL_DEBUG_FUNC; // Declare debug() }; @@ -130,7 +130,7 @@ private: public: // CONSTRUCTORS CombCallVisitor() {} - virtual ~CombCallVisitor() {} + virtual ~CombCallVisitor() override {} void main(AstNetlist* nodep) { iterate(nodep); } }; @@ -151,7 +151,7 @@ private: public: // CONSTRUCTORS explicit CombMarkVisitor(AstNode* nodep) { iterate(nodep); } - virtual ~CombMarkVisitor() {} + virtual ~CombMarkVisitor() override {} }; //###################################################################### @@ -466,7 +466,7 @@ public: m_walkLast2p = nullptr; iterate(nodep); } - virtual ~CombineVisitor() { // + virtual ~CombineVisitor() override { // V3Stats::addStat("Optimizations, Combined CFuncs", m_statCombs); } }; diff --git a/src/V3Const.cpp b/src/V3Const.cpp index 04e059036..784528c2b 100644 --- a/src/V3Const.cpp +++ b/src/V3Const.cpp @@ -52,7 +52,7 @@ public: AstNode::user4ClearTree(); // Check marked InUse before we're called iterate(nodep); } - virtual ~ConstVarMarkVisitor() {} + virtual ~ConstVarMarkVisitor() override {} }; class ConstVarFindVisitor : public AstNVisitor { @@ -74,7 +74,7 @@ public: m_found = false; iterateAndNextNull(nodep); } - virtual ~ConstVarFindVisitor() {} + virtual ~ConstVarFindVisitor() override {} // METHODS bool found() const { return m_found; } }; @@ -2579,7 +2579,7 @@ public: } // clang-format on } - virtual ~ConstVisitor() {} + virtual ~ConstVisitor() override {} AstNode* mainAcceptEdit(AstNode* nodep) { // Operate starting at a random place return iterateSubtreeReturnEdits(nodep); diff --git a/src/V3Coverage.cpp b/src/V3Coverage.cpp index 90a91952d..1942aa0ad 100644 --- a/src/V3Coverage.cpp +++ b/src/V3Coverage.cpp @@ -551,7 +551,7 @@ public: m_inToggleOff = false; iterateChildren(rootp); } - virtual ~CoverageVisitor() {} + virtual ~CoverageVisitor() override {} }; //###################################################################### diff --git a/src/V3CoverageJoin.cpp b/src/V3CoverageJoin.cpp index ed4f8cba2..c78818f4b 100644 --- a/src/V3CoverageJoin.cpp +++ b/src/V3CoverageJoin.cpp @@ -114,7 +114,7 @@ private: public: // CONSTRUCTORS explicit CoverageJoinVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~CoverageJoinVisitor() { + virtual ~CoverageJoinVisitor() override { V3Stats::addStat("Coverage, Toggle points joined", m_statToggleJoins); } }; diff --git a/src/V3Dead.cpp b/src/V3Dead.cpp index e4704b67f..10e547884 100644 --- a/src/V3Dead.cpp +++ b/src/V3Dead.cpp @@ -63,7 +63,7 @@ private: public: // CONSTRUCTORS explicit DeadModVisitor(AstNodeModule* nodep) { iterate(nodep); } - virtual ~DeadModVisitor() {} + virtual ~DeadModVisitor() override {} }; //###################################################################### @@ -465,7 +465,7 @@ public: // We may have removed some datatypes, cleanup nodep->typeTablep()->repairCache(); } - virtual ~DeadVisitor() {} + virtual ~DeadVisitor() override {} }; //###################################################################### diff --git a/src/V3Delayed.cpp b/src/V3Delayed.cpp index 0aee58150..af0548f99 100644 --- a/src/V3Delayed.cpp +++ b/src/V3Delayed.cpp @@ -486,7 +486,7 @@ public: iterate(nodep); } - virtual ~DelayedVisitor() { + virtual ~DelayedVisitor() override { V3Stats::addStat("Optimizations, Delayed shared-sets", m_statSharedSet); } }; diff --git a/src/V3Depth.cpp b/src/V3Depth.cpp index 96a9d4f3c..1a64eb76b 100644 --- a/src/V3Depth.cpp +++ b/src/V3Depth.cpp @@ -160,7 +160,7 @@ public: // iterate(nodep); } - virtual ~DepthVisitor() {} + virtual ~DepthVisitor() override {} }; //###################################################################### diff --git a/src/V3DepthBlock.cpp b/src/V3DepthBlock.cpp index fd5572a43..db9b7332d 100644 --- a/src/V3DepthBlock.cpp +++ b/src/V3DepthBlock.cpp @@ -127,7 +127,7 @@ public: // iterate(nodep); } - virtual ~DepthBlockVisitor() {} + virtual ~DepthBlockVisitor() override {} }; //###################################################################### diff --git a/src/V3Descope.cpp b/src/V3Descope.cpp index 3bf522614..4fcf257eb 100644 --- a/src/V3Descope.cpp +++ b/src/V3Descope.cpp @@ -301,7 +301,7 @@ public: , m_needThis(false) { iterate(nodep); } - virtual ~DescopeVisitor() {} + virtual ~DescopeVisitor() override {} }; //###################################################################### diff --git a/src/V3EmitC.cpp b/src/V3EmitC.cpp index 434257412..f3cfdebb7 100644 --- a/src/V3EmitC.cpp +++ b/src/V3EmitC.cpp @@ -1238,7 +1238,7 @@ public: m_trackText = trackText; iterate(nodep); } - virtual ~EmitCStmts() {} + virtual ~EmitCStmts() override {} }; //###################################################################### @@ -1257,12 +1257,12 @@ public: , m_serial(++m_serialNext) {} virtual ~EmitVarTspSorter() {} // METHODS - bool operator<(const TspStateBase& other) const { + virtual bool operator<(const TspStateBase& other) const override { return operator<(dynamic_cast(other)); } bool operator<(const EmitVarTspSorter& other) const { return m_serial < other.m_serial; } const MTaskIdSet& mtaskIds() const { return m_mtaskIds; } - virtual int cost(const TspStateBase* otherp) const { + virtual int cost(const TspStateBase* otherp) const override { return cost(dynamic_cast(otherp)); } virtual int cost(const EmitVarTspSorter* otherp) const { @@ -1776,7 +1776,7 @@ public: m_slow = false; m_fast = false; } - virtual ~EmitCImp() {} + virtual ~EmitCImp() override {} void mainImp(AstNodeModule* modp, bool slow); void mainInt(AstNodeModule* modp); void mainDoFunc(AstCFunc* nodep) { iterate(nodep); } @@ -3107,7 +3107,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) { + "C* tfp, int levels, int options = 0);\n"); if (optSystemC()) { puts("/// SC tracing; avoid overloaded virtual function lint warning\n"); - puts("virtual void trace(sc_trace_file* tfp) const { " + puts("virtual void trace(sc_trace_file* tfp) const override { " "::sc_core::sc_module::trace(tfp); }\n"); } } @@ -3769,7 +3769,7 @@ public: m_slow = slow; m_enumNum = 0; } - virtual ~EmitCTrace() {} + virtual ~EmitCTrace() override {} void main() { // Put out the file newOutCFile(0); diff --git a/src/V3EmitCBase.h b/src/V3EmitCBase.h index 85872e465..9d502288e 100644 --- a/src/V3EmitCBase.h +++ b/src/V3EmitCBase.h @@ -110,7 +110,7 @@ public: m_ofp = nullptr; m_trackText = false; } - virtual ~EmitCBaseVisitor() {} + virtual ~EmitCBaseVisitor() override {} }; //###################################################################### @@ -132,7 +132,7 @@ public: m_count = 0; iterate(nodep); } - virtual ~EmitCBaseCounterVisitor() {} + virtual ~EmitCBaseCounterVisitor() override {} int count() const { return m_count; } }; diff --git a/src/V3EmitCMain.cpp b/src/V3EmitCMain.cpp index 6eba5ec84..279d8e48e 100644 --- a/src/V3EmitCMain.cpp +++ b/src/V3EmitCMain.cpp @@ -31,7 +31,7 @@ class EmitCMain : EmitCBaseVisitor { // VISITORS // This visitor doesn't really iterate, but exist to appease base class - virtual void visit(AstNode* nodep) { iterateChildren(nodep); } // LCOV_EXCL_LINE + virtual void visit(AstNode* nodep) override { iterateChildren(nodep); } // LCOV_EXCL_LINE public: // CONSTRUCTORS diff --git a/src/V3EmitV.cpp b/src/V3EmitV.cpp index 0c7ecd86b..126a5660f 100644 --- a/src/V3EmitV.cpp +++ b/src/V3EmitV.cpp @@ -665,7 +665,7 @@ public: m_suppressVarSemi = false; m_sensesp = domainp; } - virtual ~EmitVBaseVisitor() {} + virtual ~EmitVBaseVisitor() override {} }; //###################################################################### @@ -676,11 +676,11 @@ class EmitVFileVisitor : public EmitVBaseVisitor { V3OutFile* m_ofp; // METHODS V3OutFile* ofp() const { return m_ofp; } - virtual void puts(const string& str) { ofp()->puts(str); } - virtual void putbs(const string& str) { ofp()->putbs(str); } - virtual void putfs(AstNode*, const string& str) { putbs(str); } - virtual void putqs(AstNode*, const string& str) { putbs(str); } - virtual void putsNoTracking(const string& str) { ofp()->putsNoTracking(str); } + virtual void puts(const string& str) override { ofp()->puts(str); } + virtual void putbs(const string& str) override { ofp()->putbs(str); } + virtual void putfs(AstNode*, const string& str) override { putbs(str); } + virtual void putqs(AstNode*, const string& str) override { putbs(str); } + virtual void putsNoTracking(const string& str) override { ofp()->putsNoTracking(str); } public: EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp, bool trackText = false, @@ -690,7 +690,7 @@ public: m_suppressVarSemi = suppressVarSemi; iterate(nodep); } - virtual ~EmitVFileVisitor() {} + virtual ~EmitVFileVisitor() override {} }; //###################################################################### @@ -700,18 +700,18 @@ class EmitVStreamVisitor : public EmitVBaseVisitor { // MEMBERS std::ostream& m_os; // METHODS - virtual void putsNoTracking(const string& str) { m_os << str; } - virtual void puts(const string& str) { putsNoTracking(str); } - virtual void putbs(const string& str) { puts(str); } - virtual void putfs(AstNode*, const string& str) { putbs(str); } - virtual void putqs(AstNode*, const string& str) { putbs(str); } + virtual void putsNoTracking(const string& str) override { m_os << str; } + virtual void puts(const string& str) override { putsNoTracking(str); } + virtual void putbs(const string& str) override { puts(str); } + virtual void putfs(AstNode*, const string& str) override { putbs(str); } + virtual void putqs(AstNode*, const string& str) override { putbs(str); } public: EmitVStreamVisitor(AstNode* nodep, std::ostream& os) : m_os(os) { iterate(nodep); } - virtual ~EmitVStreamVisitor() {} + virtual ~EmitVStreamVisitor() override {} }; //###################################################################### @@ -724,7 +724,7 @@ class EmitVPrefixedFormatter : public V3OutFormatter { int m_column; // Rough location; need just zero or non-zero FileLine* m_prefixFl; // METHODS - virtual void putcOutput(char chr) { + virtual void putcOutput(char chr) override { if (chr == '\n') { m_column = 0; m_os << chr; @@ -755,7 +755,7 @@ public: = v3Global.rootp() ->fileline(); // NETLIST's fileline instead of nullptr to avoid nullptr checks } - virtual ~EmitVPrefixedFormatter() { + virtual ~EmitVPrefixedFormatter() override { if (m_column) puts("\n"); } }; @@ -765,13 +765,13 @@ class EmitVPrefixedVisitor : public EmitVBaseVisitor { EmitVPrefixedFormatter m_formatter; // Special verilog formatter (Way down the // inheritance is another unused V3OutFormatter) // METHODS - virtual void putsNoTracking(const string& str) { m_formatter.putsNoTracking(str); } - virtual void puts(const string& str) { m_formatter.puts(str); } + virtual void putsNoTracking(const string& str) override { m_formatter.putsNoTracking(str); } + virtual void puts(const string& str) override { m_formatter.puts(str); } // We don't use m_formatter's putbs because the tokens will change filelines // and insert returns at the proper locations - virtual void putbs(const string& str) { m_formatter.puts(str); } - virtual void putfs(AstNode* nodep, const string& str) { putfsqs(nodep, str, false); } - virtual void putqs(AstNode* nodep, const string& str) { putfsqs(nodep, str, true); } + virtual void putbs(const string& str) override { m_formatter.puts(str); } + virtual void putfs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, false); } + virtual void putqs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, true); } void putfsqs(AstNode* nodep, const string& str, bool quiet) { if (m_formatter.prefixFl() != nodep->fileline()) { m_formatter.prefixFl(nodep->fileline()); @@ -789,7 +789,7 @@ public: if (user3mark) { AstUser3InUse::check(); } iterate(nodep); } - virtual ~EmitVPrefixedVisitor() {} + virtual ~EmitVPrefixedVisitor() override {} }; //###################################################################### diff --git a/src/V3EmitXml.cpp b/src/V3EmitXml.cpp index caebcd4a2..e760f600d 100644 --- a/src/V3EmitXml.cpp +++ b/src/V3EmitXml.cpp @@ -250,7 +250,7 @@ public: m_id = 0; iterate(nodep); } - virtual ~EmitXmlFileVisitor() {} + virtual ~EmitXmlFileVisitor() override {} }; //###################################################################### @@ -301,7 +301,7 @@ public: } m_os << "\n"; } - virtual ~ModuleFilesXmlVisitor() {} + virtual ~ModuleFilesXmlVisitor() override {} }; //###################################################################### @@ -368,7 +368,7 @@ public: // Operate on whole netlist nodep->accept(*this); } - virtual ~HierCellsXmlVisitor() {} + virtual ~HierCellsXmlVisitor() override {} }; //###################################################################### diff --git a/src/V3Expand.cpp b/src/V3Expand.cpp index 7aa4f6ad0..9bbf7c72f 100644 --- a/src/V3Expand.cpp +++ b/src/V3Expand.cpp @@ -882,7 +882,7 @@ public: m_stmtp = nullptr; iterate(nodep); } - virtual ~ExpandVisitor() {} + virtual ~ExpandVisitor() override {} }; //---------------------------------------------------------------------- diff --git a/src/V3File.h b/src/V3File.h index e98496bc9..5e1dda601 100644 --- a/src/V3File.h +++ b/src/V3File.h @@ -182,12 +182,12 @@ class V3OutFile : public V3OutFormatter { public: V3OutFile(const string& filename, V3OutFormatter::Language lang); - virtual ~V3OutFile(); + virtual ~V3OutFile() override; void putsForceIncs(); private: // CALLBACKS - virtual void putcOutput(char chr) { fputc(chr, m_fp); } + virtual void putcOutput(char chr) override { fputc(chr, m_fp); } }; class V3OutCFile : public V3OutFile { @@ -199,7 +199,7 @@ public: , m_guard(false) { resetPrivate(); } - virtual ~V3OutCFile() {} + virtual ~V3OutCFile() override {} virtual void putsHeader() { puts("// Verilated -*- C++ -*-\n"); } virtual void putsIntTopInclude() { putsForceIncs(); } virtual void putsGuard(); @@ -223,9 +223,9 @@ class V3OutScFile : public V3OutCFile { public: explicit V3OutScFile(const string& filename) : V3OutCFile(filename) {} - virtual ~V3OutScFile() {} - virtual void putsHeader() { puts("// Verilated -*- SystemC -*-\n"); } - virtual void putsIntTopInclude() { + virtual ~V3OutScFile() override {} + virtual void putsHeader() override { puts("// Verilated -*- SystemC -*-\n"); } + virtual void putsIntTopInclude() override { putsForceIncs(); puts("#include \"systemc.h\"\n"); puts("#include \"verilated_sc.h\"\n"); @@ -236,7 +236,7 @@ class V3OutVFile : public V3OutFile { public: explicit V3OutVFile(const string& filename) : V3OutFile(filename, V3OutFormatter::LA_VERILOG) {} - virtual ~V3OutVFile() {} + virtual ~V3OutVFile() override {} virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); } }; @@ -246,7 +246,7 @@ public: : V3OutFile(filename, V3OutFormatter::LA_XML) { blockIndent(2); } - virtual ~V3OutXmlFile() {} + virtual ~V3OutXmlFile() override {} virtual void putsHeader() { puts("\n"); } }; @@ -254,7 +254,7 @@ class V3OutMkFile : public V3OutFile { public: explicit V3OutMkFile(const string& filename) : V3OutFile(filename, V3OutFormatter::LA_MK) {} - virtual ~V3OutMkFile() {} + virtual ~V3OutMkFile() override {} virtual void putsHeader() { puts("# Verilated -*- Makefile -*-\n"); } // No automatic indentation yet. void puts(const char* strg) { putsNoTracking(strg); } diff --git a/src/V3Gate.cpp b/src/V3Gate.cpp index 09ef06951..9c0405539 100644 --- a/src/V3Gate.cpp +++ b/src/V3Gate.cpp @@ -78,9 +78,9 @@ public: , m_reducible(true) , m_dedupable(true) , m_consumed(false) {} - virtual ~GateEitherVertex() {} + virtual ~GateEitherVertex() override {} // ACCESSORS - virtual string dotStyle() const { return m_consumed ? "" : "dotted"; } + virtual string dotStyle() const override { return m_consumed ? "" : "dotted"; } AstScope* scopep() const { return m_scopep; } bool reducible() const { return m_reducible; } bool dedupable() const { return m_dedupable; } @@ -140,11 +140,11 @@ public: , m_isClock(false) , m_rstSyncNodep(nullptr) , m_rstAsyncNodep(nullptr) {} - virtual ~GateVarVertex() {} + virtual ~GateVarVertex() override {} // ACCESSORS AstVarScope* varScp() const { return m_varScp; } - virtual string name() const { return (cvtToHex(m_varScp) + " " + varScp()->name()); } - virtual string dotColor() const { return "blue"; } + virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); } + virtual string dotColor() const override { return "blue"; } bool isTop() const { return m_isTop; } void setIsTop() { m_isTop = true; } bool isClock() const { return m_isClock; } @@ -165,7 +165,9 @@ public: setIsClock(); } } - VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser(0)) { return v.visit(this, vu); } + virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser(0)) override { + return v.visit(this, vu); + } }; class GateLogicVertex : public GateEitherVertex { @@ -179,15 +181,19 @@ public: , m_nodep(nodep) , m_activep(activep) , m_slow(slow) {} - virtual ~GateLogicVertex() {} + virtual ~GateLogicVertex() override {} // ACCESSORS - virtual string name() const { return (cvtToHex(m_nodep) + "@" + scopep()->prettyName()); } - virtual string dotColor() const { return "purple"; } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { + return (cvtToHex(m_nodep) + "@" + scopep()->prettyName()); + } + virtual string dotColor() const override { return "purple"; } + virtual FileLine* fileline() const override { return nodep()->fileline(); } AstNode* nodep() const { return m_nodep; } AstActive* activep() const { return m_activep; } bool slow() const { return m_slow; } - VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser(0)) { return v.visit(this, vu); } + virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser(0)) override { + return v.visit(this, vu); + } }; //###################################################################### @@ -294,7 +300,7 @@ public: } if (debug() >= 9 && !m_isSimple) nodep->dumpTree(cout, " gate!Ok: "); } - virtual ~GateOkVisitor() {} + virtual ~GateOkVisitor() override {} // PUBLIC METHODS bool isSimple() const { return m_isSimple; } AstNode* substTree() const { return m_substTreep; } @@ -538,7 +544,7 @@ public: m_inSlow = false; iterate(nodep); } - virtual ~GateVisitor() { + virtual ~GateVisitor() override { V3Stats::addStat("Optimizations, Gate sigs deleted", m_statSigs); V3Stats::addStat("Optimizations, Gate inputs replaced", m_statRefs); V3Stats::addStat("Optimizations, Gate sigs deduped", m_statDedupLogic); @@ -878,7 +884,7 @@ private: public: // CONSTRUCTORS - virtual ~GateElimVisitor() {} + virtual ~GateElimVisitor() override {} GateElimVisitor(AstNode* nodep, AstVarScope* varscp, AstNode* replaceTreep, GateDedupeVarVisitor* varVisp) { UINFO(9, " elimvisitor " << nodep << endl); @@ -1143,7 +1149,7 @@ private: GateDedupeVarVisitor m_varVisitor; // Looks for a dupe of the logic int m_depth; // Iteration depth - virtual VNUser visit(GateVarVertex* vvertexp, VNUser) { + virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override { // Check that we haven't been here before if (m_depth > GATE_DEDUP_MAX_DEPTH) return VNUser(0); // Break loops; before user2 set so hit this vertex later @@ -1210,7 +1216,7 @@ private: // Given iterated logic, starting at vu which was consumer's GateVarVertex // Returns a varref that has the same logic input; or nullptr if none - virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) { + virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override { lvertexp->iterateInEdges(*this); GateVarVertex* consumerVvertexpp = static_cast(vu.toGraphVertex()); @@ -1290,7 +1296,7 @@ private: } } - virtual VNUser visit(GateVarVertex* vvertexp, VNUser) { + virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override { for (V3GraphEdge* edgep = vvertexp->inBeginp(); edgep;) { V3GraphEdge* oldedgep = edgep; edgep = edgep->inNextp(); // for recursive since the edge could be deleted @@ -1363,7 +1369,7 @@ private: } return VNUser(0); } - virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) { // + virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override { // return VNUser(0); } @@ -1433,7 +1439,7 @@ public: m_found_offset = 0; m_found = false; } - virtual ~GateConcatVisitor() {} + virtual ~GateConcatVisitor() override {} // PUBLIC METHODS bool concatOffset(AstConcat* concatp, AstVarScope* vscp, int& offsetr) { m_vscp = vscp; @@ -1474,7 +1480,7 @@ private: int m_total_seen_clk_vectors; int m_total_decomposed_clk_vectors; - virtual VNUser visit(GateVarVertex* vvertexp, VNUser vu) { + virtual VNUser visit(GateVarVertex* vvertexp, VNUser vu) override { // Check that we haven't been here before AstVarScope* vsp = vvertexp->varScp(); if (vsp->user2SetOnce()) return VNUser(0); @@ -1491,7 +1497,7 @@ private: return VNUser(0); // Unused } - virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) { + virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override { GateClkDecompState* currState = reinterpret_cast(vu.c()); int clk_offset = currState->m_offset; if (const AstAssignW* assignp = VN_CAST(lvertexp->nodep(), AssignW)) { @@ -1564,7 +1570,7 @@ public: m_total_seen_clk_vectors = 0; m_total_decomposed_clk_vectors = 0; } - virtual ~GateClkDecompGraphVisitor() { + virtual ~GateClkDecompGraphVisitor() override { V3Stats::addStat("Optimizations, Clocker seen vectors", m_total_seen_clk_vectors); V3Stats::addStat("Optimizations, Clocker decomposed vectors", m_total_decomposed_clk_vectors); @@ -1621,7 +1627,7 @@ private: public: // CONSTRUCTORS explicit GateDeassignVisitor(AstNode* nodep) { iterate(nodep); } - virtual ~GateDeassignVisitor() {} + virtual ~GateDeassignVisitor() override {} }; //###################################################################### diff --git a/src/V3GenClk.cpp b/src/V3GenClk.cpp index ccf8535e4..07805aff9 100644 --- a/src/V3GenClk.cpp +++ b/src/V3GenClk.cpp @@ -124,7 +124,7 @@ public: m_activep = nullptr; iterate(nodep); } - virtual ~GenClkRenameVisitor() {} + virtual ~GenClkRenameVisitor() override {} }; //###################################################################### @@ -223,7 +223,7 @@ public: , m_topModp(nullptr) { iterate(nodep); } - virtual ~GenClkReadVisitor() {} + virtual ~GenClkReadVisitor() override {} }; //###################################################################### diff --git a/src/V3GraphAcyc.cpp b/src/V3GraphAcyc.cpp index 1360f0b0c..222712aff 100644 --- a/src/V3GraphAcyc.cpp +++ b/src/V3GraphAcyc.cpp @@ -45,13 +45,13 @@ public: , m_storedRank(0) , m_onWorkList(false) , m_deleted(false) {} - virtual ~GraphAcycVertex() {} + virtual ~GraphAcycVertex() override {} V3GraphVertex* origVertexp() const { return m_origVertexp; } void setDelete() { m_deleted = true; } bool isDelete() const { return m_deleted; } - virtual string name() const { return m_origVertexp->name(); } - virtual string dotColor() const { return m_origVertexp->dotColor(); } - virtual FileLine* fileline() const { return m_origVertexp->fileline(); } + virtual string name() const override { return m_origVertexp->name(); } + virtual string dotColor() const override { return m_origVertexp->dotColor(); } + virtual FileLine* fileline() const override { return m_origVertexp->fileline(); } }; //-------------------------------------------------------------------- @@ -70,9 +70,11 @@ public: GraphAcycEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight, bool cutable = false) : V3GraphEdge(graphp, fromp, top, weight, cutable) {} - virtual ~GraphAcycEdge() {} + virtual ~GraphAcycEdge() override {} // yellow=we might still cut it, else oldEdge: yellowGreen=made uncutable, red=uncutable - virtual string dotColor() const { return (cutable() ? "yellow" : origEdgep()->dotColor()); } + virtual string dotColor() const override { + return (cutable() ? "yellow" : origEdgep()->dotColor()); + } }; //-------------------------------------------------------------------- diff --git a/src/V3GraphDfa.h b/src/V3GraphDfa.h index 85fc47f60..1e757c426 100644 --- a/src/V3GraphDfa.h +++ b/src/V3GraphDfa.h @@ -62,7 +62,7 @@ class DfaGraph : public V3Graph { public: // CONSTRUCTORS DfaGraph() {} - virtual ~DfaGraph() {} + virtual ~DfaGraph() override {} // METHODS /// Find start node DfaVertex* findStart(); @@ -93,10 +93,12 @@ public: virtual DfaVertex* clone(DfaGraph* graphp) { return new DfaVertex(graphp, start(), accepting()); } - virtual ~DfaVertex() {} + virtual ~DfaVertex() override {} // ACCESSORS - virtual string dotShape() const { return (accepting() ? "doublecircle" : ""); } - virtual string dotColor() const { return start() ? "blue" : (color() ? "red" : "black"); } + virtual string dotShape() const override { return (accepting() ? "doublecircle" : ""); } + virtual string dotColor() const override { + return start() ? "blue" : (color() ? "red" : "black"); + } bool start() const { return m_start; } void start(bool flag) { m_start = flag; } bool accepting() const { return m_accepting; } @@ -126,16 +128,18 @@ public: : V3GraphEdge(graphp, fromp, top, copyfrom->weight()) , m_input(copyfrom->input()) , m_complement(copyfrom->complement()) {} - virtual ~DfaEdge() {} + virtual ~DfaEdge() override {} // METHODS - virtual string dotColor() const { return (na() ? "yellow" : epsilon() ? "green" : "black"); } - virtual string dotLabel() const { + virtual string dotColor() const override { + return (na() ? "yellow" : epsilon() ? "green" : "black"); + } + virtual string dotLabel() const override { return (na() ? "" : epsilon() ? "e" : complement() ? ("not " + cvtToStr(input().toInt())) : cvtToStr(input().toInt())); } - virtual string dotStyle() const { return (na() || cutable()) ? "dashed" : ""; } + virtual string dotStyle() const override { return (na() || cutable()) ? "dashed" : ""; } bool epsilon() const { return input().toInt() == EPSILON().toInt(); } bool na() const { return input().toInt() == NA().toInt(); } bool complement() const { return m_complement; } diff --git a/src/V3GraphTest.cpp b/src/V3GraphTest.cpp index 19f489f0c..8765c67a2 100644 --- a/src/V3GraphTest.cpp +++ b/src/V3GraphTest.cpp @@ -57,18 +57,18 @@ public: V3GraphTestVertex(V3Graph* graphp, const string& name) : V3GraphVertex(graphp) , m_name(name) {} - virtual ~V3GraphTestVertex() {} + virtual ~V3GraphTestVertex() override {} // ACCESSORS - virtual string name() const { return m_name; } + virtual string name() const override { return m_name; } }; class V3GraphTestVarVertex : public V3GraphTestVertex { public: V3GraphTestVarVertex(V3Graph* graphp, const string& name) : V3GraphTestVertex(graphp, name) {} - virtual ~V3GraphTestVarVertex() {} + virtual ~V3GraphTestVarVertex() override {} // ACCESSORS - virtual string dotColor() const { return "blue"; } + virtual string dotColor() const override { return "blue"; } }; //###################################################################### @@ -77,8 +77,8 @@ public: class V3GraphTestStrong : public V3GraphTest { public: - virtual string name() { return "strong"; } - virtual void runTest() { + virtual string name() override { return "strong"; } + virtual void runTest() override { V3Graph* gp = &m_graph; // Verify we break edges at a good point // A simple alg would make 3 breaks, below only requires b->i to break @@ -115,8 +115,8 @@ public: class V3GraphTestAcyc : public V3GraphTest { public: - virtual string name() { return "acyc"; } - virtual void runTest() { + virtual string name() override { return "acyc"; } + virtual void runTest() override { V3Graph* gp = &m_graph; // Verify we break edges at a good point // A simple alg would make 3 breaks, below only requires b->i to break @@ -143,8 +143,8 @@ public: class V3GraphTestVars : public V3GraphTest { public: - virtual string name() { return "vars"; } - virtual void runTest() { + virtual string name() override { return "vars"; } + virtual void runTest() override { V3Graph* gp = &m_graph; V3GraphTestVertex* clk = new V3GraphTestVarVertex(gp, "$clk"); @@ -267,16 +267,16 @@ public: DfaTestVertex(DfaGraph* graphp, const string& name) : DfaVertex(graphp) , m_name(name) {} - virtual ~DfaTestVertex() {} + virtual ~DfaTestVertex() override {} // ACCESSORS - virtual string name() const { return m_name; } + virtual string name() const override { return m_name; } }; class V3GraphTestDfa : public V3GraphTest { public: - virtual string name() { return "dfa"; } - virtual void runTest() { + virtual string name() override { return "dfa"; } + virtual void runTest() override { DfaGraph* gp = &m_graph; // NFA Pattern for ( (LR) | (L*R)) Z @@ -330,8 +330,8 @@ class V3GraphTestImport : public V3GraphTest { #endif public: - virtual string name() { return "import"; } - virtual void runTest() { + virtual string name() override { return "import"; } + virtual void runTest() override { DfaGraph* gp = &m_graph; if (V3GraphTest::debug()) DfaGraph::debug(9); dotImport(); diff --git a/src/V3Hashed.cpp b/src/V3Hashed.cpp index c834c2e73..c473f8873 100644 --- a/src/V3Hashed.cpp +++ b/src/V3Hashed.cpp @@ -103,7 +103,7 @@ public: nodeHashIterate(const_cast(nodep)); } V3Hash finalHash() const { return m_lowerHash; } - virtual ~HashedVisitor() {} + virtual ~HashedVisitor() override {} }; //###################################################################### diff --git a/src/V3Inline.cpp b/src/V3Inline.cpp index adffa74af..5a17ab793 100644 --- a/src/V3Inline.cpp +++ b/src/V3Inline.cpp @@ -223,7 +223,7 @@ public: m_modp = nullptr; iterate(nodep); } - virtual ~InlineMarkVisitor() { + virtual ~InlineMarkVisitor() override { V3Stats::addStat("Optimizations, Inline unsupported", m_statUnsup); // Done with these, are not outputs AstNode::user2ClearTree(); @@ -257,7 +257,7 @@ public: explicit InlineCollectVisitor(AstNodeModule* nodep) { // passed OLD module, not new one iterate(nodep); } - virtual ~InlineCollectVisitor() {} + virtual ~InlineCollectVisitor() override {} }; //###################################################################### @@ -475,7 +475,7 @@ public: m_cellp = cellp; iterate(cloneModp); } - virtual ~InlineRelinkVisitor() {} + virtual ~InlineRelinkVisitor() override {} }; //###################################################################### @@ -618,7 +618,7 @@ public: m_modp = nullptr; iterate(nodep); } - virtual ~InlineVisitor() { // + virtual ~InlineVisitor() override { // V3Stats::addStat("Optimizations, Inlined cells", m_statCells); } }; @@ -709,7 +709,7 @@ private: public: // CONSTRUCTORS explicit InlineIntfRefVisitor(AstNode* nodep) { iterate(nodep); } - virtual ~InlineIntfRefVisitor() {} + virtual ~InlineIntfRefVisitor() override {} }; //###################################################################### diff --git a/src/V3Inst.cpp b/src/V3Inst.cpp index 3ad65819c..734233404 100644 --- a/src/V3Inst.cpp +++ b/src/V3Inst.cpp @@ -136,7 +136,7 @@ public: // iterate(nodep); } - virtual ~InstVisitor() {} + virtual ~InstVisitor() override {} }; //###################################################################### @@ -190,7 +190,7 @@ public: m_modVarNameMap.clear(); iterate(nodep); } - virtual ~InstDeModVarVisitor() {} + virtual ~InstDeModVarVisitor() override {} }; //###################################################################### @@ -472,7 +472,7 @@ public: // iterate(nodep); } - virtual ~InstDeVisitor() {} + virtual ~InstDeVisitor() override {} }; //###################################################################### diff --git a/src/V3InstrCount.cpp b/src/V3InstrCount.cpp index ff777e4f9..61f40e16c 100644 --- a/src/V3InstrCount.cpp +++ b/src/V3InstrCount.cpp @@ -77,7 +77,7 @@ public: , m_osp(osp) { if (nodep) iterate(nodep); } - virtual ~InstrCountVisitor() {} + virtual ~InstrCountVisitor() override {} // METHODS uint32_t instrCount() const { return m_instrCount; } @@ -280,7 +280,7 @@ public: UASSERT_OBJ(osp, nodep, "Don't call if not dumping"); if (nodep) iterate(nodep); } - virtual ~InstrCountDumpVisitor() {} + virtual ~InstrCountDumpVisitor() override {} private: // METHODS diff --git a/src/V3Life.cpp b/src/V3Life.cpp index 4e2bb6471..886d85730 100644 --- a/src/V3Life.cpp +++ b/src/V3Life.cpp @@ -453,7 +453,7 @@ public: if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr); } } - virtual ~LifeVisitor() { + virtual ~LifeVisitor() override { if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr); } VL_UNCOPYABLE(LifeVisitor); @@ -490,7 +490,7 @@ public: m_statep = statep; iterate(nodep); } - virtual ~LifeTopVisitor() {} + virtual ~LifeTopVisitor() override {} }; //###################################################################### diff --git a/src/V3LifePost.cpp b/src/V3LifePost.cpp index 7da2e5f7d..577e15a2f 100644 --- a/src/V3LifePost.cpp +++ b/src/V3LifePost.cpp @@ -94,7 +94,7 @@ public: : m_tracingCall(false) { iterate(nodep); } - virtual ~LifePostElimVisitor() {} + virtual ~LifePostElimVisitor() override {} }; //###################################################################### @@ -354,7 +354,7 @@ public: , m_mtasksGraphp(nullptr) { iterate(nodep); } - virtual ~LifePostDlyVisitor() { + virtual ~LifePostDlyVisitor() override { V3Stats::addStat("Optimizations, Lifetime postassign deletions", m_statAssnDel); } }; diff --git a/src/V3LinkCells.cpp b/src/V3LinkCells.cpp index 335c60190..1defaeff3 100644 --- a/src/V3LinkCells.cpp +++ b/src/V3LinkCells.cpp @@ -44,8 +44,8 @@ class LinkCellsGraph : public V3Graph { public: LinkCellsGraph() {} - virtual ~LinkCellsGraph() {} - virtual void loopsMessageCb(V3GraphVertex* vertexp); + virtual ~LinkCellsGraph() override {} + virtual void loopsMessageCb(V3GraphVertex* vertexp) override; }; class LinkCellsVertex : public V3GraphVertex { @@ -55,12 +55,12 @@ public: LinkCellsVertex(V3Graph* graphp, AstNodeModule* modp) : V3GraphVertex(graphp) , m_modp(modp) {} - virtual ~LinkCellsVertex() {} + virtual ~LinkCellsVertex() override {} AstNodeModule* modp() const { return m_modp; } - virtual string name() const { return modp()->name(); } - virtual FileLine* fileline() const { return modp()->fileline(); } + virtual string name() const override { return modp()->name(); } + virtual FileLine* fileline() const override { return modp()->fileline(); } // Recursive modules get space for maximum recursion - virtual uint32_t rankAdder() const { + virtual uint32_t rankAdder() const override { return m_modp->recursiveClone() ? (1 + v3Global.opt.moduleRecursionDepth()) : 1; } }; @@ -69,8 +69,8 @@ class LibraryVertex : public V3GraphVertex { public: explicit LibraryVertex(V3Graph* graphp) : V3GraphVertex(graphp) {} - virtual ~LibraryVertex() {} - virtual string name() const { return "*LIBRARY*"; } + virtual ~LibraryVertex() override {} + virtual string name() const override { return "*LIBRARY*"; } }; void LinkCellsGraph::loopsMessageCb(V3GraphVertex* vertexp) { @@ -521,7 +521,7 @@ public: } iterate(nodep); } - virtual ~LinkCellsVisitor() {} + virtual ~LinkCellsVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkDot.cpp b/src/V3LinkDot.cpp index c39915a9a..544a0bcec 100644 --- a/src/V3LinkDot.cpp +++ b/src/V3LinkDot.cpp @@ -78,19 +78,19 @@ class LinkNodeMatcherFTask : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { return VN_IS(nodep, NodeFTask); } + virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); } }; class LinkNodeMatcherModport : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { return VN_IS(nodep, Modport); } + virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); } }; class LinkNodeMatcherVar : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { return VN_IS(nodep, Var); } + virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Var); } }; class LinkNodeMatcherVarIO : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { + virtual bool nodeMatch(const AstNode* nodep) const override { const AstVar* varp = VN_CAST_CONST(nodep, Var); if (!varp) return false; return varp->isIO(); @@ -98,7 +98,7 @@ public: }; class LinkNodeMatcherVarParam : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { + virtual bool nodeMatch(const AstNode* nodep) const override { const AstVar* varp = VN_CAST_CONST(nodep, Var); if (!varp) return false; return varp->isParam(); @@ -106,7 +106,7 @@ public: }; class LinkNodeMatcherVarOrScope : public VNodeMatcher { public: - virtual bool nodeMatch(const AstNode* nodep) const { + virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Var) || VN_IS(nodep, Scope); } }; @@ -1267,7 +1267,7 @@ public: // iterate(rootp); } - virtual ~LinkDotFindVisitor() {} + virtual ~LinkDotFindVisitor() override {} }; //====================================================================== @@ -1434,7 +1434,7 @@ public: // iterate(rootp); } - virtual ~LinkDotParamVisitor() {} + virtual ~LinkDotParamVisitor() override {} }; //====================================================================== @@ -1590,7 +1590,7 @@ public: // iterate(rootp); } - virtual ~LinkDotScopeVisitor() {} + virtual ~LinkDotScopeVisitor() override {} }; //====================================================================== @@ -1675,7 +1675,7 @@ public: m_statep = statep; iterate(nodep); } - virtual ~LinkDotIfaceVisitor() {} + virtual ~LinkDotIfaceVisitor() override {} }; void LinkDotState::computeIfaceModSyms() { @@ -2825,7 +2825,7 @@ public: // iterate(rootp); } - virtual ~LinkDotResolveVisitor() {} + virtual ~LinkDotResolveVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkInc.cpp b/src/V3LinkInc.cpp index e9db2bf74..5dc4153e4 100644 --- a/src/V3LinkInc.cpp +++ b/src/V3LinkInc.cpp @@ -241,7 +241,7 @@ public: m_unsupportedHere = false; iterate(nodep); } - virtual ~LinkIncVisitor() {} + virtual ~LinkIncVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkJump.cpp b/src/V3LinkJump.cpp index 4ca10cb79..42486f5b5 100644 --- a/src/V3LinkJump.cpp +++ b/src/V3LinkJump.cpp @@ -294,7 +294,7 @@ public: m_modRepeatNum = 0; iterate(nodep); } - virtual ~LinkJumpVisitor() {} + virtual ~LinkJumpVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkLValue.cpp b/src/V3LinkLValue.cpp index 8f5cc6d66..e1c33b58a 100644 --- a/src/V3LinkLValue.cpp +++ b/src/V3LinkLValue.cpp @@ -303,7 +303,7 @@ public: m_ftaskp = nullptr; iterate(nodep); } - virtual ~LinkLValueVisitor() {} + virtual ~LinkLValueVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkParse.cpp b/src/V3LinkParse.cpp index e0a71f901..cc9f35680 100644 --- a/src/V3LinkParse.cpp +++ b/src/V3LinkParse.cpp @@ -604,7 +604,7 @@ public: m_valueModp = nullptr; iterate(rootp); } - virtual ~LinkParseVisitor() {} + virtual ~LinkParseVisitor() override {} }; //###################################################################### diff --git a/src/V3LinkResolve.cpp b/src/V3LinkResolve.cpp index 99d7401da..6e5e161d5 100644 --- a/src/V3LinkResolve.cpp +++ b/src/V3LinkResolve.cpp @@ -530,7 +530,7 @@ public: m_senitemCvtNum = 0; iterate(rootp); } - virtual ~LinkResolveVisitor() {} + virtual ~LinkResolveVisitor() override {} }; //###################################################################### @@ -574,7 +574,7 @@ public: // iterate(rootp); } - virtual ~LinkBotupVisitor() {} + virtual ~LinkBotupVisitor() override {} }; //###################################################################### diff --git a/src/V3Localize.cpp b/src/V3Localize.cpp index 3f8641ae0..455435cc5 100644 --- a/src/V3Localize.cpp +++ b/src/V3Localize.cpp @@ -85,7 +85,7 @@ private: public: // CONSTRUCTORS explicit LocalizeDehierVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~LocalizeDehierVisitor() {} + virtual ~LocalizeDehierVisitor() override {} }; //###################################################################### @@ -225,7 +225,7 @@ public: m_cfuncp = nullptr; iterate(nodep); } - virtual ~LocalizeVisitor() { + virtual ~LocalizeVisitor() override { V3Stats::addStat("Optimizations, Vars localized", m_statLocVars); } }; diff --git a/src/V3MergeCond.cpp b/src/V3MergeCond.cpp index 5bc0b177a..31f3009c5 100644 --- a/src/V3MergeCond.cpp +++ b/src/V3MergeCond.cpp @@ -329,7 +329,7 @@ public: m_markVars.clear(); iterate(nodep); } - virtual ~MergeCondVisitor() { + virtual ~MergeCondVisitor() override { V3Stats::addStat("Optimizations, MergeCond merges", m_statMerges); V3Stats::addStat("Optimizations, MergeCond merged items", m_statMergedItems); V3Stats::addStat("Optimizations, MergeCond longest merge", m_statLongestList); diff --git a/src/V3Name.cpp b/src/V3Name.cpp index 45cfb2b61..6c2800850 100644 --- a/src/V3Name.cpp +++ b/src/V3Name.cpp @@ -140,7 +140,7 @@ public: m_modp = nullptr; iterate(nodep); } - virtual ~NameVisitor() {} + virtual ~NameVisitor() override {} }; //###################################################################### diff --git a/src/V3Order.cpp b/src/V3Order.cpp index 966e34771..d03538797 100644 --- a/src/V3Order.cpp +++ b/src/V3Order.cpp @@ -371,7 +371,7 @@ public: iterate(nodep); } while (m_newClkMarked); } - virtual ~OrderClkMarkVisitor() {} + virtual ~OrderClkMarkVisitor() override {} }; //###################################################################### @@ -405,7 +405,7 @@ public: m_clkAss = false; iterate(nodep); } - virtual ~OrderClkAssVisitor() {} + virtual ~OrderClkAssVisitor() override {} // METHODS bool isClkAss() { return m_clkAss; } }; @@ -1240,7 +1240,7 @@ public: m_pomNewStmts = 0; if (debug()) m_graph.debug(5); // 3 is default if global debug; we want acyc debugging } - virtual ~OrderVisitor() { + virtual ~OrderVisitor() override { // Stats for (int type = 0; type < OrderVEdgeType::_ENUM_END; type++) { double count = double(m_statCut[type]); diff --git a/src/V3OrderGraph.h b/src/V3OrderGraph.h index 3ef3a183b..10781196f 100644 --- a/src/V3OrderGraph.h +++ b/src/V3OrderGraph.h @@ -113,9 +113,9 @@ inline bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) { class OrderGraph : public V3Graph { public: OrderGraph() {} - virtual ~OrderGraph() {} + virtual ~OrderGraph() override {} // Methods - virtual void loopsVertexCb(V3GraphVertex* vertexp); + virtual void loopsVertexCb(V3GraphVertex* vertexp) override; }; //###################################################################### @@ -138,12 +138,12 @@ public: , m_scopep(scopep) , m_domainp(domainp) , m_isFromInput(false) {} - virtual ~OrderEitherVertex() {} - virtual OrderEitherVertex* clone(V3Graph* graphp) const = 0; + virtual ~OrderEitherVertex() override {} + virtual OrderEitherVertex* clone(V3Graph* graphp) const override = 0; // Methods virtual OrderVEdgeType type() const = 0; virtual bool domainMatters() = 0; // Must be in same domain when cross edge to this vertex - virtual string dotName() const { return cvtToHex(m_scopep) + "_"; } + virtual string dotName() const override { return cvtToHex(m_scopep) + "_"; } // ACCESSORS void domainp(AstSenTree* domainp) { m_domainp = domainp; } AstScope* scopep() const { return m_scopep; } @@ -161,15 +161,15 @@ public: : OrderEitherVertex(graphp, nullptr, domainp) { isFromInput(true); // By definition } - virtual ~OrderInputsVertex() {} - virtual OrderInputsVertex* clone(V3Graph* graphp) const { + virtual ~OrderInputsVertex() override {} + virtual OrderInputsVertex* clone(V3Graph* graphp) const override { return new OrderInputsVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_INPUTS; } - virtual string name() const { return "*INPUTS*"; } - virtual string dotColor() const { return "green"; } - virtual string dotName() const { return ""; } - virtual bool domainMatters() { return false; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_INPUTS; } + virtual string name() const override { return "*INPUTS*"; } + virtual string dotColor() const override { return "green"; } + virtual string dotName() const override { return ""; } + virtual bool domainMatters() override { return false; } }; class OrderLogicVertex : public OrderEitherVertex { @@ -184,18 +184,18 @@ public: OrderLogicVertex(V3Graph* graphp, AstScope* scopep, AstSenTree* domainp, AstNode* nodep) : OrderEitherVertex(graphp, scopep, domainp) , m_nodep(nodep) {} - virtual ~OrderLogicVertex() {} - virtual OrderLogicVertex* clone(V3Graph* graphp) const { + virtual ~OrderLogicVertex() override {} + virtual OrderLogicVertex* clone(V3Graph* graphp) const override { return new OrderLogicVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_LOGIC; } - virtual bool domainMatters() { return true; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_LOGIC; } + virtual bool domainMatters() override { return true; } // ACCESSORS - virtual string name() const { + virtual string name() const override { return (cvtToHex(m_nodep) + "\\n " + cvtToStr(nodep()->typeName())); } AstNode* nodep() const { return m_nodep; } - virtual string dotColor() const { return "yellow"; } + virtual string dotColor() const override { return "yellow"; } }; class OrderVarVertex : public OrderEitherVertex { @@ -215,10 +215,10 @@ public: , m_varScp(varScp) , m_isClock(false) , m_isDelayed(false) {} - virtual ~OrderVarVertex() {} - virtual OrderVarVertex* clone(V3Graph* graphp) const = 0; - virtual OrderVEdgeType type() const = 0; - virtual FileLine* fileline() const { return varScp()->fileline(); } + virtual ~OrderVarVertex() override {} + virtual OrderVarVertex* clone(V3Graph* graphp) const override = 0; + virtual OrderVEdgeType type() const override = 0; + virtual FileLine* fileline() const override { return varScp()->fileline(); } // ACCESSORS AstVarScope* varScp() const { return m_varScp; } void isClock(bool flag) { m_isClock = flag; } @@ -234,14 +234,16 @@ class OrderVarStdVertex : public OrderVarVertex { public: OrderVarStdVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp) : OrderVarVertex(graphp, scopep, varScp) {} - virtual ~OrderVarStdVertex() {} - virtual OrderVarStdVertex* clone(V3Graph* graphp) const { + virtual ~OrderVarStdVertex() override {} + virtual OrderVarStdVertex* clone(V3Graph* graphp) const override { return new OrderVarStdVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_VARSTD; } - virtual string name() const { return (cvtToHex(varScp()) + "\\n " + varScp()->name()); } - virtual string dotColor() const { return "skyblue"; } - virtual bool domainMatters() { return true; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARSTD; } + virtual string name() const override { + return (cvtToHex(varScp()) + "\\n " + varScp()->name()); + } + virtual string dotColor() const override { return "skyblue"; } + virtual bool domainMatters() override { return true; } }; class OrderVarPreVertex : public OrderVarVertex { OrderVarPreVertex(V3Graph* graphp, const OrderVarPreVertex& old) @@ -250,14 +252,16 @@ class OrderVarPreVertex : public OrderVarVertex { public: OrderVarPreVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp) : OrderVarVertex(graphp, scopep, varScp) {} - virtual ~OrderVarPreVertex() {} - virtual OrderVarPreVertex* clone(V3Graph* graphp) const { + virtual ~OrderVarPreVertex() override {} + virtual OrderVarPreVertex* clone(V3Graph* graphp) const override { return new OrderVarPreVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_VARPRE; } - virtual string name() const { return (cvtToHex(varScp()) + " PRE\\n " + varScp()->name()); } - virtual string dotColor() const { return "lightblue"; } - virtual bool domainMatters() { return false; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPRE; } + virtual string name() const override { + return (cvtToHex(varScp()) + " PRE\\n " + varScp()->name()); + } + virtual string dotColor() const override { return "lightblue"; } + virtual bool domainMatters() override { return false; } }; class OrderVarPostVertex : public OrderVarVertex { OrderVarPostVertex(V3Graph* graphp, const OrderVarPostVertex& old) @@ -266,14 +270,16 @@ class OrderVarPostVertex : public OrderVarVertex { public: OrderVarPostVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp) : OrderVarVertex(graphp, scopep, varScp) {} - virtual OrderVarPostVertex* clone(V3Graph* graphp) const { + virtual OrderVarPostVertex* clone(V3Graph* graphp) const override { return new OrderVarPostVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_VARPOST; } - virtual ~OrderVarPostVertex() {} - virtual string name() const { return (cvtToHex(varScp()) + " POST\\n " + varScp()->name()); } - virtual string dotColor() const { return "CadetBlue"; } - virtual bool domainMatters() { return false; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPOST; } + virtual ~OrderVarPostVertex() override {} + virtual string name() const override { + return (cvtToHex(varScp()) + " POST\\n " + varScp()->name()); + } + virtual string dotColor() const override { return "CadetBlue"; } + virtual bool domainMatters() override { return false; } }; class OrderVarPordVertex : public OrderVarVertex { OrderVarPordVertex(V3Graph* graphp, const OrderVarPordVertex& old) @@ -282,14 +288,16 @@ class OrderVarPordVertex : public OrderVarVertex { public: OrderVarPordVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp) : OrderVarVertex(graphp, scopep, varScp) {} - virtual ~OrderVarPordVertex() {} - virtual OrderVarPordVertex* clone(V3Graph* graphp) const { + virtual ~OrderVarPordVertex() override {} + virtual OrderVarPordVertex* clone(V3Graph* graphp) const override { return new OrderVarPordVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_VARPORD; } - virtual string name() const { return (cvtToHex(varScp()) + " PORD\\n " + varScp()->name()); } - virtual string dotColor() const { return "NavyBlue"; } - virtual bool domainMatters() { return false; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPORD; } + virtual string name() const override { + return (cvtToHex(varScp()) + " PORD\\n " + varScp()->name()); + } + virtual string dotColor() const override { return "NavyBlue"; } + virtual bool domainMatters() override { return false; } }; class OrderVarSettleVertex : public OrderVarVertex { OrderVarSettleVertex(V3Graph* graphp, const OrderVarSettleVertex& old) @@ -298,14 +306,16 @@ class OrderVarSettleVertex : public OrderVarVertex { public: OrderVarSettleVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp) : OrderVarVertex(graphp, scopep, varScp) {} - virtual ~OrderVarSettleVertex() {} - virtual OrderVarSettleVertex* clone(V3Graph* graphp) const { + virtual ~OrderVarSettleVertex() override {} + virtual OrderVarSettleVertex* clone(V3Graph* graphp) const override { return new OrderVarSettleVertex(graphp, *this); } - virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_VARSETTLE; } - virtual string name() const { return (cvtToHex(varScp()) + " STL\\n " + varScp()->name()); } - virtual string dotColor() const { return "PowderBlue"; } - virtual bool domainMatters() { return false; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARSETTLE; } + virtual string name() const override { + return (cvtToHex(varScp()) + " STL\\n " + varScp()->name()); + } + virtual string dotColor() const override { return "PowderBlue"; } + virtual bool domainMatters() override { return false; } }; //###################################################################### @@ -332,28 +342,28 @@ public: , m_logicp(logicp) , m_state(POM_WAIT) , m_domScopep(nullptr) {} - virtual ~OrderMoveVertex() {} - virtual OrderMoveVertex* clone(V3Graph* graphp) const { + virtual ~OrderMoveVertex() override {} + virtual OrderMoveVertex* clone(V3Graph* graphp) const override { v3fatalSrc("Unsupported"); return nullptr; } // METHODS virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; } - virtual string dotColor() const { + virtual string dotColor() const override { if (logicp()) { return logicp()->dotColor(); } else { return ""; } } - virtual FileLine* fileline() const { + virtual FileLine* fileline() const override { if (logicp()) { return logicp()->fileline(); } else { return nullptr; } } - virtual string name() const { + virtual string name() const override { string nm; if (VL_UNCOVERABLE(!logicp())) { // Avoid crash when debugging nm = "nul"; // LCOV_EXCL_LINE @@ -402,20 +412,20 @@ public: , m_domainp(domainp) { UASSERT(!(logicp && varp), "MTaskMoveVertex: logicp and varp may not both be set!\n"); } - virtual ~MTaskMoveVertex() {} - virtual MTaskMoveVertex* clone(V3Graph* graphp) const { + virtual ~MTaskMoveVertex() override {} + virtual MTaskMoveVertex* clone(V3Graph* graphp) const override { v3fatalSrc("Unsupported"); return nullptr; } virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; } - virtual string dotColor() const { + virtual string dotColor() const override { if (logicp()) { return logicp()->dotColor(); } else { return "yellow"; } } - virtual string name() const { + virtual string name() const override { string nm; if (logicp()) { nm = logicp()->name(); @@ -447,9 +457,10 @@ public: OrderEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight, bool cutable = false) : V3GraphEdge(graphp, fromp, top, weight, cutable) {} - virtual ~OrderEdge() {} + virtual ~OrderEdge() override {} virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_STD; } - virtual OrderEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) const { + virtual OrderEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, + V3GraphVertex* top) const override { return new OrderEdge(graphp, fromp, top, *this); } // When ordering combo blocks with stronglyConnected, follow edges not @@ -473,14 +484,14 @@ class OrderComboCutEdge : public OrderEdge { public: OrderComboCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : OrderEdge(graphp, fromp, top, WEIGHT_COMBO, CUTABLE) {} - virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_COMBOCUT; } - virtual ~OrderComboCutEdge() {} + virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_COMBOCUT; } + virtual ~OrderComboCutEdge() override {} virtual OrderComboCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, - V3GraphVertex* top) const { + V3GraphVertex* top) const override { return new OrderComboCutEdge(graphp, fromp, top, *this); } - virtual string dotColor() const { return "yellowGreen"; } - virtual bool followComboConnected() const { return true; } + virtual string dotColor() const override { return "yellowGreen"; } + virtual bool followComboConnected() const override { return true; } }; class OrderPostCutEdge : public OrderEdge { @@ -494,14 +505,14 @@ class OrderPostCutEdge : public OrderEdge { public: OrderPostCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : OrderEdge(graphp, fromp, top, WEIGHT_COMBO, CUTABLE) {} - virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_POSTCUT; } - virtual ~OrderPostCutEdge() {} + virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_POSTCUT; } + virtual ~OrderPostCutEdge() override {} virtual OrderPostCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, - V3GraphVertex* top) const { + V3GraphVertex* top) const override { return new OrderPostCutEdge(graphp, fromp, top, *this); } - virtual string dotColor() const { return "PaleGreen"; } - virtual bool followComboConnected() const { return false; } + virtual string dotColor() const override { return "PaleGreen"; } + virtual bool followComboConnected() const override { return false; } }; class OrderPreCutEdge : public OrderEdge { @@ -515,14 +526,14 @@ class OrderPreCutEdge : public OrderEdge { public: OrderPreCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : OrderEdge(graphp, fromp, top, WEIGHT_PRE, CUTABLE) {} - virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_PRECUT; } + virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_PRECUT; } virtual OrderPreCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp, - V3GraphVertex* top) const { + V3GraphVertex* top) const override { return new OrderPreCutEdge(graphp, fromp, top, *this); } - virtual ~OrderPreCutEdge() {} - virtual string dotColor() const { return "khaki"; } - virtual bool followComboConnected() const { return false; } + virtual ~OrderPreCutEdge() override {} + virtual string dotColor() const override { return "khaki"; } + virtual bool followComboConnected() const override { return false; } }; #endif // Guard diff --git a/src/V3Param.cpp b/src/V3Param.cpp index 258eb00a2..14181aef1 100644 --- a/src/V3Param.cpp +++ b/src/V3Param.cpp @@ -796,7 +796,7 @@ public: // iterate(nodep); } - virtual ~ParamVisitor() {} + virtual ~ParamVisitor() override {} }; //---------------------------------------------------------------------- diff --git a/src/V3Partition.cpp b/src/V3Partition.cpp index b69dced2e..1e976f65f 100644 --- a/src/V3Partition.cpp +++ b/src/V3Partition.cpp @@ -495,7 +495,7 @@ public: m_vertices.splice(m_vertices.end(), otherp->m_vertices); m_cost += otherp->m_cost; } - virtual const VxList* vertexListp() const { return &m_vertices; } + virtual const VxList* vertexListp() const override { return &m_vertices; } static vluint64_t incGeneration() { static vluint64_t s_generation = 0; ++s_generation; @@ -505,10 +505,10 @@ public: // Use this instead of pointer-compares to compare LogicMTasks. Avoids // nondeterministic output. Also name mtasks based on this number in // the final C++ output. - virtual uint32_t id() const { return m_serialId; } + virtual uint32_t id() const override { return m_serialId; } void id(uint32_t id) { m_serialId = id; } // Abstract cost of every logic mtask - virtual uint32_t cost() const { return m_cost; } + virtual uint32_t cost() const override { return m_cost; } void setCost(uint32_t cost) { m_cost = cost; } // For tests only uint32_t stepCost() const { return stepCost(m_cost); } static uint32_t stepCost(uint32_t cost) { @@ -559,7 +559,7 @@ public: } } - virtual string name() const { + virtual string name() const override { // Display forward and reverse critical path costs. This gives a quick // read on whether graph partitioning looks reasonable or bad. std::ostringstream out; @@ -792,7 +792,7 @@ public: fromp->addRelative(GraphWay::FORWARD, top); top->addRelative(GraphWay::REVERSE, fromp); } - virtual ~MTaskEdge() { + virtual ~MTaskEdge() override { fromMTaskp()->removeRelative(GraphWay::FORWARD, toMTaskp()); toMTaskp()->removeRelative(GraphWay::REVERSE, fromMTaskp()); } @@ -802,7 +802,7 @@ public: } LogicMTask* fromMTaskp() const { return dynamic_cast(fromp()); } LogicMTask* toMTaskp() const { return dynamic_cast(top()); } - virtual bool mergeWouldCreateCycle() const { + virtual bool mergeWouldCreateCycle() const override { return LogicMTask::pathExistsFrom(fromMTaskp(), toMTaskp(), this); } static MTaskEdge* cast(V3GraphEdge* edgep) { @@ -1702,7 +1702,7 @@ public: iterate(nodep); } bool hasDpiHazard() const { return m_hasDpiHazard; } - virtual ~DpiImportCallVisitor() {} + virtual ~DpiImportCallVisitor() override {} private: VL_UNCOPYABLE(DpiImportCallVisitor); diff --git a/src/V3PartitionGraph.h b/src/V3PartitionGraph.h index 32880b026..674929b34 100644 --- a/src/V3PartitionGraph.h +++ b/src/V3PartitionGraph.h @@ -32,7 +32,7 @@ class AbstractMTask : public V3GraphVertex { public: AbstractMTask(V3Graph* graphp) : V3GraphVertex(graphp) {} - virtual ~AbstractMTask() {} + virtual ~AbstractMTask() override {} virtual uint32_t id() const = 0; virtual uint32_t cost() const = 0; }; @@ -44,12 +44,12 @@ public: // CONSTRUCTORS AbstractLogicMTask(V3Graph* graphp) : AbstractMTask(graphp) {} - virtual ~AbstractLogicMTask() {} + virtual ~AbstractLogicMTask() override {} // METHODS // Set of logic vertices in this mtask. Order is not significant. virtual const VxList* vertexListp() const = 0; - virtual uint32_t id() const = 0; // Unique id of this mtask. - virtual uint32_t cost() const = 0; + virtual uint32_t id() const override = 0; // Unique id of this mtask. + virtual uint32_t cost() const override = 0; }; class ExecMTask : public AbstractMTask { @@ -78,10 +78,10 @@ public: , m_packNextp(nullptr) , m_threadRoot(false) {} AstMTaskBody* bodyp() const { return m_bodyp; } - virtual uint32_t id() const { return m_id; } + virtual uint32_t id() const override { return m_id; } uint32_t priority() const { return m_priority; } void priority(uint32_t pri) { m_priority = pri; } - virtual uint32_t cost() const { return m_cost; } + virtual uint32_t cost() const override { return m_cost; } void cost(uint32_t cost) { m_cost = cost; } void thread(uint32_t thread) { m_thread = thread; } uint32_t thread() const { return m_thread; } @@ -93,7 +93,7 @@ public: // If this MTask maps to a C function, this should be the name return string("__Vmtask") + "__" + cvtToStr(m_id); } - string name() const { return string("mt") + cvtToStr(id()); } + virtual string name() const override { return string("mt") + cvtToStr(id()); } void dump(std::ostream& str) const { str << name() << "." << cvtToHex(this); if (priority() || cost()) str << " [pr=" << priority() << " c=" << cvtToStr(cost()) << "]"; diff --git a/src/V3Premit.cpp b/src/V3Premit.cpp index 25de2b1bd..4ba30324e 100644 --- a/src/V3Premit.cpp +++ b/src/V3Premit.cpp @@ -76,7 +76,7 @@ public: m_noopt = false; iterate(nodep); } - virtual ~PremitAssignVisitor() {} + virtual ~PremitAssignVisitor() override {} bool noOpt() const { return m_noopt; } }; @@ -408,7 +408,7 @@ public: m_assignLhs = false; iterate(nodep); } - virtual ~PremitVisitor() {} + virtual ~PremitVisitor() override {} }; //---------------------------------------------------------------------- diff --git a/src/V3Reloop.cpp b/src/V3Reloop.cpp index 4af32d332..540616b4d 100644 --- a/src/V3Reloop.cpp +++ b/src/V3Reloop.cpp @@ -251,7 +251,7 @@ public: m_mgIndexHi = 0; iterate(nodep); } - virtual ~ReloopVisitor() { + virtual ~ReloopVisitor() override { V3Stats::addStat("Optimizations, Reloops", m_statReloops); V3Stats::addStat("Optimizations, Reloop iterations", m_statReItems); } diff --git a/src/V3Scope.cpp b/src/V3Scope.cpp index e64244044..c33ca3029 100644 --- a/src/V3Scope.cpp +++ b/src/V3Scope.cpp @@ -328,7 +328,7 @@ public: // iterate(nodep); } - virtual ~ScopeVisitor() {} + virtual ~ScopeVisitor() override {} }; //###################################################################### @@ -406,7 +406,7 @@ public: m_scopep = nullptr; iterate(nodep); } - virtual ~ScopeCleanupVisitor() {} + virtual ~ScopeCleanupVisitor() override {} }; //###################################################################### diff --git a/src/V3Simulate.h b/src/V3Simulate.h index 0862a62ce..901d1a5df 100644 --- a/src/V3Simulate.h +++ b/src/V3Simulate.h @@ -1131,7 +1131,7 @@ public: setMode(false /*scoped*/, false /*checking*/, true /*params*/); mainGuts(nodep); } - virtual ~SimulateVisitor() { + virtual ~SimulateVisitor() override { for (ConstPile::iterator it = m_constAllps.begin(); it != m_constAllps.end(); ++it) { for (ConstDeque::iterator it2 = it->second.begin(); it2 != it->second.end(); ++it2) { delete (*it2); diff --git a/src/V3Slice.cpp b/src/V3Slice.cpp index cd379d797..ca44a4c2b 100644 --- a/src/V3Slice.cpp +++ b/src/V3Slice.cpp @@ -229,7 +229,7 @@ public: m_assignError = false; iterate(nodep); } - virtual ~SliceVisitor() {} + virtual ~SliceVisitor() override {} }; //###################################################################### diff --git a/src/V3Split.cpp b/src/V3Split.cpp index 7ed0ca809..e3535aef0 100644 --- a/src/V3Split.cpp +++ b/src/V3Split.cpp @@ -102,12 +102,14 @@ protected: SplitNodeVertex(V3Graph* graphp, AstNode* nodep) : V3GraphVertex(graphp) , m_nodep(nodep) {} - virtual ~SplitNodeVertex() {} + virtual ~SplitNodeVertex() override {} // ACCESSORS // Do not make accessor for nodep(), It may change due to // reordering a lower block, but we don't repair it - virtual string name() const { return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName(); } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { + return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName(); + } + virtual FileLine* fileline() const override { return nodep()->fileline(); } public: virtual AstNode* nodep() const { return m_nodep; } @@ -117,34 +119,34 @@ class SplitPliVertex : public SplitNodeVertex { public: explicit SplitPliVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex(graphp, nodep) {} - virtual ~SplitPliVertex() {} - virtual string name() const { return "*PLI*"; } - virtual string dotColor() const { return "green"; } + virtual ~SplitPliVertex() override {} + virtual string name() const override { return "*PLI*"; } + virtual string dotColor() const override { return "green"; } }; class SplitLogicVertex : public SplitNodeVertex { public: SplitLogicVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex(graphp, nodep) {} - virtual ~SplitLogicVertex() {} - virtual string dotColor() const { return "yellow"; } + virtual ~SplitLogicVertex() override {} + virtual string dotColor() const override { return "yellow"; } }; class SplitVarStdVertex : public SplitNodeVertex { public: SplitVarStdVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex(graphp, nodep) {} - virtual ~SplitVarStdVertex() {} - virtual string dotColor() const { return "skyblue"; } + virtual ~SplitVarStdVertex() override {} + virtual string dotColor() const override { return "skyblue"; } }; class SplitVarPostVertex : public SplitNodeVertex { public: SplitVarPostVertex(V3Graph* graphp, AstNode* nodep) : SplitNodeVertex(graphp, nodep) {} - virtual ~SplitVarPostVertex() {} - virtual string name() const { return string("POST ") + SplitNodeVertex::name(); } - virtual string dotColor() const { return "CadetBlue"; } + virtual ~SplitVarPostVertex() override {} + virtual string name() const override { return string("POST ") + SplitNodeVertex::name(); } + virtual string dotColor() const override { return "CadetBlue"; } }; //###################################################################### @@ -159,7 +161,7 @@ protected: bool cutable = CUTABLE) : V3GraphEdge(graphp, fromp, top, weight, cutable) , m_ignoreInStep(0) {} - virtual ~SplitEdge() {} + virtual ~SplitEdge() override {} public: // Iterator for graph functions @@ -178,7 +180,7 @@ public: if (!oedgep) v3fatalSrc("Following edge of non-SplitEdge type"); return (!oedgep->ignoreThisStep()); } - virtual string dotStyle() const { + virtual string dotStyle() const override { return ignoreThisStep() ? "dotted" : V3GraphEdge::dotStyle(); } }; @@ -188,36 +190,36 @@ class SplitPostEdge : public SplitEdge { public: SplitPostEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge(graphp, fromp, top, WEIGHT_NORMAL) {} - virtual ~SplitPostEdge() {} - virtual bool followScoreboard() const { return false; } - virtual string dotColor() const { return "khaki"; } + virtual ~SplitPostEdge() override {} + virtual bool followScoreboard() const override { return false; } + virtual string dotColor() const override { return "khaki"; } }; class SplitLVEdge : public SplitEdge { public: SplitLVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge(graphp, fromp, top, WEIGHT_NORMAL) {} - virtual ~SplitLVEdge() {} - virtual bool followScoreboard() const { return true; } - virtual string dotColor() const { return "yellowGreen"; } + virtual ~SplitLVEdge() override {} + virtual bool followScoreboard() const override { return true; } + virtual string dotColor() const override { return "yellowGreen"; } }; class SplitRVEdge : public SplitEdge { public: SplitRVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge(graphp, fromp, top, WEIGHT_NORMAL) {} - virtual ~SplitRVEdge() {} - virtual bool followScoreboard() const { return true; } - virtual string dotColor() const { return "green"; } + virtual ~SplitRVEdge() override {} + virtual bool followScoreboard() const override { return true; } + virtual string dotColor() const override { return "green"; } }; struct SplitScorebdEdge : public SplitEdge { public: SplitScorebdEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge(graphp, fromp, top, WEIGHT_NORMAL) {} - virtual ~SplitScorebdEdge() {} - virtual bool followScoreboard() const { return true; } - virtual string dotColor() const { return "blue"; } + virtual ~SplitScorebdEdge() override {} + virtual bool followScoreboard() const override { return true; } + virtual string dotColor() const override { return "blue"; } }; struct SplitStrictEdge : public SplitEdge { @@ -226,9 +228,9 @@ struct SplitStrictEdge : public SplitEdge { public: SplitStrictEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top) : SplitEdge(graphp, fromp, top, WEIGHT_NORMAL, NOT_CUTABLE) {} - virtual ~SplitStrictEdge() {} - virtual bool followScoreboard() const { return true; } - virtual string dotColor() const { return "blue"; } + virtual ~SplitStrictEdge() override {} + virtual bool followScoreboard() const override { return true; } + virtual string dotColor() const override { return "blue"; } }; //###################################################################### @@ -261,7 +263,7 @@ protected: // CONSTRUCTORS public: SplitReorderBaseVisitor() { scoreboardClear(); } - virtual ~SplitReorderBaseVisitor() { + virtual ~SplitReorderBaseVisitor() override { V3Stats::addStat("Optimizations, Split always", m_statSplits); } @@ -444,7 +446,7 @@ class ReorderVisitor : public SplitReorderBaseVisitor { // CONSTRUCTORS public: explicit ReorderVisitor(AstNetlist* nodep) { iterate(nodep); } - virtual ~ReorderVisitor() {} + virtual ~ReorderVisitor() override {} // METHODS protected: @@ -641,7 +643,7 @@ public: // Visit through *nodep and map each AstNodeIf within to the set of // colors it will participate in. Also find the whole set of colors. explicit IfColorVisitor(AstAlways* nodep) { iterate(nodep); } - virtual ~IfColorVisitor() {} + virtual ~IfColorVisitor() override {} // METHODS const ColorSet& colors() const { return m_colors; } @@ -706,7 +708,7 @@ public: UINFO(6, " splitting always " << nodep << endl); } - virtual ~EmitSplitVisitor() {} + virtual ~EmitSplitVisitor() override {} // METHODS void go() { @@ -812,7 +814,7 @@ public: VL_DO_DANGLING(np->deleteTree(), np); } } - virtual ~RemovePlaceholdersVisitor() {} + virtual ~RemovePlaceholdersVisitor() override {} virtual void visit(AstSplitPlaceholder* nodep) override { m_removeSet.insert(nodep); } virtual void visit(AstNode* nodep) override { iterateChildren(nodep); } @@ -853,7 +855,7 @@ public: } } - virtual ~SplitVisitor() {} + virtual ~SplitVisitor() override {} // METHODS protected: diff --git a/src/V3SplitAs.cpp b/src/V3SplitAs.cpp index 7247f9c10..c7335113d 100644 --- a/src/V3SplitAs.cpp +++ b/src/V3SplitAs.cpp @@ -61,7 +61,7 @@ public: m_splitVscp = nullptr; iterate(nodep); } - virtual ~SplitAsFindVisitor() {} + virtual ~SplitAsFindVisitor() override {} // METHODS AstVarScope* splitVscp() const { return m_splitVscp; } }; @@ -123,7 +123,7 @@ public: m_matches = false; iterate(nodep); } - virtual ~SplitAsCleanVisitor() {} + virtual ~SplitAsCleanVisitor() override {} }; //###################################################################### @@ -193,7 +193,7 @@ public: AstNode::user1ClearTree(); // user1p() used on entire tree iterate(nodep); } - virtual ~SplitAsVisitor() { + virtual ~SplitAsVisitor() override { V3Stats::addStat("Optimizations, isolate_assignments blocks", m_statSplits); } }; diff --git a/src/V3Stats.cpp b/src/V3Stats.cpp index 4c8c4636a..3e11cf42c 100644 --- a/src/V3Stats.cpp +++ b/src/V3Stats.cpp @@ -220,7 +220,7 @@ public: // Process iterate(nodep); } - virtual ~StatsVisitor() { + virtual ~StatsVisitor() override { // Done. Publish statistics V3Stats::addStat(m_stage, "Instruction count, TOTAL", m_statInstr); V3Stats::addStat(m_stage, "Instruction count, fast critical", m_statInstrFast); diff --git a/src/V3Subst.cpp b/src/V3Subst.cpp index 9dc067eb2..b03f8a7ca 100644 --- a/src/V3Subst.cpp +++ b/src/V3Subst.cpp @@ -216,7 +216,7 @@ public: m_origStep = origStep; iterate(nodep); } - virtual ~SubstUseVisitor() {} + virtual ~SubstUseVisitor() override {} // METHODS bool ok() const { return m_ok; } }; @@ -375,7 +375,7 @@ public: m_assignStep = 0; iterate(nodep); } - virtual ~SubstVisitor() { + virtual ~SubstVisitor() override { V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts); for (std::vector::iterator it = m_entryps.begin(); it != m_entryps.end(); ++it) { diff --git a/src/V3TSP.cpp b/src/V3TSP.cpp index 7ee9e1770..8daf4c64e 100644 --- a/src/V3TSP.cpp +++ b/src/V3TSP.cpp @@ -59,7 +59,7 @@ public: TspVertexTmpl(V3Graph* graphp, const T_Key& k) : V3GraphVertex(graphp) , m_key(k) {} - virtual ~TspVertexTmpl() {} + virtual ~TspVertexTmpl() override {} const T_Key& key() const { return m_key; } private: @@ -80,7 +80,7 @@ public: // CONSTRUCTORS TspGraphTmpl() : V3Graph() {} - virtual ~TspGraphTmpl() {} + virtual ~TspGraphTmpl() override {} // METHODS void addVertex(const T_Key& key) { @@ -507,7 +507,7 @@ public: , m_ypos(ypos) , m_serial(++m_serialNext) {} ~TspTestState() {} - virtual int cost(const TspStateBase* otherp) const { + virtual int cost(const TspStateBase* otherp) const override { return cost(dynamic_cast(otherp)); } static unsigned diff(unsigned a, unsigned b) { @@ -527,7 +527,7 @@ public: unsigned xpos() const { return m_xpos; } unsigned ypos() const { return m_ypos; } - bool operator<(const TspStateBase& other) const { + bool operator<(const TspStateBase& other) const override { return operator<(dynamic_cast(other)); } bool operator<(const TspTestState& other) const { return m_serial < other.m_serial; } diff --git a/src/V3Table.cpp b/src/V3Table.cpp index 13f54fad2..5c5f420da 100644 --- a/src/V3Table.cpp +++ b/src/V3Table.cpp @@ -54,11 +54,11 @@ class TableSimulateVisitor : public SimulateVisitor { public: ///< Call other-this function on all new var references - virtual void varRefCb(AstVarRef* nodep); + virtual void varRefCb(AstVarRef* nodep) override; // CONSTRUCTORS explicit TableSimulateVisitor(TableVisitor* cbthis) { m_cbthis = cbthis; } - virtual ~TableSimulateVisitor() {} + virtual ~TableSimulateVisitor() override {} }; //###################################################################### @@ -461,7 +461,7 @@ public: m_totalBytes = 0; iterate(nodep); } - virtual ~TableVisitor() { // + virtual ~TableVisitor() override { // V3Stats::addStat("Optimizations, Tables created", m_statTablesCre); } }; diff --git a/src/V3Task.cpp b/src/V3Task.cpp index 1342606d8..8a0fefb29 100644 --- a/src/V3Task.cpp +++ b/src/V3Task.cpp @@ -47,7 +47,7 @@ public: : V3GraphVertex(graphp) , m_impurep(nullptr) , m_noInline(false) {} - virtual ~TaskBaseVertex() {} + virtual ~TaskBaseVertex() override {} bool pure() const { return m_impurep == nullptr; } AstNode* impureNode() const { return m_impurep; } void impure(AstNode* nodep) { m_impurep = nodep; } @@ -66,11 +66,11 @@ public: , m_nodep(nodep) { m_cFuncp = nullptr; } - virtual ~TaskFTaskVertex() {} + virtual ~TaskFTaskVertex() override {} AstNodeFTask* nodep() const { return m_nodep; } - virtual string name() const { return nodep()->name(); } - virtual string dotColor() const { return pure() ? "black" : "red"; } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { return nodep()->name(); } + virtual string dotColor() const override { return pure() ? "black" : "red"; } + virtual FileLine* fileline() const override { return nodep()->fileline(); } AstCFunc* cFuncp() const { return m_cFuncp; } void cFuncp(AstCFunc* nodep) { m_cFuncp = nodep; } }; @@ -80,17 +80,17 @@ class TaskCodeVertex : public TaskBaseVertex { public: explicit TaskCodeVertex(V3Graph* graphp) : TaskBaseVertex(graphp) {} - virtual ~TaskCodeVertex() {} - virtual string name() const { return "*CODE*"; } - virtual string dotColor() const { return "green"; } + virtual ~TaskCodeVertex() override {} + virtual string name() const override { return "*CODE*"; } + virtual string dotColor() const override { return "green"; } }; class TaskEdge : public V3GraphEdge { public: TaskEdge(V3Graph* graphp, TaskBaseVertex* fromp, TaskBaseVertex* top) : V3GraphEdge(graphp, fromp, top, 1, false) {} - virtual ~TaskEdge() {} - virtual string dotLabel() const { return "w" + cvtToStr(weight()); } + virtual ~TaskEdge() override {} + virtual string dotLabel() const override { return "w" + cvtToStr(weight()); } }; //###################################################################### @@ -273,7 +273,7 @@ public: m_callGraph.removeRedundantEdgesSum(&TaskEdge::followAlwaysTrue); m_callGraph.dumpDotFilePrefixed("task_call"); } - virtual ~TaskStateVisitor() {} + virtual ~TaskStateVisitor() override {} VL_UNCOPYABLE(TaskStateVisitor); }; @@ -309,7 +309,7 @@ public: explicit TaskRelinkVisitor(AstBegin* nodep) { // Passed temporary tree iterate(nodep); } - virtual ~TaskRelinkVisitor() {} + virtual ~TaskRelinkVisitor() override {} }; //###################################################################### @@ -1367,7 +1367,7 @@ public: AstNode::user1ClearTree(); iterate(nodep); } - virtual ~TaskVisitor() {} + virtual ~TaskVisitor() override {} }; //###################################################################### diff --git a/src/V3Trace.cpp b/src/V3Trace.cpp index 59a8a97d1..0b2e96985 100644 --- a/src/V3Trace.cpp +++ b/src/V3Trace.cpp @@ -71,20 +71,20 @@ public: m_activityCode = code; m_slow = false; } - virtual ~TraceActivityVertex() {} + virtual ~TraceActivityVertex() override {} // ACCESSORS AstNode* insertp() const { if (!m_insertp) v3fatalSrc("Null insertp; probably called on a special always/slow."); return m_insertp; } - virtual string name() const { + virtual string name() const override { if (activityAlways()) { return "*ALWAYS*"; } else { return (string(slow() ? "*SLOW* " : "")) + insertp()->name(); } } - virtual string dotColor() const { return slow() ? "yellowGreen" : "green"; } + virtual string dotColor() const override { return slow() ? "yellowGreen" : "green"; } vlsint32_t activityCode() const { return m_activityCode; } bool activityAlways() const { return activityCode() == ACTIVITY_ALWAYS; } bool activitySlow() const { return activityCode() == ACTIVITY_SLOW; } @@ -102,12 +102,12 @@ public: TraceCFuncVertex(V3Graph* graphp, AstCFunc* nodep) : V3GraphVertex(graphp) , m_nodep(nodep) {} - virtual ~TraceCFuncVertex() {} + virtual ~TraceCFuncVertex() override {} // ACCESSORS AstCFunc* nodep() const { return m_nodep; } - virtual string name() const { return nodep()->name(); } - virtual string dotColor() const { return "yellow"; } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { return nodep()->name(); } + virtual string dotColor() const override { return "yellow"; } + virtual FileLine* fileline() const override { return nodep()->fileline(); } }; class TraceTraceVertex : public V3GraphVertex { @@ -120,12 +120,12 @@ public: : V3GraphVertex(graphp) , m_nodep(nodep) , m_duplicatep(nullptr) {} - virtual ~TraceTraceVertex() {} + virtual ~TraceTraceVertex() override {} // ACCESSORS AstTraceDecl* nodep() const { return m_nodep; } - virtual string name() const { return nodep()->name(); } - virtual string dotColor() const { return "red"; } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { return nodep()->name(); } + virtual string dotColor() const override { return "red"; } + virtual FileLine* fileline() const override { return nodep()->fileline(); } TraceTraceVertex* duplicatep() const { return m_duplicatep; } void duplicatep(TraceTraceVertex* dupp) { UASSERT_OBJ(!duplicatep(), nodep(), "Assigning duplicatep() to already duplicated node"); @@ -140,12 +140,12 @@ public: TraceVarVertex(V3Graph* graphp, AstVarScope* nodep) : V3GraphVertex(graphp) , m_nodep(nodep) {} - virtual ~TraceVarVertex() {} + virtual ~TraceVarVertex() override {} // ACCESSORS AstVarScope* nodep() const { return m_nodep; } - virtual string name() const { return nodep()->name(); } - virtual string dotColor() const { return "skyblue"; } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual string name() const override { return nodep()->name(); } + virtual string dotColor() const override { return "skyblue"; } + virtual FileLine* fileline() const override { return nodep()->fileline(); } }; //###################################################################### @@ -885,7 +885,7 @@ public: m_code = 0; iterate(nodep); } - virtual ~TraceVisitor() { + virtual ~TraceVisitor() override { V3Stats::addStat("Tracing, Unique changing signals", m_statChgSigs); V3Stats::addStat("Tracing, Unique traced signals", m_statUniqSigs); V3Stats::addStat("Tracing, Unique trace codes", m_statUniqCodes); diff --git a/src/V3TraceDecl.cpp b/src/V3TraceDecl.cpp index ce11cf3c4..825679946 100644 --- a/src/V3TraceDecl.cpp +++ b/src/V3TraceDecl.cpp @@ -349,7 +349,7 @@ public: m_interface = false; iterate(nodep); } - virtual ~TraceDeclVisitor() { + virtual ~TraceDeclVisitor() override { V3Stats::addStat("Tracing, Traced signals", m_statSigs); V3Stats::addStat("Tracing, Ignored signals", m_statIgnSigs); } diff --git a/src/V3Tristate.cpp b/src/V3Tristate.cpp index 0f36c15b7..14f5190bd 100644 --- a/src/V3Tristate.cpp +++ b/src/V3Tristate.cpp @@ -90,19 +90,19 @@ public: , m_isTristate(false) , m_feedsTri(false) , m_processed(false) {} - virtual ~TristateVertex() {} + virtual ~TristateVertex() override {} // ACCESSORS AstNode* nodep() const { return m_nodep; } AstVar* varp() const { return VN_CAST(nodep(), Var); } - virtual string name() const { + virtual string name() const override { return ((isTristate() ? "tri\\n" : feedsTri() ? "feed\\n" : "-\\n") + (nodep()->prettyTypeName() + " " + cvtToHex(nodep()))); } - virtual string dotColor() const { + virtual string dotColor() const override { return (varp() ? (isTristate() ? "darkblue" : feedsTri() ? "blue" : "lightblue") : (isTristate() ? "darkgreen" : feedsTri() ? "green" : "lightgreen")); } - virtual FileLine* fileline() const { return nodep()->fileline(); } + virtual FileLine* fileline() const override { return nodep()->fileline(); } void isTristate(bool flag) { m_isTristate = flag; } bool isTristate() const { return m_isTristate; } void feedsTri(bool flag) { m_feedsTri = flag; } @@ -309,7 +309,7 @@ public: , m_lvalue(lvalue) { iterate(nodep); } - virtual ~TristatePinVisitor() {} + virtual ~TristatePinVisitor() override {} }; //###################################################################### @@ -1357,7 +1357,7 @@ public: m_tgraph.clear(); iterate(nodep); } - virtual ~TristateVisitor() { + virtual ~TristateVisitor() override { V3Stats::addStat("Tristate, Tristate resolved nets", m_statTriSigs); } }; diff --git a/src/V3Undriven.cpp b/src/V3Undriven.cpp index 94a258808..c76d0cb32 100644 --- a/src/V3Undriven.cpp +++ b/src/V3Undriven.cpp @@ -447,7 +447,7 @@ public: m_alwaysCombp = nullptr; iterate(nodep); } - virtual ~UndrivenVisitor() { + virtual ~UndrivenVisitor() override { for (std::vector::iterator it = m_entryps[1].begin(); it != m_entryps[1].end(); ++it) { (*it)->reportViolations(); diff --git a/src/V3Unknown.cpp b/src/V3Unknown.cpp index 76d0c18f3..e7eb7f282 100644 --- a/src/V3Unknown.cpp +++ b/src/V3Unknown.cpp @@ -435,7 +435,7 @@ public: m_constXCvt = false; iterate(nodep); } - virtual ~UnknownVisitor() { // + virtual ~UnknownVisitor() override { // V3Stats::addStat("Unknowns, variables created", m_statUnkVars); } }; diff --git a/src/V3Unroll.cpp b/src/V3Unroll.cpp index 10eae4ab6..d3146445a 100644 --- a/src/V3Unroll.cpp +++ b/src/V3Unroll.cpp @@ -471,7 +471,7 @@ private: public: // CONSTRUCTORS UnrollVisitor() { init(false, ""); } - virtual ~UnrollVisitor() { + virtual ~UnrollVisitor() override { V3Stats::addStatSum("Optimizations, Unrolled Loops", m_statLoops); V3Stats::addStatSum("Optimizations, Unrolled Iterations", m_statIters); } diff --git a/src/V3Width.cpp b/src/V3Width.cpp index 02405e96e..ee508070f 100644 --- a/src/V3Width.cpp +++ b/src/V3Width.cpp @@ -5419,7 +5419,7 @@ public: AstNode* mainAcceptEdit(AstNode* nodep) { return userIterateSubtreeReturnEdits(nodep, WidthVP(SELF, BOTH).p()); } - virtual ~WidthVisitor() {} + virtual ~WidthVisitor() override {} }; //###################################################################### diff --git a/src/V3WidthCommit.h b/src/V3WidthCommit.h index f17f29a10..ff6e3c03a 100644 --- a/src/V3WidthCommit.h +++ b/src/V3WidthCommit.h @@ -56,7 +56,7 @@ private: public: // CONSTRUCTORS WidthRemoveVisitor() {} - virtual ~WidthRemoveVisitor() {} + virtual ~WidthRemoveVisitor() override {} AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); } }; @@ -171,7 +171,7 @@ public: // Don't want to repairCache, as all needed nodes have been added back in // a repair would prevent dead nodes from being detected } - virtual ~WidthCommitVisitor() {} + virtual ~WidthCommitVisitor() override {} }; //###################################################################### diff --git a/src/V3WidthSel.cpp b/src/V3WidthSel.cpp index eadf0fbef..fc9be7f44 100644 --- a/src/V3WidthSel.cpp +++ b/src/V3WidthSel.cpp @@ -571,7 +571,7 @@ public: // CONSTRUCTORS WidthSelVisitor() {} AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); } - virtual ~WidthSelVisitor() {} + virtual ~WidthSelVisitor() override {} }; //######################################################################