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

Remove redundant 'virtual' keywords from overridden methods 

'virtual' is redundant when 'override' is present, so keep only
'override'.

Add t/t_dist_cppstyle.pl to check for this.
This commit is contained in:
Geza Lore 2022-09-16 11:22:11 +01:00
parent d16619fe86
commit 0c70a0dcbf
99 changed files with 4454 additions and 4525 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/verilated_fst_sc.h
View File

@ -52,35 +52,36 @@ public:
}
spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
}
virtual ~VerilatedFstSc() /*override*/ { close(); }
~VerilatedFstSc() override { close(); }
// METHODS
/// Called by SystemC simulate()
virtual void cycle(bool delta_cycle) {
void cycle(bool delta_cycle) override {
if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
}
// Override VerilatedFstC. Must be called after starting simulation.
// cppcheck-suppress missingOverride // GCC won't accept override
virtual void open(const char* filename) /*override*/ VL_MT_SAFE;
// Note: this is not a virtual function in the base class, so no 'override'
virtual void open(const char* filename) VL_MT_SAFE;
private:
/// Fake outs for linker
#ifdef NC_SYSTEMC
// Cadence Incisive has these as abstract functions so we must create them
virtual void set_time_unit(int exponent10_seconds) {} // deprecated
void set_time_unit(int exponent10_seconds) override {} // deprecated
#endif
virtual void set_time_unit(double v, sc_time_unit tu) {} // LCOV_EXCL_LINE
void set_time_unit(double v, sc_time_unit tu) override {} // LCOV_EXCL_LINE
//--------------------------------------------------
// SystemC 2.1.v1
#define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
#define DECL_TRACE_METHOD_A(tp) \
void trace(const tp& object, const std::string& name) override;
#define DECL_TRACE_METHOD_B(tp) \
virtual void trace(const tp& object, const std::string& name, int width);
void trace(const tp& object, const std::string& name, int width) override;
virtual void write_comment(const std::string&);
virtual void trace(const unsigned int&, const std::string&, const char**);
void write_comment(const std::string&) override;
void trace(const unsigned int&, const std::string&, const char**) override;
// clang-format off
// Formatting matches that of sc_trace.h

20
include/verilated_vcd_sc.h
View File

@ -55,35 +55,35 @@ public:
spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
}
/// Destruct, flush, and close the dump
virtual ~VerilatedVcdSc() /*override*/ { close(); }
~VerilatedVcdSc() override { close(); }
// METHODS - for SC kernel
// Called by SystemC simulate()
virtual void cycle(bool delta_cycle) {
void cycle(bool delta_cycle) override {
if (!delta_cycle) this->dump(sc_time_stamp().to_double());
}
// Override VerilatedVcdC. Must be called after starting simulation.
// cppcheck-suppress missingOverride // GCC won't accept override
virtual void open(const char* filename) /*override*/ VL_MT_SAFE;
void open(const char* filename) override VL_MT_SAFE;
private:
// METHODS - Fake outs for linker
#ifdef NC_SYSTEMC
// Cadence Incisive has these as abstract functions so we must create them
virtual void set_time_unit(int exponent10_seconds) {} // deprecated
void set_time_unit(int exponent10_seconds) override {} // deprecated
#endif
virtual void set_time_unit(double v, sc_time_unit tu) {} // LCOV_EXCL_LINE
void set_time_unit(double v, sc_time_unit tu) override {} // LCOV_EXCL_LINE
//--------------------------------------------------
// SystemC 2.1.v1
#define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
#define DECL_TRACE_METHOD_A(tp) \
void trace(const tp& object, const std::string& name) override;
#define DECL_TRACE_METHOD_B(tp) \
virtual void trace(const tp& object, const std::string& name, int width);
void trace(const tp& object, const std::string& name, int width) override;
virtual void write_comment(const std::string&);
virtual void trace(const unsigned int&, const std::string&, const char**);
void write_comment(const std::string&) override;
void trace(const unsigned int&, const std::string&, const char**) override;
// clang-format off
// Formatting matches that of sc_trace.h

58
src/V3Active.cpp
View File

@ -66,8 +66,8 @@ public:
: V3GraphVertex{graphp}
, m_name{name}
, m_type{type} {}
virtual string name() const override { return m_name + " " + typestr(); }
virtual string dotColor() const override { return user() ? "green" : "black"; }
string name() const override { return m_name + " " + typestr(); }
string dotColor() const override { return user() ? "green" : "black"; }
virtual int type() const { return m_type; }
};
@ -120,7 +120,7 @@ protected:
public:
LatchDetectGraph() { clear(); }
virtual ~LatchDetectGraph() override { clear(); }
~LatchDetectGraph() override { clear(); }
// ACCESSORS
LatchDetectGraphVertex* currentp() { return m_curVertexp; }
void currentp(LatchDetectGraphVertex* vertex) { m_curVertexp = vertex; }
@ -219,7 +219,7 @@ private:
m_scopep->addActivep(nodep);
}
// VISITORS
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
m_scopep = nodep;
m_iActivep = nullptr;
m_cActivep = nullptr;
@ -227,13 +227,13 @@ private:
iterateChildren(nodep);
// Don't clear scopep, the namer persists beyond this visit
}
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
// Simplify sensitivity list
VL_DO_DANGLING(V3Const::constifyExpensiveEdit(nodep), nodep);
}
//--------------------
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeStmt*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// METHODS
@ -275,7 +275,7 @@ public:
// CONSTRUCTORS
ActiveNamer() = default;
virtual ~ActiveNamer() override = default;
~ActiveNamer() override = default;
void main(AstScope* nodep) { iterate(nodep); }
};
@ -291,13 +291,13 @@ private:
// STATE
LatchDetectGraph m_graph; // Graph used to detect latches in combo always
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
const AstVar* const varp = nodep->varp();
if (nodep->access().isWriteOrRW() && varp->isSignal() && !varp->isUsedLoopIdx()) {
m_graph.addAssignment(nodep);
}
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
if (!nodep->isBoundsCheck()) {
LatchDetectGraphVertex* const parentp = m_graph.currentp();
LatchDetectGraphVertex* const branchp = m_graph.addPathVertex(parentp, "BRANCH", true);
@ -309,7 +309,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -333,7 +333,7 @@ private:
const CheckType m_check; // Process type we are checking
// VISITORS
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
// Non-blocking assignments are OK in sequential processes
if (m_check == CT_SEQ) return;
@ -357,7 +357,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstAssign* nodep) override {
void visit(AstAssign* nodep) override {
// Blocking assignments are always OK in combinational (and initial/final) processes
if (m_check != CT_SEQ) return;
@ -380,7 +380,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -407,7 +407,7 @@ private:
bool m_itemSequent = false; // Found a SenItem sequential
// VISITORS
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// Create required actives and add to scope
UINFO(4, " SCOPE " << nodep << endl);
// Clear last scope's names, and collect this scope's existing names
@ -415,10 +415,10 @@ private:
m_scopeFinalp = nullptr;
iterateChildren(nodep);
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
// Actives are being formed, so we can ignore any already made
}
virtual void visit(AstInitialStatic* nodep) override {
void visit(AstInitialStatic* nodep) override {
// Relink to IACTIVE, unless already under it
UINFO(4, " INITIAL " << nodep << endl);
const ActiveDlyVisitor dlyvisitor{nodep, ActiveDlyVisitor::CT_INITIAL};
@ -426,7 +426,7 @@ private:
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstInitial* nodep) override {
void visit(AstInitial* nodep) override {
// Relink to IACTIVE, unless already under it
UINFO(4, " INITIAL " << nodep << endl);
const ActiveDlyVisitor dlyvisitor{nodep, ActiveDlyVisitor::CT_INITIAL};
@ -434,28 +434,28 @@ private:
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " ASSIGNW " << nodep << endl);
AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " ASSIGNW " << nodep << endl);
AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstCoverToggle* nodep) override {
void visit(AstCoverToggle* nodep) override {
// Relink to CACTIVE, unless already under it
UINFO(4, " COVERTOGGLE " << nodep << endl);
AstActive* const wantactivep = m_namer.getCActive(nodep->fileline());
nodep->unlinkFrBack();
wantactivep->addStmtsp(nodep);
}
virtual void visit(AstFinal* nodep) override {
void visit(AstFinal* nodep) override {
// Relink to CFUNC for the final
UINFO(4, " FINAL " << nodep << endl);
if (!nodep->bodysp()) { // Empty, Kill it.
@ -537,7 +537,7 @@ private:
ActiveDlyVisitor{nodep, ActiveDlyVisitor::CT_SEQ};
}
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
// Move always to appropriate ACTIVE based on its sense list
UINFO(4, " ALW " << nodep << endl);
// if (debug() >= 9) nodep->dumpTree(cout, " Alw: ");
@ -549,7 +549,7 @@ private:
}
visitAlways(nodep, nodep->sensesp(), nodep->keyword());
}
virtual void visit(AstAlwaysPostponed* nodep) override {
void visit(AstAlwaysPostponed* nodep) override {
UINFO(4, " ALW " << nodep << endl);
if (!nodep->bodysp()) {
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
@ -557,13 +557,13 @@ private:
}
visitAlways(nodep, nullptr, VAlwaysKwd::ALWAYS);
}
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
// Move always to appropriate ACTIVE based on its sense list
UINFO(4, " ALWPub " << nodep << endl);
// if (debug() >= 9) nodep->dumpTree(cout, " Alw: ");
visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
if (nodep->varrefp()) {
if (const AstBasicDType* const basicp = nodep->varrefp()->dtypep()->basicp()) {
if (basicp->isEventValue()) {
@ -592,9 +592,9 @@ private:
}
//--------------------
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstVarScope*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstVarScope*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

20
src/V3ActiveTop.cpp
View File

@ -52,13 +52,13 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Create required actives and add to module
// We can start ordering at a module, or a scope
UINFO(4, " MOD " << nodep << endl);
iterateChildren(nodep);
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
UINFO(4, " ACTIVE " << nodep << endl);
// Remove duplicate clocks and such; sensesp() may change!
V3Const::constifyExpensiveEdit(nodep);
@ -101,27 +101,27 @@ private:
// No need to do statements under it, they're already moved.
// iterateChildren(nodep);
}
virtual void visit(AstNodeProcedure* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodeProcedure* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAssignAlias* nodep) override { // LCOV_EXCL_LINE
void visit(AstAssignAlias* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAssignW* nodep) override { // LCOV_EXCL_LINE
void visit(AstAssignW* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
virtual void visit(AstAlwaysPublic* nodep) override { // LCOV_EXCL_LINE
void visit(AstAlwaysPublic* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Node should have been under ACTIVE");
}
//--------------------
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstVarScope*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstVarScope*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ActiveTopVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ActiveTopVisitor() override = default;
~ActiveTopVisitor() override = default;
};
//######################################################################

28
src/V3Assert.cpp
View File

@ -196,7 +196,7 @@ private:
}
// VISITORS
virtual void visit(AstIf* nodep) override {
void visit(AstIf* nodep) override {
if (nodep->user1SetOnce()) return;
if (nodep->uniquePragma() || nodep->unique0Pragma()) {
const AstNodeIf* ifp = nodep;
@ -254,7 +254,7 @@ private:
}
//========== Case assertions
virtual void visit(AstCase* nodep) override {
void visit(AstCase* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
bool has_default = false;
@ -323,7 +323,7 @@ private:
}
//========== Past
virtual void visit(AstPast* nodep) override {
void visit(AstPast* nodep) override {
iterateChildren(nodep);
uint32_t ticks = 1;
if (nodep->ticksp()) {
@ -353,13 +353,13 @@ private:
}
nodep->replaceWith(inp);
}
virtual void visit(AstSampled* nodep) override {
void visit(AstSampled* nodep) override {
nodep->replaceWith(nodep->exprp()->unlinkFrBack());
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
//========== Statements
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
iterateChildren(nodep);
// Replace the special types with standard text
if (nodep->displayType() == VDisplayType::DT_INFO) {
@ -410,32 +410,32 @@ private:
m_modp->addStmtp(newp);
}
}
virtual void visit(AstMonitorOff* nodep) override {
void visit(AstMonitorOff* nodep) override {
const auto newp
= new AstAssign(nodep->fileline(), newMonitorOffVarRefp(nodep, VAccess::WRITE),
new AstConst(nodep->fileline(), AstConst::BitTrue{}, nodep->off()));
nodep->replaceWith(newp);
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstAssert* nodep) override {
void visit(AstAssert* nodep) override {
iterateChildren(nodep);
newPslAssertion(nodep, nodep->failsp());
}
virtual void visit(AstAssertIntrinsic* nodep) override {
void visit(AstAssertIntrinsic* nodep) override {
iterateChildren(nodep);
newPslAssertion(nodep, nodep->failsp());
}
virtual void visit(AstCover* nodep) override {
void visit(AstCover* nodep) override {
iterateChildren(nodep);
newPslAssertion(nodep, nullptr);
}
virtual void visit(AstRestrict* nodep) override {
void visit(AstRestrict* nodep) override {
iterateChildren(nodep);
// IEEE says simulator ignores these
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
VL_RESTORER(m_modPastNum);
VL_RESTORER(m_modStrobeNum);
@ -446,7 +446,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
// This code is needed rather than a visitor in V3Begin,
// because V3Assert is called before V3Begin
VL_RESTORER(m_beginp);
@ -456,12 +456,12 @@ private:
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit AssertVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~AssertVisitor() override {
~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);

24
src/V3AssertPre.cpp
View File

@ -69,7 +69,7 @@ private:
// VISITORS
//========== Statements
virtual void visit(AstClocking* nodep) override {
void visit(AstClocking* nodep) override {
UINFO(8, " CLOCKING" << nodep << endl);
// Store the new default clock, reset on new module
m_seniDefaultp = nodep->sensesp();
@ -81,14 +81,14 @@ private:
}
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
iterateAndNextNull(nodep->sensesp());
if (nodep->sensesp()) m_seniAlwaysp = nodep->sensesp()->sensesp();
iterateAndNextNull(nodep->bodysp());
m_seniAlwaysp = nullptr;
}
virtual void visit(AstNodeCoverOrAssert* nodep) override {
void visit(AstNodeCoverOrAssert* nodep) override {
if (nodep->sentreep()) return; // Already processed
clearAssertInfo();
// Find Clocking's buried under nodep->exprsp
@ -96,7 +96,7 @@ private:
if (!nodep->immediate()) nodep->sentreep(newSenTree(nodep));
clearAssertInfo();
}
virtual void visit(AstFell* nodep) override {
void visit(AstFell* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* const fl = nodep->fileline();
@ -110,12 +110,12 @@ private:
nodep->sentreep(newSenTree(nodep));
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstPast* nodep) override {
void visit(AstPast* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
nodep->sentreep(newSenTree(nodep));
}
virtual void visit(AstRose* nodep) override {
void visit(AstRose* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* const fl = nodep->fileline();
@ -129,7 +129,7 @@ private:
nodep->sentreep(newSenTree(nodep));
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstStable* nodep) override {
void visit(AstStable* nodep) override {
if (nodep->sentreep()) return; // Already processed
iterateChildren(nodep);
FileLine* const fl = nodep->fileline();
@ -143,7 +143,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstImplication* nodep) override {
void visit(AstImplication* nodep) override {
if (nodep->sentreep()) return; // Already processed
FileLine* const fl = nodep->fileline();
@ -161,7 +161,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstPropClocked* nodep) override {
void visit(AstPropClocked* nodep) override {
// No need to iterate the body, once replace will get iterated
iterateAndNextNull(nodep->sensesp());
if (m_senip)
@ -183,12 +183,12 @@ private:
nodep->replaceWith(blockp);
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
iterateChildren(nodep);
// Reset defaults
m_seniDefaultp = nullptr;
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -197,7 +197,7 @@ public:
// Process
iterate(nodep);
}
virtual ~AssertPreVisitor() override = default;
~AssertPreVisitor() override = default;
};
//######################################################################

646
src/V3AstNodeDType.h
View File

File diff suppressed because it is too large Load Diff

3112
src/V3AstNodeMath.h
View File

File diff suppressed because it is too large Load Diff

1014
src/V3AstNodeOther.h
View File

File diff suppressed because it is too large Load Diff

10
src/V3AstNodes.cpp
View File

@ -564,11 +564,11 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
return dpiTypesToStringConverter{}.convert(this);
} else {
class converter final : public dpiTypesToStringConverter {
virtual string bitLogicVector(const AstVar* varp, bool isBit) const override {
string bitLogicVector(const AstVar* varp, bool isBit) const override {
return string(varp->isReadOnly() ? "const " : "")
+ dpiTypesToStringConverter::bitLogicVector(varp, isBit) + '*';
}
virtual string primitive(const AstVar* varp) const override {
string primitive(const AstVar* varp) const override {
string type = dpiTypesToStringConverter::primitive(varp);
if (varp->isWritable() || VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) {
if (!varp->isWritable() && varp->basicp()->keyword() != VBasicDTypeKwd::STRING)
@ -600,16 +600,16 @@ string AstVar::dpiTmpVarType(const string& varName) const {
return "";
}
}
virtual string openArray(const AstVar* varp) const override {
string openArray(const AstVar* varp) const override {
return dpiTypesToStringConverter::openArray(varp) + ' ' + m_name
+ arraySuffix(varp, 0);
}
virtual string bitLogicVector(const AstVar* varp, bool isBit) const override {
string bitLogicVector(const AstVar* varp, bool isBit) const override {
string type = dpiTypesToStringConverter::bitLogicVector(varp, isBit);
type += ' ' + m_name + arraySuffix(varp, varp->widthWords());
return type;
}
virtual string primitive(const AstVar* varp) const override {
string primitive(const AstVar* varp) const override {
string type = dpiTypesToStringConverter::primitive(varp);
if (varp->isWritable() || VN_IS(varp->dtypep()->skipRefp(), UnpackArrayDType)) {
if (!varp->isWritable() && varp->basicp()->keyword() == VBasicDTypeKwd::CHANDLE)

34
src/V3Begin.cpp
View File

@ -120,14 +120,14 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
UINFO(8, " " << nodep << endl);
// Rename it
if (m_unnamedScope != "") {
@ -162,7 +162,7 @@ private:
m_ftaskp = nullptr;
}
}
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
// Begin blocks were only useful in variable creation, change names and delete
UINFO(8, " " << nodep << endl);
VL_RESTORER(m_displayScope);
@ -191,7 +191,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (m_unnamedScope != "") {
// Rename it
nodep->name(dot(m_unnamedScope, nodep->name()));
@ -200,7 +200,7 @@ private:
liftNode(nodep);
}
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
if (m_unnamedScope != "") {
// Rename it
nodep->name(dot(m_unnamedScope, nodep->name()));
@ -209,7 +209,7 @@ private:
liftNode(nodep);
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
UINFO(8, " CELL " << nodep << endl);
if (m_namedScope != "") {
m_statep->userMarkChanged(nodep);
@ -222,14 +222,14 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
UINFO(9, " VARXREF " << nodep << endl);
if (m_namedScope != "" && nodep->inlinedDots() == "" && !m_ftaskp) {
nodep->inlinedDots(m_namedScope);
UINFO(9, " rescope to " << nodep << endl);
}
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
// Similar code in V3Inline
if (nodep->user1SetOnce()) return; // Don't double-add text's
@ -244,13 +244,13 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) override {
void visit(AstCoverDecl* nodep) override {
// Don't need to fix path in coverage statements, they're not under
// any BEGINs, but V3Coverage adds them all under the module itself.
iterateChildren(nodep);
}
// VISITORS - LINT CHECK
virtual void visit(AstIf* nodep) override { // not AstNodeIf; other types not covered
void visit(AstIf* nodep) override { // not AstNodeIf; other types not covered
// Check IFDEPTH warning - could be in other transform files if desire
VL_RESTORER(m_ifDepth);
if (m_ifDepth == -1 || v3Global.opt.ifDepth() < 1) { // Turned off
@ -264,7 +264,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -272,7 +272,7 @@ public:
: m_statep{statep} {
iterate(nodep);
}
virtual ~BeginVisitor() override = default;
~BeginVisitor() override = default;
};
//######################################################################
@ -285,21 +285,21 @@ private:
// AstNodeFTask::user1p // Node replaced, rename it
// VISITORS
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
if (nodep->taskp()->user1()) { // It was converted
UINFO(9, " relinkFTask " << nodep << endl);
nodep->name(nodep->taskp()->name());
}
iterateChildren(nodep);
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->varp()->user1()) { // It was converted
UINFO(9, " relinVarRef " << nodep << endl);
nodep->name(nodep->varp()->name());
}
iterateChildren(nodep);
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
// May have changed cell names
// TypeTable is always after all modules, so names are stable
UINFO(8, " IFACEREFDTYPE " << nodep << endl);
@ -308,12 +308,12 @@ private:
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
BeginRelinkVisitor(AstNetlist* nodep, BeginState*) { iterate(nodep); }
virtual ~BeginRelinkVisitor() override = default;
~BeginRelinkVisitor() override = default;
};
//######################################################################

10
src/V3Branch.cpp
View File

@ -63,7 +63,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
UINFO(4, " IF: " << nodep << endl);
VL_RESTORER(m_likely);
VL_RESTORER(m_unlikely);
@ -87,17 +87,17 @@ private:
} // else leave unknown
}
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
checkUnlikely(nodep);
nodep->funcp()->user1Inc();
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
checkUnlikely(nodep);
m_cfuncsp.push_back(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
checkUnlikely(nodep);
iterateChildren(nodep);
}
@ -116,7 +116,7 @@ public:
iterateChildren(nodep);
calc_tasks();
}
virtual ~BranchVisitor() override = default;
~BranchVisitor() override = default;
};
//######################################################################

20
src/V3Broken.cpp
View File

@ -214,27 +214,27 @@ private:
}
return false;
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
processAndIterate(nodep);
UASSERT_OBJ(!(v3Global.assertDTypesResolved() && nodep->brokeLhsMustBeLvalue()
&& VN_IS(nodep->lhsp(), NodeVarRef)
&& !VN_AS(nodep->lhsp(), NodeVarRef)->access().isWriteOrRW()),
nodep, "Assignment LHS is not an lvalue");
}
virtual void visit(AstRelease* nodep) override {
void visit(AstRelease* nodep) override {
processAndIterate(nodep);
UASSERT_OBJ(!(v3Global.assertDTypesResolved() && VN_IS(nodep->lhsp(), NodeVarRef)
&& !VN_AS(nodep->lhsp(), NodeVarRef)->access().isWriteOrRW()),
nodep, "Release LHS is not an lvalue");
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
VL_RESTORER(m_inScope);
{
m_inScope = true;
processAndIterate(nodep);
}
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
processAndIterate(nodep);
// m_inScope because some Vars have initial variable references without scopes
// This might false fire with some debug flags, as not certain we don't have temporary
@ -252,7 +252,7 @@ private:
}
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
UASSERT_OBJ(!m_cfuncp, nodep, "Nested AstCFunc");
m_cfuncp = nodep;
m_localVars.clear();
@ -270,7 +270,7 @@ private:
m_cfuncp = nullptr;
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
// Each branch is a separate local variable scope
pushLocalScope();
processEnter(nodep);
@ -288,21 +288,21 @@ private:
processExit(nodep);
popLocalScope();
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
// For local variable checking act as if any statement introduces a new scope.
// This is aggressive but conservatively correct.
pushLocalScope();
processAndIterate(nodep);
popLocalScope();
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
processAndIterate(nodep);
if (m_cfuncp) {
m_localVars.insert(nodep);
m_localsStack.back().insert(nodep);
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// Process not just iterate
processAndIterate(nodep);
}
@ -310,7 +310,7 @@ private:
public:
// CONSTRUCTORS
explicit BrokenCheckVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~BrokenCheckVisitor() override = default;
~BrokenCheckVisitor() override = default;
};
//######################################################################

10
src/V3CUse.cpp
View File

@ -57,7 +57,7 @@ class CUseVisitor final : public VNVisitor {
}
// VISITORS
virtual void visit(AstClassRefDType* nodep) override {
void visit(AstClassRefDType* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
if (!m_impOnly) addNewUse(nodep, VUseType::INT_FWD_CLASS, nodep->classp()->name());
// Need to include extends() when we implement, but no need for pointers to know
@ -67,17 +67,17 @@ class CUseVisitor final : public VNVisitor {
iterateChildren(nodep->classp()); // This also gets all extend classes
}
}
virtual void visit(AstNodeDType* nodep) override {
void visit(AstNodeDType* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
if (nodep->virtRefDTypep()) iterate(nodep->virtRefDTypep());
if (nodep->virtRefDType2p()) iterate(nodep->virtRefDType2p());
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
if (nodep->dtypep() && !nodep->dtypep()->user1()) iterate(nodep->dtypep());
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
// Currently no IMP_INCLUDE because we include __Syms which has them all
addNewUse(nodep, VUseType::INT_FWD_CLASS, nodep->modp()->name());
@ -90,7 +90,7 @@ public:
: m_modp(modp) {
iterate(modp);
}
virtual ~CUseVisitor() override = default;
~CUseVisitor() override = default;
VL_UNCOPYABLE(CUseVisitor);
};

14
src/V3Case.cpp
View File

@ -59,7 +59,7 @@ private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeCase* nodep) override {
void visit(AstNodeCase* nodep) override {
if (VN_IS(nodep, Case) && VN_AS(nodep, Case)->casex()) {
nodep->v3warn(CASEX, "Suggest casez (with ?'s) in place of casex (with X's)");
}
@ -86,7 +86,7 @@ private:
m_caseExprp = nullptr;
}
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
// See also neverItem
if (m_caseExprp && nodep->num().isFourState()) {
if (VN_IS(m_caseExprp, GenCase)) {
@ -107,12 +107,12 @@ private:
}
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit CaseLintVisitor(AstNodeCase* nodep) { iterate(nodep); }
virtual ~CaseLintVisitor() override = default;
~CaseLintVisitor() override = default;
};
//######################################################################
@ -493,7 +493,7 @@ private:
}
// VISITORS
virtual void visit(AstCase* nodep) override {
void visit(AstCase* nodep) override {
V3Case::caseLint(nodep);
iterateChildren(nodep);
if (debug() >= 9) nodep->dumpTree(cout, " case_old: ");
@ -510,7 +510,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (VN_IS(nodep, Always)) m_alwaysp = nodep;
iterateChildren(nodep);
}
@ -521,7 +521,7 @@ public:
for (auto& itr : m_valueItem) itr = nullptr;
iterate(nodep);
}
virtual ~CaseVisitor() override {
~CaseVisitor() override {
V3Stats::addStat("Optimizations, Cases parallelized", m_statCaseFast);
V3Stats::addStat("Optimizations, Cases complex", m_statCaseSlow);
}

28
src/V3Cast.cpp
View File

@ -111,25 +111,25 @@ private:
}
// VISITORS
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
}
virtual void visit(AstNodeTriop* nodep) override {
void visit(AstNodeTriop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1());
if (nodep->sizeMattersLhs()) ensureCast(nodep->lhsp());
if (nodep->sizeMattersRhs()) ensureCast(nodep->rhsp());
if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
}
virtual void visit(AstNodeQuadop* nodep) override {
void visit(AstNodeQuadop* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1() | nodep->rhsp()->user1() | nodep->thsp()->user1()
| nodep->fhsp()->user1());
@ -138,12 +138,12 @@ private:
if (nodep->sizeMattersThs()) ensureCast(nodep->thsp());
if (nodep->sizeMattersFhs()) ensureCast(nodep->fhsp());
}
virtual void visit(AstCCast* nodep) override {
void visit(AstCCast* nodep) override {
iterateChildren(nodep);
ensureLower32Cast(nodep);
nodep->user1(1);
}
virtual void visit(AstNegate* nodep) override {
void visit(AstNegate* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
if (nodep->lhsp()->widthMin() == 1) {
@ -155,7 +155,7 @@ private:
ensureCast(nodep->lhsp());
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
const AstNode* const backp = nodep->backp();
if (nodep->access().isReadOnly() && !VN_IS(backp, CCast) && VN_IS(backp, NodeMath)
&& !VN_IS(backp, ArraySel) && !VN_IS(backp, RedXor) && backp->width()
@ -166,7 +166,7 @@ private:
}
nodep->user1(1);
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
// Constants are of unknown size if smaller than 33 bits, because
// we're too lazy to wrap every constant in the universe in
// ((IData)#).
@ -174,29 +174,29 @@ private:
}
// Null dereference protection
virtual void visit(AstNullCheck* nodep) override {
void visit(AstNullCheck* nodep) override {
iterateChildren(nodep);
nodep->user1(nodep->lhsp()->user1());
}
virtual void visit(AstCMethodCall* nodep) override {
void visit(AstCMethodCall* nodep) override {
iterateChildren(nodep);
ensureNullChecked(nodep->fromp());
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
iterateChildren(nodep);
ensureNullChecked(nodep->fromp());
}
// NOPs
virtual void visit(AstVar*) override {}
void visit(AstVar*) override {}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit CastVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~CastVisitor() override = default;
~CastVisitor() override = default;
};
//######################################################################

78
src/V3Cdc.cpp
View File

@ -67,9 +67,9 @@ public:
, m_srcDomainSet{false}
, m_dstDomainSet{false}
, m_asyncPath{false} {}
virtual ~CdcEitherVertex() override = default;
~CdcEitherVertex() override = default;
// ACCESSORS
virtual FileLine* fileline() const override { return nodep()->fileline(); }
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; }
@ -93,11 +93,11 @@ public:
CdcVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: CdcEitherVertex{graphp, scopep, varScp}
, m_varScp{varScp} {}
virtual ~CdcVarVertex() override = default;
~CdcVarVertex() override = default;
// ACCESSORS
AstVarScope* varScp() const { return m_varScp; }
virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
virtual string dotColor() const override {
string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
string dotColor() const override {
return fromFlop() ? "green" : cntAsyncRst() ? "red" : "blue";
}
int cntAsyncRst() const { return m_cntAsyncRst; }
@ -118,12 +118,10 @@ public:
srcDomainp(sensenodep);
dstDomainp(sensenodep);
}
virtual ~CdcLogicVertex() override = default;
~CdcLogicVertex() override = default;
// ACCESSORS
virtual string name() const override {
return (cvtToHex(nodep()) + "@" + scopep()->prettyName());
}
virtual string dotColor() const override { return hazard() ? "black" : "yellow"; }
string name() const override { return (cvtToHex(nodep()) + "@" + scopep()->prettyName()); }
string dotColor() const override { return hazard() ? "black" : "yellow"; }
bool hazard() const { return m_hazard; }
void setHazard(AstNode* nodep) {
m_hazard = true;
@ -144,7 +142,7 @@ private:
std::ofstream* const m_ofp = nullptr; // Output file
string m_prefix;
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
*m_ofp << m_prefix;
if (nodep->user3()) {
*m_ofp << " %%";
@ -171,7 +169,7 @@ public:
, m_prefix{prefix} {
iterate(nodep);
}
virtual ~CdcDumpVisitor() override = default;
~CdcDumpVisitor() override = default;
};
//######################################################################
@ -181,7 +179,7 @@ private:
int m_maxLineno = 0;
size_t m_maxFilenameLen = 0;
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
// Keeping line+filename lengths separate is much faster than calling ascii().length()
if (nodep->fileline()->lineno() >= m_maxLineno) {
@ -195,7 +193,7 @@ private:
public:
// CONSTRUCTORS
explicit CdcWidthVisitor(AstNode* nodep) { iterate(nodep); }
virtual ~CdcWidthVisitor() override = default;
~CdcWidthVisitor() override = default;
// ACCESSORS
int maxWidth() const {
size_t width = 1;
@ -628,21 +626,21 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
m_logicVertexp = nullptr;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
// Create required blocks and add to module
UINFO(4, " BLOCK " << nodep << endl);
AstNode::user2ClearTree();
@ -654,7 +652,7 @@ private:
m_domainp = nullptr;
AstNode::user2ClearTree();
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
if (m_scopep) {
UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
AstVarScope* const varscp = nodep->varScopep();
@ -682,53 +680,53 @@ private:
}
}
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
m_inDly = true;
iterateChildren(nodep);
m_inDly = false;
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
m_inSenItem = true;
iterateChildren(nodep);
m_inSenItem = false;
}
virtual void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlways* nodep) override { iterateNewStmt(nodep); }
void visit(AstAlwaysPublic* nodep) override {
// CDC doesn't care about public variables
}
virtual void visit(AstCFunc* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
virtual void visit(AstAssignW* nodep) override { iterateNewStmt(nodep); }
void visit(AstCFunc* nodep) override { iterateNewStmt(nodep); }
void visit(AstAssignAlias* nodep) override { iterateNewStmt(nodep); }
void visit(AstAssignW* nodep) override { iterateNewStmt(nodep); }
// Math that shouldn't cause us to clear hazard
virtual void visit(AstConst*) override {}
virtual void visit(AstReplicate* nodep) override { iterateChildren(nodep); }
virtual void visit(AstConcat* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNot* nodep) override { iterateChildren(nodep); }
virtual void visit(AstSel* nodep) override {
void visit(AstConst*) override {}
void visit(AstReplicate* nodep) override { iterateChildren(nodep); }
void visit(AstConcat* nodep) override { iterateChildren(nodep); }
void visit(AstNot* nodep) override { iterateChildren(nodep); }
void visit(AstSel* nodep) override {
if (!VN_IS(nodep->lsbp(), Const)) setNodeHazard(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeSel* nodep) override {
void visit(AstNodeSel* nodep) override {
if (!VN_IS(nodep->bitp(), Const)) setNodeHazard(nodep);
iterateChildren(nodep);
}
// Ignores
virtual void visit(AstInitial*) override {}
virtual void visit(AstInitialAutomatic*) override {}
virtual void visit(AstInitialStatic*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstCoverToggle*) override {}
virtual void visit(AstNodeDType*) override {}
void visit(AstInitial*) override {}
void visit(AstInitialAutomatic*) override {}
void visit(AstInitialStatic*) override {}
void visit(AstTraceDecl*) override {}
void visit(AstCoverToggle*) override {}
void visit(AstNodeDType*) override {}
//--------------------
// Default
virtual void visit(AstNodeMath* nodep) override {
void visit(AstNodeMath* nodep) override {
setNodeHazard(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -754,7 +752,7 @@ public:
*m_ofp << '\n';
}
}
virtual ~CdcVisitor() override {
~CdcVisitor() override {
if (m_ofp) VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
}
};

12
src/V3Changed.cpp
View File

@ -155,13 +155,13 @@ private:
m_state.m_numStmts += initp->nodeCount() + m_varEqnp->widthWords();
}
virtual void visit(AstBasicDType*) override { //
void visit(AstBasicDType*) override { //
newChangeDet();
}
virtual void visit(AstPackArrayDType*) override { //
void visit(AstPackArrayDType*) override { //
newChangeDet();
}
virtual void visit(AstUnpackArrayDType* nodep) override {
void visit(AstUnpackArrayDType* nodep) override {
for (int index = 0; index < nodep->elementsConst(); ++index) {
VL_RESTORER(m_varEqnp);
VL_RESTORER(m_newLvEqnp);
@ -181,7 +181,7 @@ private:
}
}
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
if (nodep->packedUnsup()) {
newChangeDet();
} else {
@ -191,7 +191,7 @@ private:
<< m_vscp->varp()->prettyNameQ());
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
if (debug()) nodep->dumpTree(cout, "-DETECTARRAY-general-");
m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable"
@ -231,7 +231,7 @@ public:
m_newLvEqnp->deleteTree();
m_newRvEqnp->deleteTree();
}
virtual ~ChangedInsertVisitor() override = default;
~ChangedInsertVisitor() override = default;
VL_UNCOPYABLE(ChangedInsertVisitor);
};

24
src/V3Class.cpp
View File

@ -49,7 +49,7 @@ private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
if (nodep->user1SetOnce()) return;
// Move this class
nodep->name(m_prefix + nodep->name());
@ -100,7 +100,7 @@ private:
}
nodep->repairCache();
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Visit for NodeModules that are not AstClass (AstClass is-a AstNodeModule)
VL_RESTORER(m_prefix);
{
@ -109,7 +109,7 @@ private:
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
if (m_packageScopep) {
if (m_ftaskp && m_ftaskp->lifetime().isStatic()) {
@ -127,12 +127,12 @@ private:
}
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
iterateChildren(nodep);
nodep->varp()->user1p(nodep);
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
VL_RESTORER(m_ftaskp);
{
m_ftaskp = nodep;
@ -142,7 +142,7 @@ private:
}
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Don't move now, or wouldn't keep interating the class
// TODO move function statics only
@ -150,14 +150,14 @@ private:
// m_toScopeMoves.push_back(std::make_pair(nodep, m_classScopep));
//}
}
virtual void visit(AstInitial* nodep) override {
void visit(AstInitial* nodep) override {
// But not AstInitialAutomatic, which remains under the class
iterateChildren(nodep);
if (m_packageScopep) {
m_toScopeMoves.emplace_back(std::make_pair(nodep, m_packageScopep));
}
}
virtual void visit(AstInitialStatic* nodep) override {
void visit(AstInitialStatic* nodep) override {
// But not AstInitialAutomatic, which remains under the class
iterateChildren(nodep);
if (m_packageScopep) {
@ -165,14 +165,14 @@ private:
}
}
virtual void visit(AstNodeMath* nodep) override {} // Short circuit
virtual void visit(AstNodeStmt* nodep) override {} // Short circuit
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath* nodep) override {} // Short circuit
void visit(AstNodeStmt* nodep) override {} // Short circuit
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ClassVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ClassVisitor() override {
~ClassVisitor() override {
for (auto moved : m_toScopeMoves) {
AstNode* const nodep = moved.first;
AstScope* const scopep = moved.second;

58
src/V3Clean.cpp
View File

@ -173,64 +173,64 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
if (nodep->cleanLhs()) ensureClean(nodep->lhsp());
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
operandBiop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstAnd* nodep) override {
void visit(AstAnd* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
}
virtual void visit(AstXor* nodep) override {
void visit(AstXor* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
}
virtual void visit(AstOr* nodep) override {
void visit(AstOr* nodep) override {
operandBiop(nodep);
setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
}
virtual void visit(AstNodeQuadop* nodep) override {
void visit(AstNodeQuadop* nodep) override {
operandQuadop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeMath* nodep) override {
void visit(AstNodeMath* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
if (nodep->cleanRhs()) ensureClean(nodep->rhsp());
}
virtual void visit(AstText* nodep) override { //
void visit(AstText* nodep) override { //
setClean(nodep, true);
}
virtual void visit(AstScopeName* nodep) override { //
void visit(AstScopeName* nodep) override { //
setClean(nodep, true);
}
virtual void visit(AstCNew* nodep) override {
void visit(AstCNew* nodep) override {
iterateChildren(nodep);
setClean(nodep, true);
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
operandTriop(nodep);
setClean(nodep, nodep->cleanOut());
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
setClean(nodep, false);
@ -238,69 +238,69 @@ private:
if (!VN_IS(nodep->backp(), And)) insertClean(nodep);
ensureCleanAndNext(nodep->bodysp());
}
virtual void visit(AstTraceDecl* nodep) override {
void visit(AstTraceDecl* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
virtual void visit(AstTraceInc* nodep) override {
void visit(AstTraceInc* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->valuep());
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
virtual void visit(AstParamTypeDType* nodep) override {
void visit(AstParamTypeDType* nodep) override {
// No cleaning, or would loose pointer to enum
iterateChildren(nodep);
}
// Control flow operators
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
iterateChildren(nodep);
ensureClean(nodep->condp());
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->exprsp());
setClean(nodep, true); // generates a string, so not relevant
}
virtual void visit(AstUCStmt* nodep) override {
void visit(AstUCStmt* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->bodysp());
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->argsp());
setClean(nodep, true);
}
virtual void visit(AstCMethodHard* nodep) override {
void visit(AstCMethodHard* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->pinsp());
setClean(nodep, true);
}
virtual void visit(AstWith* nodep) override {
void visit(AstWith* nodep) override {
iterateChildren(nodep);
ensureCleanAndNext(nodep->exprp());
setClean(nodep, true);
}
virtual void visit(AstIntfRef* nodep) override {
void visit(AstIntfRef* nodep) override {
iterateChildren(nodep);
setClean(nodep, true); // generates a string, so not relevant
}
//--------------------
// Default: Just iterate
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
computeCppWidth(nodep);
}
@ -308,7 +308,7 @@ private:
public:
// CONSTRUCTORS
explicit CleanVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~CleanVisitor() override = default;
~CleanVisitor() override = default;
};
//######################################################################

22
src/V3Clock.cpp
View File

@ -242,7 +242,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) override {
void visit(AstTopScope* nodep) override {
UINFO(4, " TOPSCOPE " << nodep << endl);
m_topScopep = nodep;
m_scopep = nodep->scopep();
@ -277,7 +277,7 @@ private:
m_topScopep = nullptr;
m_scopep = nullptr;
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// UINFO(4, " MOD " << nodep << endl);
VL_RESTORER(m_modp);
{
@ -285,7 +285,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
iterateChildren(nodep);
@ -296,14 +296,14 @@ private:
}
m_scopep = nullptr;
}
virtual void visit(AstNodeProcedure* nodep) override {
void visit(AstNodeProcedure* nodep) override {
if (AstNode* const stmtsp = nodep->bodysp()) {
stmtsp->unlinkFrBackWithNext();
nodep->addNextHere(stmtsp);
}
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstCoverToggle* nodep) override {
void visit(AstCoverToggle* nodep) override {
// nodep->dumpTree(cout, "ct:");
// COVERTOGGLE(INC, ORIG, CHANGE) ->
// IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
@ -320,7 +320,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
// Link to global function
if (nodep->isFinal()) {
@ -329,7 +329,7 @@ private:
m_finalFuncp->addStmtsp(callp);
}
}
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
// Delete it later; Actives still pointing to it
nodep->unlinkFrBack();
pushDeletep(nodep);
@ -343,7 +343,7 @@ private:
void addToInitial(AstNode* stmtsp) {
m_initFuncp->addStmtsp(stmtsp); // add to top level function
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
// Careful if adding variables here, ACTIVES can be under other ACTIVES
// Need to save and restore any member state in AstUntilStable block
if (!m_topScopep || !nodep->stmtsp()) {
@ -411,7 +411,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
}
virtual void visit(AstExecGraph* nodep) override {
void visit(AstExecGraph* nodep) override {
VL_RESTORER(m_mtaskBodyp);
for (m_mtaskBodyp = nodep->mTaskBodiesp(); m_mtaskBodyp;
m_mtaskBodyp = VN_AS(m_mtaskBodyp->nextp(), MTaskBody)) {
@ -427,7 +427,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -437,7 +437,7 @@ public:
// easily without iterating through the tree.
nodep->evalp(m_evalFuncp);
}
virtual ~ClockVisitor() override = default;
~ClockVisitor() override = default;
};
//######################################################################

12
src/V3Combine.cpp
View File

@ -180,32 +180,32 @@ class CombineVisitor final : VNVisitor {
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Gather functions and references
iterateChildrenConst(nodep);
// Combine functions
process(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UASSERT_OBJ(!m_modp, nodep, "Should not nest");
m_modp = nodep;
iterateChildrenConst(nodep);
m_modp = nullptr;
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
iterateChildrenConst(nodep);
if (nodep->dontCombine()) return;
auto& coll = nodep->slow() ? m_cfuncs(m_modp).m_slow : m_cfuncs(m_modp).m_fast;
coll.emplace_back(nodep);
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
iterateChildrenConst(nodep);
AstCFunc* const funcp = nodep->funcp();
if (funcp->dontCombine()) return;
m_callSites(funcp).emplace_back(nodep);
}
virtual void visit(AstAddrOfCFunc* nodep) override {
void visit(AstAddrOfCFunc* nodep) override {
iterateChildrenConst(nodep);
if (nodep->funcp()->dontCombine()) return;
// LCOV_EXCL_START
@ -217,7 +217,7 @@ class CombineVisitor final : VNVisitor {
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
// CONSTRUCTORS
explicit CombineVisitor(AstNetlist* nodep) { iterate(nodep); }

94
src/V3Const.cpp
View File

@ -417,14 +417,12 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
}
// VISITORS
virtual void visit(AstNode* nodep) override {
CONST_BITOP_SET_FAILED("Hit unexpected op", nodep);
}
virtual void visit(AstCCast* nodep) override {
void visit(AstNode* nodep) override { CONST_BITOP_SET_FAILED("Hit unexpected op", nodep); }
void visit(AstCCast* nodep) override {
iterateChildren(nodep);
if (m_leafp) m_leafp->updateBitRange(nodep);
}
virtual void visit(AstShiftR* nodep) override {
void visit(AstShiftR* nodep) override {
CONST_BITOP_RETURN_IF(!m_leafp, nodep);
AstConst* const constp = VN_CAST(nodep->rhsp(), Const);
CONST_BITOP_RETURN_IF(!constp, nodep->rhsp());
@ -434,7 +432,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
m_leafp->updateBitRange(nodep);
m_lsb -= constp->toUInt();
}
virtual void visit(AstNot* nodep) override {
void visit(AstNot* nodep) override {
CONST_BITOP_RETURN_IF(nodep->widthMin() != 1, nodep);
AstNode* lhsp = nodep->lhsp();
AstCCast* const castp = VN_CAST(lhsp, CCast);
@ -449,7 +447,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
if (!isXorTree()) m_polarity = !m_polarity;
if (m_leafp && castp) m_leafp->updateBitRange(castp);
}
virtual void visit(AstWordSel* nodep) override {
void visit(AstWordSel* nodep) override {
CONST_BITOP_RETURN_IF(!m_leafp, nodep);
AstConst* const constp = VN_CAST(nodep->bitp(), Const);
CONST_BITOP_RETURN_IF(!constp, nodep->rhsp());
@ -457,17 +455,17 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
m_leafp->wordIdx(constp->toSInt());
iterate(nodep->fromp());
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
CONST_BITOP_RETURN_IF(!m_leafp, nodep);
m_leafp->setLeaf(nodep);
m_leafp->polarity(m_polarity);
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
CONST_BITOP_RETURN_IF(!m_leafp, nodep);
m_leafp->setLeaf(nodep);
}
virtual void visit(AstRedXor* nodep) override {
void visit(AstRedXor* nodep) override {
Restorer restorer{*this};
CONST_BITOP_RETURN_IF(!VN_IS(m_rootp, Xor), nodep);
AstNode* lhsp = nodep->lhsp();
@ -514,7 +512,7 @@ class ConstBitOpTreeVisitor final : public VNVisitor {
}
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
if (VN_IS(nodep, And) && isConst(nodep->lhsp(), 1)) { // 1 & _
// Always reach past a plain making AND
Restorer restorer{*this};
@ -2252,11 +2250,11 @@ private:
//----------------------------------------
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order. That's faster
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
@ -2264,7 +2262,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// No ASSIGNW removals under funcs, we've long eliminated INITIALs
// (We should perhaps rename the assignw's to just assigns)
VL_RESTORER(m_wremove);
@ -2273,7 +2271,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// No ASSIGNW removals under scope, we've long eliminated INITIALs
VL_RESTORER(m_wremove);
VL_RESTORER(m_scopep);
@ -2370,17 +2368,17 @@ private:
}
// Special cases
virtual void visit(AstConst*) override {} // Already constant
void visit(AstConst*) override {} // Already constant
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
if (m_params) {
iterateAndNextNull(nodep->paramsp());
} else {
iterateChildren(nodep);
}
}
virtual void visit(AstClassOrPackageRef* nodep) override { iterateChildren(nodep); }
virtual void visit(AstPin* nodep) override { iterateChildren(nodep); }
void visit(AstClassOrPackageRef* nodep) override { iterateChildren(nodep); }
void visit(AstPin* nodep) override { iterateChildren(nodep); }
void replaceLogEq(AstLogEq* nodep) {
// LOGEQ(a,b) => AstLogAnd{AstLogOr{AstLogNot{a},b},AstLogOr{AstLogNot{b},a}}
@ -2562,7 +2560,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstAttrOf* nodep) override {
void visit(AstAttrOf* nodep) override {
VL_RESTORER(m_attrp);
{
m_attrp = nodep;
@ -2570,7 +2568,7 @@ private:
}
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
iterateAndNextNull(nodep->bitp());
if (VN_IS(nodep->bitp(), Const)
&& VN_IS(nodep->fromp(), VarRef)
@ -2596,7 +2594,7 @@ private:
}
m_selp = nullptr;
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
UASSERT_OBJ(nodep->varp(), nodep, "Not linked");
bool did = false;
@ -2650,7 +2648,7 @@ private:
<< nodep->varp()->prettyNameQ());
}
}
virtual void visit(AstEnumItemRef* nodep) override {
void visit(AstEnumItemRef* nodep) override {
iterateChildren(nodep);
UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
bool did = false;
@ -2675,7 +2673,7 @@ private:
}
}
// virtual void visit(AstCvtPackString* nodep) override {
// void visit(AstCvtPackString* nodep) override {
// Not constant propagated (for today) because AstNodeMath::isOpaque is set
// Someday if lower is constant, convert to quoted "string".
@ -2683,7 +2681,7 @@ private:
// Only one if it's not in a list
return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
iterateChildren(nodep);
if (m_doNConst
&& (VN_IS(nodep->sensp(), Const) || VN_IS(nodep->sensp(), EnumItemRef)
@ -2750,7 +2748,7 @@ private:
}
};
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
iterateChildren(nodep);
if (m_doExpensive) {
// cout<<endl; nodep->dumpTree(cout, "ssin: ");
@ -2834,17 +2832,17 @@ private:
//-----
// Zero elimination
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
iterateChildren(nodep);
if (m_doNConst && replaceNodeAssign(nodep)) return;
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
// Don't perform any optimizations, keep the alias around
}
virtual void visit(AstAssignVarScope* nodep) override {
void visit(AstAssignVarScope* nodep) override {
// Don't perform any optimizations, the node won't be linked yet
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
iterateChildren(nodep);
if (m_doNConst && replaceNodeAssign(nodep)) return;
AstNodeVarRef* const varrefp = VN_CAST(
@ -2871,7 +2869,7 @@ private:
varrefp->varp()->valuep(initvaluep);
}
}
virtual void visit(AstRelease* nodep) override {
void visit(AstRelease* nodep) override {
if (AstConcat* const concatp = VN_CAST(nodep->lhsp(), Concat)) {
FileLine* const flp = nodep->fileline();
AstRelease* const newLp = new AstRelease{flp, concatp->lhsp()->unlinkFrBack()};
@ -2884,7 +2882,7 @@ private:
}
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
iterateChildren(nodep);
if (m_doNConst) {
if (const AstConst* const constp = VN_CAST(nodep->condp(), Const)) {
@ -2968,7 +2966,7 @@ private:
}
}
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
// DISPLAY(SFORMAT(text1)),DISPLAY(SFORMAT(text2)) -> DISPLAY(SFORMAT(text1+text2))
iterateChildren(nodep);
if (stmtDisplayDisplay(nodep)) return;
@ -3022,7 +3020,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
return true;
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
// Substitute constants into displays. The main point of this is to
// simplify assertion methodologies which call functions with display's.
// This eliminates a pile of wide temps, and makes the C a whole lot more readable.
@ -3089,17 +3087,17 @@ private:
}
}
virtual void visit(AstFuncRef* nodep) override {
void visit(AstFuncRef* nodep) override {
iterateChildren(nodep);
if (m_params) { // Only parameters force us to do constant function call propagation
replaceWithSimulation(nodep);
}
}
virtual void visit(AstArg* nodep) override {
void visit(AstArg* nodep) override {
// replaceWithSimulation on the Arg's parent FuncRef replaces these
iterateChildren(nodep);
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
const bool oldHasJumpDelay = m_hasJumpDelay;
m_hasJumpDelay = false;
{ iterateChildren(nodep); }
@ -3125,22 +3123,22 @@ private:
}
}
}
virtual void visit(AstInitArray* nodep) override { iterateChildren(nodep); }
virtual void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
virtual void visit(AstUnbounded* nodep) override { iterateChildren(nodep); }
void visit(AstInitArray* nodep) override { iterateChildren(nodep); }
void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
void visit(AstUnbounded* nodep) override { iterateChildren(nodep); }
// These are converted by V3Param. Don't constify as we don't want the
// from() VARREF to disappear, if any.
// If output of a presel didn't get consted, chances are V3Param didn't visit properly
virtual void visit(AstNodePreSel*) override {}
void visit(AstNodePreSel*) override {}
// Ignored, can eliminate early
virtual void visit(AstSysIgnore* nodep) override {
void visit(AstSysIgnore* nodep) override {
iterateChildren(nodep);
if (m_doNConst) VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
// Simplify
virtual void visit(AstBasicDType* nodep) override {
void visit(AstBasicDType* nodep) override {
iterateChildren(nodep);
nodep->cvtRangeConst();
}
@ -3148,11 +3146,11 @@ private:
//-----
// Jump elimination
virtual void visit(AstDelay* nodep) override {
void visit(AstDelay* nodep) override {
iterateChildren(nodep);
m_hasJumpDelay = true;
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
iterateChildren(nodep);
// Jump to label where label immediately follows label is not useful
if (nodep->labelp() == VN_CAST(nodep->nextp(), JumpLabel)) {
@ -3183,7 +3181,7 @@ private:
m_hasJumpDelay = true;
}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
// Because JumpLabels disable many optimizations,
// remove JumpLabels that are not pointed to by any AstJumpGos
// Note this assumes all AstJumpGos are underneath the given label; V3Broken asserts this
@ -3537,7 +3535,7 @@ private:
// Note we can't convert EqCase/NeqCase to Eq/Neq here because that would break 3'b1x1==3'b101
//-----
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// Default: Just iterate
if (m_required) {
if (VN_IS(nodep, NodeDType) || VN_IS(nodep, Range) || VN_IS(nodep, SliceSel)) {
@ -3584,7 +3582,7 @@ public:
}
// clang-format on
}
virtual ~ConstVisitor() override {
~ConstVisitor() override {
if (m_doCpp) {
if (m_globalPass) {
V3Stats::addStat("Optimizations, Const bit op reduction", m_statBitOpReduction);

26
src/V3Coverage.cpp
View File

@ -209,7 +209,7 @@ private:
}
// VISITORS - BOTH
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
const AstNodeModule* const origModp = m_modp;
VL_RESTORER(m_modp);
VL_RESTORER(m_state);
@ -227,9 +227,9 @@ private:
}
}
virtual void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
virtual void visit(AstWhile* nodep) override { iterateProcedure(nodep); }
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeProcedure* nodep) override { iterateProcedure(nodep); }
void visit(AstWhile* nodep) override { iterateProcedure(nodep); }
void visit(AstNodeFTask* nodep) override {
if (!nodep->dpiImport()) iterateProcedure(nodep);
}
void iterateProcedure(AstNode* nodep) {
@ -258,7 +258,7 @@ private:
}
// VISITORS - TOGGLE COVERAGE
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
if (m_modp && !m_inToggleOff && !m_state.m_inModOff && nodep->fileline()->coverageOn()
&& v3Global.opt.coverageToggle()) {
@ -383,7 +383,7 @@ private:
// VISITORS - LINE COVERAGE
// Note not AstNodeIf; other types don't get covered
virtual void visit(AstIf* nodep) override {
void visit(AstIf* nodep) override {
UINFO(4, " IF: " << nodep << endl);
if (m_state.m_on) {
// An else-if. When we iterate the if, use "elsif" marking
@ -460,7 +460,7 @@ private:
}
UINFO(9, " done HANDLE " << m_state.m_handle << " for " << nodep << endl);
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
// We don't add an explicit "default" coverage if not provided,
// as we already have a warning when there is no default.
UINFO(4, " CASEI: " << nodep << endl);
@ -479,7 +479,7 @@ private:
}
}
}
virtual void visit(AstCover* nodep) override {
void visit(AstCover* nodep) override {
UINFO(4, " COVER: " << nodep << endl);
VL_RESTORER(m_state);
{
@ -495,11 +495,11 @@ private:
}
}
}
virtual void visit(AstStop* nodep) override {
void visit(AstStop* nodep) override {
UINFO(4, " STOP: " << nodep << endl);
m_state.m_on = false;
}
virtual void visit(AstPragma* nodep) override {
void visit(AstPragma* nodep) override {
if (nodep->pragType() == VPragmaType::COVERAGE_BLOCK_OFF) {
// Skip all NEXT nodes under this block, and skip this if/case branch
UINFO(4, " OFF: h" << m_state.m_handle << " " << nodep << endl);
@ -510,7 +510,7 @@ private:
lineTrack(nodep);
}
}
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
// Record the hierarchy of any named begins, so we can apply to user
// coverage points. This is because there may be cov points inside
// generate blocks; each point should get separate consideration.
@ -529,7 +529,7 @@ private:
}
// VISITORS - BOTH
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
lineTrack(nodep);
}
@ -537,7 +537,7 @@ private:
public:
// CONSTRUCTORS
explicit CoverageVisitor(AstNetlist* rootp) { iterateChildren(rootp); }
virtual ~CoverageVisitor() override = default;
~CoverageVisitor() override = default;
};
//######################################################################

10
src/V3CoverageJoin.cpp
View File

@ -88,24 +88,24 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Find all Coverage's
iterateChildren(nodep);
// Simplify
detectDuplicates();
}
virtual void visit(AstCoverToggle* nodep) override {
void visit(AstCoverToggle* nodep) override {
m_toggleps.push_back(nodep);
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit CoverageJoinVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~CoverageJoinVisitor() override {
~CoverageJoinVisitor() override {
V3Stats::addStat("Coverage, Toggle points joined", m_statToggleJoins);
}
};

40
src/V3Dead.cpp
View File

@ -102,7 +102,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (m_modp) m_modp->user1Inc(); // e.g. Class under Package
VL_RESTORER(m_modp);
{
@ -120,12 +120,12 @@ private:
}
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->scopep()) nodep->scopep()->user1Inc();
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
@ -136,14 +136,14 @@ private:
m_scopesp.push_back(nodep);
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
m_cellsp.push_back(nodep);
nodep->modp()->user1Inc();
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
// Note NodeAssign skips calling this in some cases
iterateChildren(nodep);
checkAll(nodep);
@ -155,7 +155,7 @@ private:
if (nodep->varp()) nodep->varp()->user1Inc();
if (nodep->classOrPackagep()) nodep->classOrPackagep()->user1Inc();
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->classOrPackagep()) {
@ -166,11 +166,11 @@ private:
}
}
}
virtual void visit(AstMethodCall* nodep) override {
void visit(AstMethodCall* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
}
virtual void visit(AstRefDType* nodep) override {
void visit(AstRefDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
@ -184,7 +184,7 @@ private:
}
}
}
virtual void visit(AstClassRefDType* nodep) override {
void visit(AstClassRefDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
@ -197,12 +197,12 @@ private:
}
if (nodep->classp()) nodep->classp()->user1Inc();
}
virtual void visit(AstNodeDType* nodep) override {
void visit(AstNodeDType* nodep) override {
iterateChildren(nodep);
checkDType(nodep);
checkAll(nodep);
}
virtual void visit(AstEnumItemRef* nodep) override {
void visit(AstEnumItemRef* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->classOrPackagep()) {
@ -214,13 +214,13 @@ private:
}
checkAll(nodep);
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
iterateChildren(nodep);
if (nodep->varp()) nodep->varp()->user1Inc();
if (nodep->fromp()->dtypep()) nodep->fromp()->dtypep()->user1Inc(); // classref
checkAll(nodep);
}
virtual void visit(AstModport* nodep) override {
void visit(AstModport* nodep) override {
iterateChildren(nodep);
if (m_elimCells) {
if (!nodep->varsp()) {
@ -230,14 +230,14 @@ private:
}
checkAll(nodep);
}
virtual void visit(AstSelLoopVars* nodep) override {
void visit(AstSelLoopVars* nodep) override {
// Var under a SelLoopVars means we haven't called V3Width to remove them yet
VL_RESTORER(m_selloopvarsp);
m_selloopvarsp = nodep;
iterateChildren(nodep);
checkAll(nodep);
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
iterateChildren(nodep);
if (m_elimCells && !nodep->attrPublic()) {
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
@ -248,20 +248,20 @@ private:
// Normal modules may disappear, e.g. if they are parameterized then removed
if (nodep->attrPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->scopep()) nodep->scopep()->user1Inc();
if (mightElimVar(nodep->varp())) m_vscsp.push_back(nodep);
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
checkAll(nodep);
if (nodep->isSigPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
if (m_selloopvarsp) nodep->user1Inc();
if (mightElimVar(nodep)) m_varsp.push_back(nodep);
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// See if simple assignments to variables may be eliminated because
// that variable is never used.
// Similar code in V3Life
@ -284,7 +284,7 @@ private:
}
//-----
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (nodep->isOutputter()) m_sideEffect = true;
iterateChildren(nodep);
checkAll(nodep);
@ -446,7 +446,7 @@ public:
// We may have removed some datatypes, cleanup
nodep->typeTablep()->repairCache();
}
virtual ~DeadVisitor() override = default;
~DeadVisitor() override = default;
};
//######################################################################

22
src/V3Delayed.cpp
View File

@ -365,24 +365,24 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// VV***** We reset all userp() on the netlist
m_modVarMap.clear();
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UINFO(4, " MOD " << nodep << endl);
AstNode::user3ClearTree();
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_cfuncp);
{
m_cfuncp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
m_activep = nodep;
VL_RESTORER(m_inInitial);
{
@ -392,7 +392,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
m_inDly = true;
m_nextDlyp
= VN_CAST(nodep->nextp(), AssignDly); // Next assignment in same block, maybe nullptr.
@ -426,7 +426,7 @@ private:
m_nextDlyp = nullptr;
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (!nodep->user2Inc()) { // Not done yet
if (m_inDly && nodep->access().isWriteOrRW()) {
UINFO(4, "AssignDlyVar: " << nodep << endl);
@ -488,18 +488,18 @@ private:
}
}
virtual void visit(AstNodeReadWriteMem* nodep) override {
void visit(AstNodeReadWriteMem* nodep) override {
VL_RESTORER(m_ignoreBlkAndNBlk);
m_ignoreBlkAndNBlk = true; // $readmem/$writemem often used in mem models
// so we will suppress BLKANDNBLK warnings
iterateChildren(nodep);
}
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin");
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
VL_RESTORER(m_inLoop);
{
m_inLoop = true;
@ -508,12 +508,12 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit DelayedVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~DelayedVisitor() override {
~DelayedVisitor() override {
V3Stats::addStat("Optimizations, Delayed shared-sets", m_statSharedSet);
}
};

20
src/V3Depth.cpp
View File

@ -73,7 +73,7 @@ private:
}
// VISITORS
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_cfuncp);
VL_RESTORER(m_mtaskbodyp);
{
@ -85,7 +85,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstMTaskBody* nodep) override {
void visit(AstMTaskBody* nodep) override {
VL_RESTORER(m_cfuncp);
VL_RESTORER(m_mtaskbodyp);
{
@ -106,7 +106,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
} else {
@ -114,8 +114,8 @@ private:
}
}
// Operators
virtual void visit(AstNodeTermop* nodep) override {}
virtual void visit(AstNodeMath* nodep) override {
void visit(AstNodeTermop* nodep) override {}
void visit(AstNodeMath* nodep) override {
// We have some operator defines that use 2 parens, so += 2.
{
VL_RESTORER(m_depth);
@ -142,19 +142,19 @@ private:
m_cfuncp->isStatic(false);
}
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
needNonStaticFunc(nodep);
iterateChildren(nodep);
}
virtual void visit(AstUCStmt* nodep) override {
void visit(AstUCStmt* nodep) override {
needNonStaticFunc(nodep);
visitStmt(nodep);
}
//--------------------
// Default: Just iterate
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't hit varrefs under vars
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -162,7 +162,7 @@ public:
: m_tempNames{"__Vdeeptemp"} {
iterate(nodep);
}
virtual ~DepthVisitor() override = default;
~DepthVisitor() override = default;
};
//######################################################################

14
src/V3DepthBlock.cpp
View File

@ -71,7 +71,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
VL_RESTORER(m_modp);
{
@ -80,7 +80,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// We recurse into this.
VL_RESTORER(m_depth);
VL_RESTORER(m_cfuncp);
@ -106,7 +106,7 @@ private:
}
m_depth--;
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
} else {
@ -114,15 +114,15 @@ private:
}
}
virtual void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNodeMath*) override {} // Accelerate
//--------------------
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't hit varrefs under vars
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit DepthBlockVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~DepthBlockVisitor() override = default;
~DepthBlockVisitor() override = default;
};
//######################################################################

24
src/V3Descope.cpp
View File

@ -185,11 +185,11 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
nodep->dpiExportTriggerp(nullptr);
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
@ -199,17 +199,17 @@ private:
makePublicFuncWrappers();
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
m_scopep = nodep;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
// Delete the varscope when we're finished
nodep->unlinkFrBack();
pushDeletep(nodep);
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
if (!nodep->varScopep()) {
UASSERT_OBJ(nodep->varp()->isFuncLocal(), nodep,
@ -233,7 +233,7 @@ private:
nodep->varScopep(nullptr);
UINFO(9, " refout " << nodep << " selfPtr=" << nodep->selfPointer() << endl);
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
// UINFO(9, " " << nodep << endl);
iterateChildren(nodep);
// Convert the hierch name
@ -243,9 +243,9 @@ private:
// Can't do this, as we may have more calls later
// nodep->funcp()->scopep(nullptr);
}
virtual void visit(AstCMethodCall* nodep) override { iterateChildren(nodep); }
virtual void visit(AstCNew* nodep) override { iterateChildren(nodep); }
virtual void visit(AstCFunc* nodep) override {
void visit(AstCMethodCall* nodep) override { iterateChildren(nodep); }
void visit(AstCNew* nodep) override { iterateChildren(nodep); }
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_funcp);
if (!nodep->user1()) {
// Static functions should have been moved under the corresponding AstClassPackage
@ -268,13 +268,13 @@ private:
}
}
}
virtual void visit(AstVar*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit DescopeVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~DescopeVisitor() override = default;
~DescopeVisitor() override = default;
};
//######################################################################

2
src/V3EmitCBase.h
View File

@ -110,7 +110,7 @@ public:
// CONSTRUCTORS
EmitCBaseVisitor() = default;
virtual ~EmitCBaseVisitor() override = default;
~EmitCBaseVisitor() override = default;
};
#endif // guard

8
src/V3EmitCConstInit.h
View File

@ -45,7 +45,7 @@ class EmitCConstInit VL_NOT_FINAL : public EmitCBaseVisitor {
protected:
// VISITORS
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
VL_RESTORER(m_inUnpacked);
VL_RESTORER(m_unpackedWord);
m_inUnpacked = true;
@ -94,11 +94,11 @@ protected:
}
}
virtual void visit(AstInitItem* nodep) override { // LCOV_EXCL_START
void visit(AstInitItem* nodep) override { // LCOV_EXCL_START
nodep->v3fatal("Handled by AstInitArray");
} // LCOV_EXCL_STOP
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
const V3Number& num = nodep->num();
UASSERT_OBJ(!num.isFourState(), nodep, "4-state value in constant pool");
const AstNodeDType* const dtypep = nodep->dtypep();
@ -145,7 +145,7 @@ protected:
}
// Default
virtual void visit(AstNode* nodep) override { // LCOV_EXCL_START
void visit(AstNode* nodep) override { // LCOV_EXCL_START
nodep->v3fatalSrc("Unknown node type reached EmitCConstInit: " << nodep->prettyTypeName());
} // LCOV_EXCL_STOP
};

2
src/V3EmitCConstPool.cpp
View File

@ -100,7 +100,7 @@ class EmitCConstPool final : public EmitCConstInit {
}
// VISITORS
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
m_outFileSize += nodep->num().isString() ? 10 : nodep->isWide() ? nodep->widthWords() : 1;
EmitCConstInit::visit(nodep);
}

188
src/V3EmitCFunc.h
View File

@ -70,17 +70,17 @@ class EmitCLazyDecls final : public VNVisitor {
}
// VISITORS
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
lazyDeclare(nodep->funcp());
iterateChildren(nodep);
}
virtual void visit(AstAddrOfCFunc* nodep) override {
void visit(AstAddrOfCFunc* nodep) override {
lazyDeclare(nodep->funcp());
iterateChildren(nodep);
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
AstVar* const varp = nodep->varp();
// Only constant pool symbols are lazy declared for now ...
if (EmitCBaseVisitor::isConstPoolMod(EmitCParentModule::get(varp))) {
@ -88,7 +88,7 @@ class EmitCLazyDecls final : public VNVisitor {
}
}
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
VL_DEBUG_FUNC;
@ -213,7 +213,7 @@ public:
// VISITORS
using EmitCConstInit::visit;
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_useSelfForThis);
VL_RESTORER(m_cfuncp);
m_cfuncp = nodep;
@ -281,12 +281,12 @@ public:
if (nodep->ifdef() != "") puts("#endif // " + nodep->ifdef() + "\n");
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
UASSERT_OBJ(m_cfuncp, nodep, "Cannot emit non-local variable");
emitVarDecl(nodep);
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
bool paren = true;
bool decind = false;
bool rhs = true;
@ -368,8 +368,8 @@ public:
if (decind) ofp()->blockDec();
puts(";\n");
}
virtual void visit(AstAlwaysPublic*) override {}
virtual void visit(AstAssocSel* nodep) override {
void visit(AstAlwaysPublic*) override {}
void visit(AstAssocSel* nodep) override {
iterateAndNextNull(nodep->fromp());
putbs(".at(");
AstAssocArrayDType* const adtypep = VN_AS(nodep->fromp()->dtypep(), AssocArrayDType);
@ -381,7 +381,7 @@ public:
}
puts(")");
}
virtual void visit(AstWildcardSel* nodep) override {
void visit(AstWildcardSel* nodep) override {
iterateAndNextNull(nodep->fromp());
putbs(".at(");
AstWildcardArrayDType* const adtypep = VN_AS(nodep->fromp()->dtypep(), WildcardArrayDType);
@ -389,7 +389,7 @@ public:
iterateAndNextNull(nodep->bitp());
puts(")");
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
const AstCFunc* const funcp = nodep->funcp();
const AstNodeModule* const funcModp = EmitCParentModule::get(funcp);
if (funcp->dpiImportPrototype()) {
@ -415,7 +415,7 @@ public:
}
emitCCallArgs(nodep, nodep->selfPointerProtect(m_useSelfForThis));
}
virtual void visit(AstCMethodCall* nodep) override {
void visit(AstCMethodCall* nodep) override {
const AstCFunc* const funcp = nodep->funcp();
UASSERT_OBJ(!funcp->isLoose(), nodep, "Loose method called via AstCMethodCall");
iterate(nodep->fromp());
@ -423,7 +423,7 @@ public:
puts(funcp->nameProtect());
emitCCallArgs(nodep, "");
}
virtual void visit(AstCNew* nodep) override {
void visit(AstCNew* nodep) override {
bool comma = false;
puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
puts("vlSymsp"); // TODO make this part of argsp, and eliminate when unnecessary
@ -435,7 +435,7 @@ public:
}
puts(")");
}
virtual void visit(AstCMethodHard* nodep) override {
void visit(AstCMethodHard* nodep) override {
iterate(nodep->fromp());
puts(".");
puts(nodep->name());
@ -457,8 +457,8 @@ public:
UASSERT_OBJ(!nodep->isStatement() || VN_IS(nodep->dtypep(), VoidDType), nodep,
"Statement of non-void data type");
}
virtual void visit(AstLambdaArgRef* nodep) override { putbs(nodep->nameProtect()); }
virtual void visit(AstWith* nodep) override {
void visit(AstLambdaArgRef* nodep) override { putbs(nodep->nameProtect()); }
void visit(AstWith* nodep) override {
// With uses a C++11 lambda
putbs("[=](");
if (auto* const argrefp = nodep->indexArgRefp()) {
@ -473,11 +473,11 @@ public:
iterateAndNextNull(nodep->exprp());
puts("; }\n");
}
virtual void visit(AstNodeCase* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodeCase* nodep) override { // LCOV_EXCL_LINE
// In V3Case...
nodep->v3fatalSrc("Case statements should have been reduced out");
}
virtual void visit(AstComment* nodep) override {
void visit(AstComment* nodep) override {
string at;
if (nodep->showAt()) {
at = " at " + nodep->fileline()->ascii();
@ -489,7 +489,7 @@ public:
}
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) override {
void visit(AstCoverDecl* nodep) override {
puts("vlSelf->__vlCoverInsert("); // As Declared in emitCoverageDecl
puts("&(vlSymsp->__Vcoverage[");
puts(cvtToStr(nodep->dataDeclThisp()->binNum()));
@ -517,7 +517,7 @@ public:
putsQuoted(nodep->linescov());
puts(");\n");
}
virtual void visit(AstCoverInc* nodep) override {
void visit(AstCoverInc* nodep) override {
if (v3Global.opt.threads()) {
puts("vlSymsp->__Vcoverage[");
puts(cvtToStr(nodep->declp()->dataDeclThisp()->binNum()));
@ -528,17 +528,17 @@ public:
puts("]);\n");
}
}
virtual void visit(AstCReturn* nodep) override {
void visit(AstCReturn* nodep) override {
puts("return (");
iterateAndNextNull(nodep->lhsp());
puts(");\n");
}
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
string text = nodep->fmtp()->text();
if (nodep->addNewline()) text += "\n";
displayNode(nodep, nodep->fmtp()->scopeNamep(), text, nodep->fmtp()->exprsp(), false);
}
virtual void visit(AstDumpCtl* nodep) override {
void visit(AstDumpCtl* nodep) override {
switch (nodep->ctlType()) {
case VDumpCtlType::FILE:
puts("vlSymsp->_vm_contextp__->dumpfile(");
@ -577,7 +577,7 @@ public:
default: nodep->v3fatalSrc("Bad case, unexpected " << nodep->ctlType().ascii());
}
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
// For use under AstCCalls for dpiImports. ScopeNames under
// displays are handled in AstDisplay
if (!nodep->dpiExport()) {
@ -586,20 +586,20 @@ public:
putbs("(&(vlSymsp->" + protect("__Vscope_" + scope) + "))");
}
}
virtual void visit(AstSFormat* nodep) override {
void visit(AstSFormat* nodep) override {
displayNode(nodep, nodep->fmtp()->scopeNamep(), nodep->fmtp()->text(),
nodep->fmtp()->exprsp(), false);
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
displayNode(nodep, nodep->scopeNamep(), nodep->text(), nodep->exprsp(), false);
}
virtual void visit(AstFScanF* nodep) override {
void visit(AstFScanF* nodep) override {
displayNode(nodep, nullptr, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSScanF* nodep) override {
void visit(AstSScanF* nodep) override {
displayNode(nodep, nullptr, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstValuePlusArgs* nodep) override {
void visit(AstValuePlusArgs* nodep) override {
puts("VL_VALUEPLUSARGS_IN");
emitIQW(nodep->outp());
puts("(");
@ -611,19 +611,19 @@ public:
iterateAndNextNull(nodep->outp());
puts(")");
}
virtual void visit(AstTestPlusArgs* nodep) override {
void visit(AstTestPlusArgs* nodep) override {
puts("VL_TESTPLUSARGS_I(");
emitCvtPackStr(nodep->searchp());
puts(")");
}
virtual void visit(AstFError* nodep) override {
void visit(AstFError* nodep) override {
puts("VL_FERROR_IN(");
iterateAndNextNull(nodep->filep());
putbs(", ");
iterateAndNextNull(nodep->strp());
puts(")");
}
virtual void visit(AstFGetS* nodep) override {
void visit(AstFGetS* nodep) override {
checkMaxWords(nodep);
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
}
@ -636,7 +636,7 @@ public:
<< " bits exceeds hardcoded limit VL_VALUE_STRING_MAX_WORDS in verilatedos.h");
}
}
virtual void visit(AstFOpen* nodep) override {
void visit(AstFOpen* nodep) override {
iterateAndNextNull(nodep->filep());
puts(" = VL_FOPEN_NN(");
emitCvtPackStr(nodep->filenamep());
@ -646,13 +646,13 @@ public:
emitCvtPackStr(nodep->modep());
puts(");\n");
}
virtual void visit(AstFOpenMcd* nodep) override {
void visit(AstFOpenMcd* nodep) override {
iterateAndNextNull(nodep->filep());
puts(" = VL_FOPEN_MCD_N(");
emitCvtPackStr(nodep->filenamep());
puts(");\n");
}
virtual void visit(AstNodeReadWriteMem* nodep) override {
void visit(AstNodeReadWriteMem* nodep) override {
puts(nodep->cFuncPrefixp());
puts("N(");
puts(nodep->isHex() ? "true" : "false");
@ -701,14 +701,14 @@ public:
}
puts(");\n");
}
virtual void visit(AstFClose* nodep) override {
void visit(AstFClose* nodep) override {
puts("VL_FCLOSE_I(");
iterateAndNextNull(nodep->filep());
puts("); ");
iterateAndNextNull(nodep->filep()); // For safety, so user doesn't later WRITE with it.
puts(" = 0;\n");
}
virtual void visit(AstFFlush* nodep) override {
void visit(AstFFlush* nodep) override {
if (!nodep->filep()) {
puts("Verilated::runFlushCallbacks();\n");
} else {
@ -719,7 +719,7 @@ public:
puts("); }\n");
}
}
virtual void visit(AstFSeek* nodep) override {
void visit(AstFSeek* nodep) override {
puts("(VL_FSEEK_I(");
iterateAndNextNull(nodep->filep());
puts(",");
@ -728,17 +728,17 @@ public:
iterateAndNextNull(nodep->operation());
puts(") == -1 ? -1 : 0)");
}
virtual void visit(AstFTell* nodep) override {
void visit(AstFTell* nodep) override {
puts("VL_FTELL_I(");
iterateAndNextNull(nodep->filep());
puts(")");
}
virtual void visit(AstFRewind* nodep) override {
void visit(AstFRewind* nodep) override {
puts("(VL_FSEEK_I(");
iterateAndNextNull(nodep->filep());
puts(", 0, 0) == -1 ? -1 : 0)");
}
virtual void visit(AstFRead* nodep) override {
void visit(AstFRead* nodep) override {
puts("VL_FREAD_I(");
puts(cvtToStr(nodep->memp()->widthMin())); // Need real storage width
putbs(",");
@ -781,12 +781,12 @@ public:
}
puts(")");
}
virtual void visit(AstSysFuncAsTask* nodep) override {
void visit(AstSysFuncAsTask* nodep) override {
if (!nodep->lhsp()->isWide()) puts("(void)");
iterateAndNextNull(nodep->lhsp());
if (!nodep->lhsp()->isWide()) puts(";");
}
virtual void visit(AstSystemT* nodep) override {
void visit(AstSystemT* nodep) override {
puts("(void)VL_SYSTEM_I");
emitIQW(nodep->lhsp());
puts("(");
@ -798,7 +798,7 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(");\n");
}
virtual void visit(AstSystemF* nodep) override {
void visit(AstSystemF* nodep) override {
puts("VL_SYSTEM_I");
emitIQW(nodep->lhsp());
puts("(");
@ -810,20 +810,20 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(")");
}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
nodep->labelNum(++m_labelNum);
puts("{\n"); // Make it visually obvious label jumps outside these
iterateAndNextNull(nodep->stmtsp());
iterateAndNextNull(nodep->endStmtsp());
puts("}\n");
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
puts("goto __Vlabel" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
}
virtual void visit(AstJumpLabel* nodep) override {
void visit(AstJumpLabel* nodep) override {
puts("__Vlabel" + cvtToStr(nodep->blockp()->labelNum()) + ": ;\n");
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
iterateAndNextNull(nodep->precondsp());
puts("while (");
iterateAndNextNull(nodep->condp());
@ -833,7 +833,7 @@ public:
iterateAndNextNull(nodep->precondsp()); // Need to recompute before next loop
puts("}\n");
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
puts("if (");
if (!nodep->branchPred().unknown()) {
puts(nodep->branchPred().ascii());
@ -857,7 +857,7 @@ public:
}
}
}
virtual void visit(AstExprStmt* nodep) override {
void visit(AstExprStmt* nodep) override {
// GCC allows compound statements in expressions, but this is not standard.
// So we use an immediate-evaluation lambda and comma operator
putbs("([&]() {\n");
@ -866,7 +866,7 @@ public:
iterateAndNextNull(nodep->resultp());
puts(")");
}
virtual void visit(AstStop* nodep) override {
void visit(AstStop* nodep) override {
puts("VL_STOP_MT(");
putsQuoted(protect(nodep->fileline()->filename()));
puts(", ");
@ -874,38 +874,38 @@ public:
puts(", \"\"");
puts(");\n");
}
virtual void visit(AstFinish* nodep) override {
void visit(AstFinish* nodep) override {
puts("VL_FINISH_MT(");
putsQuoted(protect(nodep->fileline()->filename()));
puts(", ");
puts(cvtToStr(nodep->fileline()->lineno()));
puts(", \"\");\n");
}
virtual void visit(AstPrintTimeScale* nodep) override {
void visit(AstPrintTimeScale* nodep) override {
puts("VL_PRINTTIMESCALE(");
putsQuoted(protect(nodep->name()));
puts(", ");
putsQuoted(nodep->timeunit().ascii());
puts(", vlSymsp->_vm_contextp__);\n");
}
virtual void visit(AstRand* nodep) override {
void visit(AstRand* nodep) override {
emitOpName(nodep, nodep->emitC(), nodep->seedp(), nullptr, nullptr);
}
virtual void visit(AstTime* nodep) override {
void visit(AstTime* nodep) override {
puts("VL_TIME_UNITED_Q(");
if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$time has no units");
puts(cvtToStr(nodep->timeunit().multiplier()
/ v3Global.rootp()->timeprecision().multiplier()));
puts(")");
}
virtual void visit(AstTimeD* nodep) override {
void visit(AstTimeD* nodep) override {
puts("VL_TIME_UNITED_D(");
if (nodep->timeunit().isNone()) nodep->v3fatalSrc("$realtime has no units");
puts(cvtToStr(nodep->timeunit().multiplier()
/ v3Global.rootp()->timeprecision().multiplier()));
puts(")");
}
virtual void visit(AstTimeFormat* nodep) override {
void visit(AstTimeFormat* nodep) override {
puts("VL_TIMEFORMAT_IINI(");
iterateAndNextNull(nodep->unitsp());
puts(", ");
@ -916,7 +916,7 @@ public:
iterateAndNextNull(nodep->widthp());
puts(", vlSymsp->_vm_contextp__);\n");
}
virtual void visit(AstNodeSimpleText* nodep) override {
void visit(AstNodeSimpleText* nodep) override {
const string text = m_inUC && m_useSelfForThis
? VString::replaceWord(nodep->text(), "this", "vlSelf")
: nodep->text();
@ -926,29 +926,29 @@ public:
ofp()->putsNoTracking(text);
}
}
virtual void visit(AstTextBlock* nodep) override {
void visit(AstTextBlock* nodep) override {
visit(static_cast<AstNodeSimpleText*>(nodep));
for (AstNode* childp = nodep->nodesp(); childp; childp = childp->nextp()) {
iterate(childp);
if (nodep->commas() && childp->nextp()) puts(", ");
}
}
virtual void visit(AstCStmt* nodep) override {
void visit(AstCStmt* nodep) override {
putbs("");
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstCMath* nodep) override {
void visit(AstCMath* nodep) override {
putbs("");
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstUCStmt* nodep) override {
void visit(AstUCStmt* nodep) override {
VL_RESTORER(m_inUC);
m_inUC = true;
putsDecoration(ifNoProtect("// $c statement at " + nodep->fileline()->ascii() + "\n"));
iterateAndNextNull(nodep->bodysp());
puts("\n");
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
VL_RESTORER(m_inUC);
m_inUC = true;
puts("\n");
@ -958,10 +958,10 @@ public:
}
// Operators
virtual void visit(AstNodeTermop* nodep) override {
void visit(AstNodeTermop* nodep) override {
emitOpName(nodep, nodep->emitC(), nullptr, nullptr, nullptr);
}
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeUniop* nodep) override {
if (nodep->emitCheckMaxWords()
&& (nodep->widthWords() > VL_MULS_MAX_WORDS
|| nodep->lhsp()->widthWords() > VL_MULS_MAX_WORDS)) {
@ -981,7 +981,7 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nullptr, nullptr);
}
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
if (nodep->emitCheckMaxWords() && nodep->widthWords() > VL_MULS_MAX_WORDS) {
nodep->v3warn(
E_UNSUPPORTED,
@ -1001,11 +1001,11 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
}
}
virtual void visit(AstNodeTriop* nodep) override {
void visit(AstNodeTriop* nodep) override {
UASSERT_OBJ(!emitSimpleOk(nodep), nodep, "Triop cannot be described in a simple way");
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nodep->thsp());
}
virtual void visit(AstRedXor* nodep) override {
void visit(AstRedXor* nodep) override {
if (nodep->lhsp()->isWide()) {
visit(static_cast<AstNodeUniop*>(nodep));
} else {
@ -1021,7 +1021,7 @@ public:
puts(")");
}
}
virtual void visit(AstCCast* nodep) override {
void visit(AstCCast* nodep) override {
// Extending a value of the same word width is just a NOP.
if (nodep->size() <= VL_IDATASIZE) {
puts("(IData)(");
@ -1031,7 +1031,7 @@ public:
iterateAndNextNull(nodep->lhsp());
puts(")");
}
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
// Widths match up already, so we'll just use C++'s operator w/o any temps.
if (nodep->expr1p()->isWide()) {
emitOpName(nodep, nodep->emitC(), nodep->condp(), nodep->expr1p(), nodep->expr2p());
@ -1045,12 +1045,12 @@ public:
puts(")");
}
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
iterateAndNextNull(nodep->fromp());
putbs("->");
puts(nodep->varp()->nameProtect());
}
virtual void visit(AstNullCheck* nodep) override {
void visit(AstNullCheck* nodep) override {
puts("VL_NULL_CHECK(");
iterateAndNextNull(nodep->lhsp());
puts(", ");
@ -1059,17 +1059,17 @@ public:
puts(cvtToStr(nodep->fileline()->lineno()));
puts(")");
}
virtual void visit(AstNewCopy* nodep) override {
void visit(AstNewCopy* nodep) override {
puts("std::make_shared<" + prefixNameProtect(nodep->dtypep()) + ">(");
puts("*"); // i.e. make into a reference
iterateAndNextNull(nodep->rhsp());
puts(")");
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
// Note ASSIGN checks for this on a LHS
emitOpName(nodep, nodep->emitC(), nodep->fromp(), nodep->lsbp(), nodep->thsp());
}
virtual void visit(AstReplicate* nodep) override {
void visit(AstReplicate* nodep) override {
if (nodep->lhsp()->widthMin() == 1 && !nodep->isWide()) {
UASSERT_OBJ((static_cast<int>(VN_AS(nodep->rhsp(), Const)->toUInt())
* nodep->lhsp()->widthMin())
@ -1088,7 +1088,7 @@ public:
emitOpName(nodep, nodep->emitC(), nodep->lhsp(), nodep->rhsp(), nullptr);
}
}
virtual void visit(AstStreamL* nodep) override {
void visit(AstStreamL* nodep) override {
// Attempt to use a "fast" stream function for slice size = power of 2
if (!nodep->isWide()) {
const uint32_t isPow2 = VN_AS(nodep->rhsp(), Const)->num().countOnes() == 1;
@ -1110,14 +1110,14 @@ public:
emitOpName(nodep, "VL_STREAML_%nq%lq%rq(%lw, %P, %li, %ri)", nodep->lhsp(), nodep->rhsp(),
nullptr);
}
virtual void visit(AstCastDynamic* nodep) override {
void visit(AstCastDynamic* nodep) override {
putbs("VL_CAST_DYNAMIC(");
iterateAndNextNull(nodep->lhsp());
puts(", ");
iterateAndNextNull(nodep->rhsp());
puts(")");
}
virtual void visit(AstCountBits* nodep) override {
void visit(AstCountBits* nodep) override {
putbs("VL_COUNTBITS_");
emitIQW(nodep->lhsp());
puts("(");
@ -1137,9 +1137,9 @@ public:
iterateAndNextNull(nodep->fhsp());
puts(")");
}
virtual void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
void visit(AstInitItem* nodep) override { iterateChildren(nodep); }
// Terminals
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
const AstVar* const varp = nodep->varp();
const AstNodeModule* const varModp = EmitCParentModule::get(varp);
if (isConstPoolMod(varModp)) {
@ -1156,14 +1156,14 @@ public:
}
puts(nodep->varp()->nameProtect());
}
virtual void visit(AstAddrOfCFunc* nodep) override {
void visit(AstAddrOfCFunc* nodep) override {
// Note: Can be thought to handle more, but this is all that is needed right now
const AstCFunc* const funcp = nodep->funcp();
UASSERT_OBJ(funcp->isLoose(), nodep, "Cannot take address of non-loose method");
puts("&");
puts(funcNameProtect(funcp));
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
if (m_emitConstInit) {
EmitCConstInit::visit(nodep);
} else if (nodep->isWide()) {
@ -1176,12 +1176,12 @@ public:
}
//
virtual void visit(AstMTaskBody* nodep) override {
void visit(AstMTaskBody* nodep) override {
VL_RESTORER(m_useSelfForThis);
m_useSelfForThis = true;
iterateChildrenConst(nodep);
}
virtual void visit(AstConsAssoc* nodep) override {
void visit(AstConsAssoc* nodep) override {
putbs(nodep->dtypep()->cType("", false, false));
puts("()");
if (nodep->defaultp()) {
@ -1190,7 +1190,7 @@ public:
puts(")");
}
}
virtual void visit(AstSetAssoc* nodep) override {
void visit(AstSetAssoc* nodep) override {
iterateAndNextNull(nodep->lhsp());
putbs(".set(");
iterateAndNextNull(nodep->keyp());
@ -1199,7 +1199,7 @@ public:
iterateAndNextNull(nodep->valuep());
puts(")");
}
virtual void visit(AstConsWildcard* nodep) override {
void visit(AstConsWildcard* nodep) override {
putbs(nodep->dtypep()->cType("", false, false));
puts("()");
if (nodep->defaultp()) {
@ -1208,7 +1208,7 @@ public:
puts(")");
}
}
virtual void visit(AstSetWildcard* nodep) override {
void visit(AstSetWildcard* nodep) override {
iterateAndNextNull(nodep->lhsp());
putbs(".set(");
iterateAndNextNull(nodep->keyp());
@ -1217,7 +1217,7 @@ public:
iterateAndNextNull(nodep->valuep());
puts(")");
}
virtual void visit(AstConsDynArray* nodep) override {
void visit(AstConsDynArray* nodep) override {
putbs(nodep->dtypep()->cType("", false, false));
if (!nodep->lhsp()) {
puts("()");
@ -1232,7 +1232,7 @@ public:
puts(")");
}
}
virtual void visit(AstConsQueue* nodep) override {
void visit(AstConsQueue* nodep) override {
putbs(nodep->dtypep()->cType("", false, false));
if (!nodep->lhsp()) {
puts("()");
@ -1247,22 +1247,22 @@ public:
puts(")");
}
}
virtual void visit(AstCReset* nodep) override {
void visit(AstCReset* nodep) override {
AstVar* const varp = nodep->varrefp()->varp();
emitVarReset(varp);
}
virtual void visit(AstExecGraph* nodep) override {
void visit(AstExecGraph* nodep) override {
// The location of the AstExecGraph within the containing AstCFunc is where we want to
// invoke the graph and wait for it to complete. Emitting the children does just that.
UASSERT_OBJ(!nodep->mTaskBodiesp(), nodep, "These should have been lowered");
iterateChildrenConst(nodep);
}
virtual void visit(AstChangeDet* nodep) override { //
void visit(AstChangeDet* nodep) override { //
m_blkChangeDetVec.push_back(nodep);
}
// Default
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
puts(string("\n???? // ") + nodep->prettyTypeName() + "\n");
iterateChildren(nodep);
// LCOV_EXCL_START
@ -1280,7 +1280,7 @@ public:
m_trackText = trackText;
iterate(nodep);
}
virtual ~EmitCFunc() override = default;
~EmitCFunc() override = default;
};
#endif // guard

2
src/V3EmitCHeaders.cpp
View File

@ -326,7 +326,7 @@ class EmitCHeader final : public EmitCConstInit {
// Close output file
VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
}
virtual ~EmitCHeader() override = default;
~EmitCHeader() override = default;
public:
static void main(const AstNodeModule* modp) { EmitCHeader emitCHeader(modp); }

44
src/V3EmitCImp.cpp
View File

@ -68,59 +68,59 @@ class EmitCGatherDependencies final : VNVisitor {
}
// VISITORS
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
addSelfDependency(nodep->selfPointer(), nodep->funcp());
iterateChildrenConst(nodep);
}
virtual void visit(AstCNew* nodep) override {
void visit(AstCNew* nodep) override {
addDTypeDependency(nodep->dtypep());
iterateChildrenConst(nodep);
}
virtual void visit(AstCMethodCall* nodep) override {
void visit(AstCMethodCall* nodep) override {
addDTypeDependency(nodep->fromp()->dtypep());
iterateChildrenConst(nodep);
}
virtual void visit(AstNewCopy* nodep) override {
void visit(AstNewCopy* nodep) override {
addDTypeDependency(nodep->dtypep());
iterateChildrenConst(nodep);
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
addDTypeDependency(nodep->fromp()->dtypep());
iterateChildrenConst(nodep);
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
addSelfDependency(nodep->selfPointer(), nodep->varp());
iterateChildrenConst(nodep);
}
virtual void visit(AstCoverDecl* nodep) override {
void visit(AstCoverDecl* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstCoverInc* nodep) override {
void visit(AstCoverInc* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstDumpCtl* nodep) override {
void visit(AstDumpCtl* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstPrintTimeScale* nodep) override {
void visit(AstPrintTimeScale* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstTimeFormat* nodep) override {
void visit(AstTimeFormat* nodep) override {
addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstNodeSimpleText* nodep) override {
void visit(AstNodeSimpleText* nodep) override {
if (nodep->text().find("vlSymsp") != string::npos) addSymsDependency();
iterateChildrenConst(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
void visit(AstNode* nodep) override { iterateChildrenConst(nodep); }
// CONSTRUCTOR
explicit EmitCGatherDependencies(AstCFunc* cfuncp) {
@ -512,7 +512,7 @@ class EmitCImp final : EmitCFunc {
}
// VISITORS
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (splitNeeded()) {
// Splitting file, so using parallel build.
v3Global.useParallelBuild(true);
@ -544,7 +544,7 @@ class EmitCImp final : EmitCFunc {
// Emit implementations of all AstCFunc
emitCFuncImp(modp);
}
virtual ~EmitCImp() override = default;
~EmitCImp() override = default;
public:
static void main(const AstNodeModule* modp, bool slow, std::deque<AstCFile*>& cfilesr) {
@ -823,7 +823,7 @@ class EmitCTrace final : EmitCFunc {
// VISITORS
using EmitCFunc::visit; // Suppress hidden overloaded virtual function warning
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!nodep->isTrace()) return;
if (nodep->slow() != m_slow) return;
@ -838,17 +838,17 @@ class EmitCTrace final : EmitCFunc {
EmitCFunc::visit(nodep);
}
virtual void visit(AstTracePushNamePrefix* nodep) override {
void visit(AstTracePushNamePrefix* nodep) override {
puts("tracep->pushNamePrefix(");
putsQuoted(VIdProtect::protectWordsIf(nodep->prefix(), nodep->protect()));
puts(");\n");
}
virtual void visit(AstTracePopNamePrefix* nodep) override { //
void visit(AstTracePopNamePrefix* nodep) override { //
puts("tracep->popNamePrefix(");
puts(cvtToStr(nodep->count()));
puts(");\n");
}
virtual void visit(AstTraceDecl* nodep) override {
void visit(AstTraceDecl* nodep) override {
const int enumNum = emitTraceDeclDType(nodep->dtypep());
if (nodep->arrayRange().ranged()) {
puts("for (int i = 0; i < " + cvtToStr(nodep->arrayRange().elements()) + "; ++i) {\n");
@ -859,7 +859,7 @@ class EmitCTrace final : EmitCFunc {
puts("\n");
}
}
virtual void visit(AstTraceInc* nodep) override {
void visit(AstTraceInc* nodep) override {
if (nodep->declp()->arrayRange().ranged()) {
// It traces faster if we unroll the loop
for (int i = 0; i < nodep->declp()->arrayRange().elements(); i++) {
@ -883,7 +883,7 @@ class EmitCTrace final : EmitCFunc {
// Close output file
VL_DO_CLEAR(delete m_ofp, m_ofp = nullptr);
}
virtual ~EmitCTrace() override = default;
~EmitCTrace() override = default;
public:
static void main(AstNodeModule* modp, bool slow, std::deque<AstCFile*>& cfilesr) {

6
src/V3EmitCInlines.cpp
View File

@ -32,18 +32,18 @@ class EmitCInlines final : EmitCBaseVisitor {
// METHODS
// VISITORS
virtual void visit(AstCNew* nodep) override {
void visit(AstCNew* nodep) override {
if (v3Global.opt.savable())
v3warn(E_UNSUPPORTED, "Unsupported: --savable with dynamic new");
iterateChildren(nodep);
}
virtual void visit(AstDumpCtl* nodep) override {
void visit(AstDumpCtl* nodep) override {
if (v3Global.opt.trace()) v3Global.needTraceDumper(true);
iterateChildren(nodep);
}
//---------------------------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
explicit EmitCInlines(AstNetlist* nodep) { iterate(nodep); }

2
src/V3EmitCMain.cpp
View File

@ -32,7 +32,7 @@ class EmitCMain final : EmitCBaseVisitor {
// VISITORS
// This visitor doesn't really iterate, but exist to appease base class
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); } // LCOV_EXCL_LINE
void visit(AstNode* nodep) override { iterateChildren(nodep); } // LCOV_EXCL_LINE
public:
// CONSTRUCTORS

2
src/V3EmitCModel.cpp
View File

@ -190,7 +190,7 @@ class EmitCModel final : public EmitCFunc {
+ "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 override { "
puts("void trace(sc_trace_file* tfp) const override { "
"::sc_core::sc_module::trace(tfp); }\n");
}
}

22
src/V3EmitCSyms.cpp
View File

@ -258,7 +258,7 @@ class EmitCSyms final : EmitCBaseVisitor {
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Collect list of scopes
iterateChildren(nodep);
varsExpand();
@ -280,8 +280,8 @@ class EmitCSyms final : EmitCBaseVisitor {
if (!m_dpiHdrOnly) emitDpiImp();
}
}
virtual void visit(AstConstPool* nodep) override {} // Ignore
virtual void visit(AstNodeModule* nodep) override {
void visit(AstConstPool* nodep) override {} // Ignore
void visit(AstNodeModule* nodep) override {
nameCheck(nodep);
VL_RESTORER(m_modp);
{
@ -289,7 +289,7 @@ class EmitCSyms final : EmitCBaseVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstCellInline* nodep) override {
void visit(AstCellInline* nodep) override {
if (v3Global.opt.vpi()) {
const string type
= (nodep->origModName() == "__BEGIN__") ? "SCOPE_OTHER" : "SCOPE_MODULE";
@ -300,7 +300,7 @@ class EmitCSyms final : EmitCBaseVisitor {
std::make_pair(name, ScopeData(scopeSymString(name), name_dedot, timeunit, type)));
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
if (VN_IS(m_modp, Class)) return; // The ClassPackage is what is visible
nameCheck(nodep);
@ -315,7 +315,7 @@ class EmitCSyms final : EmitCBaseVisitor {
timeunit, type)));
}
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
const string name = nodep->scopeSymName();
// UINFO(9,"scnameins sp "<<nodep->name()<<" sp "<<nodep->scopePrettySymName()
// <<" ss"<<name<<endl);
@ -337,19 +337,19 @@ class EmitCSyms final : EmitCBaseVisitor {
}
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
nameCheck(nodep);
iterateChildren(nodep);
if (nodep->isSigUserRdPublic() && !m_cfuncp)
m_modVars.emplace_back(std::make_pair(m_modp, nodep));
}
virtual void visit(AstCoverDecl* nodep) override {
void visit(AstCoverDecl* nodep) override {
// Assign numbers to all bins, so we know how big of an array to use
if (!nodep->dataDeclNullp()) { // else duplicate we don't need code for
nodep->binNum(m_coverBins++);
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
nameCheck(nodep);
if (nodep->dpiImportPrototype() || nodep->dpiExportDispatcher()) m_dpis.push_back(nodep);
VL_RESTORER(m_cfuncp);
@ -360,8 +360,8 @@ class EmitCSyms final : EmitCBaseVisitor {
}
//---------------------------------------
virtual void visit(AstConst*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstConst*) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
explicit EmitCSyms(AstNetlist* nodep, bool dpiHdrOnly)

236
src/V3EmitV.cpp
View File

@ -53,14 +53,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
// VISITORS
virtual void visit(AstNetlist* nodep) override { iterateAndNextConstNull(nodep->modulesp()); }
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNetlist* nodep) override { iterateAndNextConstNull(nodep->modulesp()); }
void visit(AstNodeModule* nodep) override {
putfs(nodep, nodep->verilogKwd() + " " + prefixNameProtect(nodep) + ";\n");
iterateChildrenConst(nodep);
putqs(nodep, "end" + nodep->verilogKwd() + "\n");
}
virtual void visit(AstPort* nodep) override {}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstPort* nodep) override {}
void visit(AstNodeFTask* nodep) override {
putfs(nodep, nodep->isFunction() ? "function" : "task");
puts(" ");
puts(nodep->prettyName());
@ -70,7 +70,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
putfs(nodep, nodep->isFunction() ? "endfunction\n" : "endtask\n");
}
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
if (nodep->name() == "") {
putbs("begin\n");
} else {
@ -79,7 +79,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateChildrenConst(nodep);
puts("end\n");
}
virtual void visit(AstFork* nodep) override {
void visit(AstFork* nodep) override {
if (nodep->name() == "") {
putbs("fork\n");
} else {
@ -89,19 +89,19 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
puts(nodep->joinType().verilogKwd());
puts("\n");
}
virtual void visit(AstFinal* nodep) override {
void visit(AstFinal* nodep) override {
putfs(nodep, "final begin\n");
iterateChildrenConst(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstInitial* nodep) override {
void visit(AstInitial* nodep) override {
putfs(nodep, "initial begin\n");
iterateChildrenConst(nodep);
putqs(nodep, "end\n");
}
virtual void visit(AstInitialAutomatic* nodep) override { iterateChildrenConst(nodep); }
virtual void visit(AstInitialStatic* nodep) override { iterateChildrenConst(nodep); }
virtual void visit(AstAlways* nodep) override {
void visit(AstInitialAutomatic* nodep) override { iterateChildrenConst(nodep); }
void visit(AstInitialStatic* nodep) override { iterateChildrenConst(nodep); }
void visit(AstAlways* nodep) override {
putfs(nodep, "always ");
if (m_sensesp) {
iterateAndNextConstNull(m_sensesp);
@ -113,7 +113,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
putfs(nodep, "/*verilator public_flat_rw ");
if (m_sensesp) {
iterateAndNextConstNull(m_sensesp);
@ -125,43 +125,43 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->bodysp());
putqs(nodep, "*/\n");
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (VN_IS(nodep, AssignForce)) puts("force ");
iterateAndNextConstNull(nodep->lhsp());
putfs(nodep, " " + nodep->verilogKwd() + " ");
iterateAndNextConstNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
iterateAndNextConstNull(nodep->lhsp());
putfs(nodep, " <= ");
iterateAndNextConstNull(nodep->rhsp());
puts(";\n");
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
putbs("alias ");
iterateAndNextConstNull(nodep->lhsp());
putfs(nodep, " = ");
iterateAndNextConstNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
putfs(nodep, "assign ");
iterateAndNextConstNull(nodep->lhsp());
putbs(" = ");
iterateAndNextConstNull(nodep->rhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstRelease* nodep) override {
void visit(AstRelease* nodep) override {
puts("release ");
iterateAndNextConstNull(nodep->lhsp());
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstBreak*) override {
void visit(AstBreak*) override {
putbs("break");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
// AstSenItem is called for dumping in isolation by V3Order
putfs(nodep, "@(");
for (AstNode* expp = nodep->sensesp(); expp; expp = expp->nextp()) {
@ -170,13 +170,13 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
putfs(nodep, "");
puts(nodep->edgeType().verilogKwd());
if (nodep->sensp()) puts(" ");
iterateChildrenConst(nodep);
}
virtual void visit(AstNodeCase* nodep) override {
void visit(AstNodeCase* nodep) override {
putfs(nodep, "");
if (const AstCase* const casep = VN_CAST(nodep, Case)) {
if (casep->priorityPragma()) puts("priority ");
@ -197,7 +197,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->itemsp());
putqs(nodep, "endcase\n");
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
if (nodep->condsp()) {
iterateAndNextConstNull(nodep->condsp());
} else {
@ -207,17 +207,17 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstComment* nodep) override {
void visit(AstComment* nodep) override {
puts(std::string{"// "} + nodep->name() + "\n");
iterateChildrenConst(nodep);
}
virtual void visit(AstContinue*) override {
void visit(AstContinue*) override {
putbs("continue");
if (!m_suppressSemi) puts(";\n");
}
virtual void visit(AstCoverDecl*) override {} // N/A
virtual void visit(AstCoverInc*) override {} // N/A
virtual void visit(AstCoverToggle*) override {} // N/A
void visit(AstCoverDecl*) override {} // N/A
void visit(AstCoverInc*) override {} // N/A
void visit(AstCoverToggle*) override {} // N/A
void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp, const string& text,
AstNode* exprsp) {
@ -234,26 +234,26 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(");\n");
}
virtual void visit(AstDisable* nodep) override { putbs("disable " + nodep->name() + ";\n"); }
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisable* nodep) override { putbs("disable " + nodep->name() + ";\n"); }
void visit(AstDisplay* nodep) override {
visitNodeDisplay(nodep, nodep->filep(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstElabDisplay* nodep) override {
void visit(AstElabDisplay* nodep) override {
visitNodeDisplay(nodep, nullptr, nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstFScanF* nodep) override {
void visit(AstFScanF* nodep) override {
visitNodeDisplay(nodep, nodep->filep(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSScanF* nodep) override {
void visit(AstSScanF* nodep) override {
visitNodeDisplay(nodep, nodep->fromp(), nodep->text(), nodep->exprsp());
}
virtual void visit(AstSFormat* nodep) override {
void visit(AstSFormat* nodep) override {
visitNodeDisplay(nodep, nodep->lhsp(), nodep->fmtp()->text(), nodep->fmtp()->exprsp());
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
visitNodeDisplay(nodep, nullptr, nodep->text(), nodep->exprsp());
}
virtual void visit(AstFOpen* nodep) override {
void visit(AstFOpen* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
iterateAndNextConstNull(nodep->filenamep());
@ -261,36 +261,34 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->modep());
puts(");\n");
}
virtual void visit(AstFOpenMcd* nodep) override {
void visit(AstFOpenMcd* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
iterateAndNextConstNull(nodep->filenamep());
puts(");\n");
}
virtual void visit(AstFClose* nodep) override {
void visit(AstFClose* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
if (nodep->filep()) iterateAndNextConstNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstFFlush* nodep) override {
void visit(AstFFlush* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
if (nodep->filep()) iterateAndNextConstNull(nodep->filep());
puts(");\n");
}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
putbs("begin : label" + cvtToStr(nodep->labelNum()) + "\n");
if (nodep->stmtsp()) iterateAndNextConstNull(nodep->stmtsp());
puts("end\n");
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
putbs("disable label" + cvtToStr(nodep->labelp()->blockp()->labelNum()) + ";\n");
}
virtual void visit(AstJumpLabel* nodep) override {
putbs("// " + cvtToStr(nodep->blockp()) + ":\n");
}
virtual void visit(AstNodeReadWriteMem* nodep) override {
void visit(AstJumpLabel* nodep) override { putbs("// " + cvtToStr(nodep->blockp()) + ":\n"); }
void visit(AstNodeReadWriteMem* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
if (nodep->filenamep()) iterateAndNextConstNull(nodep->filenamep());
@ -306,17 +304,17 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(");\n");
}
virtual void visit(AstSysFuncAsTask* nodep) override {
void visit(AstSysFuncAsTask* nodep) override {
iterateAndNextConstNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstSysIgnore* nodep) override {
void visit(AstSysIgnore* nodep) override {
putfs(nodep, nodep->verilogKwd());
putbs("(");
iterateAndNextConstNull(nodep->exprsp());
puts(");\n");
}
virtual void visit(AstNodeFor* nodep) override {
void visit(AstNodeFor* nodep) override {
putfs(nodep, "for (");
{
VL_RESTORER(m_suppressSemi);
@ -331,14 +329,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->bodysp());
putqs(nodep, "end\n");
}
virtual void visit(AstRepeat* nodep) override {
void visit(AstRepeat* nodep) override {
putfs(nodep, "repeat (");
iterateAndNextConstNull(nodep->countp());
puts(") begin\n");
iterateAndNextConstNull(nodep->bodysp());
putfs(nodep, "end\n");
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
iterateAndNextConstNull(nodep->precondsp());
putfs(nodep, "while (");
iterateAndNextConstNull(nodep->condp());
@ -348,7 +346,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->precondsp()); // Need to recompute before next loop
putfs(nodep, "end\n");
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
putfs(nodep, "");
if (const AstIf* const ifp = VN_CAST(nodep, If)) {
if (ifp->priorityPragma()) puts("priority ");
@ -366,7 +364,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
putqs(nodep, "end\n");
}
virtual void visit(AstPast* nodep) override {
void visit(AstPast* nodep) override {
putfs(nodep, "$past(");
iterateAndNextConstNull(nodep->exprp());
if (nodep->ticksp()) {
@ -375,21 +373,21 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstReturn* nodep) override {
void visit(AstReturn* nodep) override {
putfs(nodep, "return ");
iterateAndNextConstNull(nodep->lhsp());
puts(";\n");
}
virtual void visit(AstStop* nodep) override { putfs(nodep, "$stop;\n"); }
virtual void visit(AstFinish* nodep) override { putfs(nodep, "$finish;\n"); }
virtual void visit(AstNodeSimpleText* nodep) override {
void visit(AstStop* nodep) override { putfs(nodep, "$stop;\n"); }
void visit(AstFinish* nodep) override { putfs(nodep, "$finish;\n"); }
void visit(AstNodeSimpleText* nodep) override {
if (nodep->tracking() || m_trackText) {
puts(nodep->text());
} else {
putsNoTracking(nodep->text());
}
}
virtual void visit(AstTextBlock* nodep) override {
void visit(AstTextBlock* nodep) override {
visit(static_cast<AstNodeSimpleText*>(nodep));
{
VL_RESTORER(m_suppressSemi);
@ -400,23 +398,23 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
}
}
virtual void visit(AstScopeName* nodep) override {}
virtual void visit(AstCStmt* nodep) override {
void visit(AstScopeName* nodep) override {}
void visit(AstCStmt* nodep) override {
putfs(nodep, "$_CSTMT(");
iterateAndNextConstNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstCMath* nodep) override {
void visit(AstCMath* nodep) override {
putfs(nodep, "$_CMATH(");
iterateAndNextConstNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCStmt* nodep) override {
void visit(AstUCStmt* nodep) override {
putfs(nodep, "$c(");
iterateAndNextConstNull(nodep->bodysp());
puts(");\n");
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
putfs(nodep, "$c(");
iterateAndNextConstNull(nodep->bodysp());
puts(")");
@ -481,25 +479,23 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
}
virtual void visit(AstNodeTermop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog());
}
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeTermop* nodep) override { emitVerilogFormat(nodep, nodep->emitVerilog()); }
void visit(AstNodeUniop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp());
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp());
}
virtual void visit(AstNodeTriop* nodep) override {
void visit(AstNodeTriop* nodep) override {
emitVerilogFormat(nodep, nodep->emitVerilog(), nodep->lhsp(), nodep->rhsp(),
nodep->thsp());
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
iterate(nodep->fromp());
puts(".");
puts(nodep->prettyName());
}
virtual void visit(AstAttrOf* nodep) override {
void visit(AstAttrOf* nodep) override {
putfs(nodep, "$_ATTROF(");
iterateAndNextConstNull(nodep->fromp());
if (nodep->dimp()) {
@ -508,7 +504,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(")");
}
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
putfs(nodep, "'{");
int comma = 0;
const auto& mapr = nodep->map();
@ -521,7 +517,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts("}");
}
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
putbs("(");
iterateAndNextConstNull(nodep->condp());
putfs(nodep, " ? ");
@ -530,7 +526,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->expr2p());
puts(")");
}
virtual void visit(AstRange* nodep) override {
void visit(AstRange* nodep) override {
puts("[");
if (VN_IS(nodep->leftp(), Const) && VN_IS(nodep->rightp(), Const)) {
// Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
@ -545,7 +541,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
puts("]");
}
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
iterateAndNextConstNull(nodep->fromp());
puts("[");
if (VN_IS(nodep->lsbp(), Const)) {
@ -569,18 +565,18 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts("]");
}
virtual void visit(AstSliceSel* nodep) override {
void visit(AstSliceSel* nodep) override {
iterateAndNextConstNull(nodep->fromp());
puts(cvtToStr(nodep->declRange()));
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
putfs(nodep, "typedef ");
iterateAndNextConstNull(nodep->dtypep());
puts(" ");
puts(nodep->prettyName());
puts(";\n");
}
virtual void visit(AstBasicDType* nodep) override {
void visit(AstBasicDType* nodep) override {
if (nodep->isSigned()) putfs(nodep, "signed ");
putfs(nodep, nodep->prettyName());
if (nodep->rangep()) {
@ -593,15 +589,15 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
puts(":0] ");
}
}
virtual void visit(AstConstDType* nodep) override {
void visit(AstConstDType* nodep) override {
putfs(nodep, "const ");
iterate(nodep->subDTypep());
}
virtual void visit(AstNodeArrayDType* nodep) override {
void visit(AstNodeArrayDType* nodep) override {
iterate(nodep->subDTypep());
iterateAndNextConstNull(nodep->rangep());
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
puts(nodep->verilogKwd() + " ");
if (nodep->packed()) puts("packed ");
puts("\n");
@ -609,12 +605,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->membersp());
puts("}");
}
virtual void visit(AstMemberDType* nodep) override {
void visit(AstMemberDType* nodep) override {
iterate(nodep->subDTypep());
puts(" ");
puts(nodep->name());
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
if (nodep->dotted() != "") {
putfs(nodep, nodep->dotted());
puts(".");
@ -626,14 +622,14 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
iterateAndNextConstNull(nodep->pinsp());
puts(")");
}
virtual void visit(AstArg* nodep) override { iterateAndNextConstNull(nodep->exprp()); }
virtual void visit(AstPrintTimeScale* nodep) override {
void visit(AstArg* nodep) override { iterateAndNextConstNull(nodep->exprp()); }
void visit(AstPrintTimeScale* nodep) override {
puts(nodep->verilogKwd());
puts(";\n");
}
// Terminals
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->varScopep()) {
putfs(nodep, nodep->varScopep()->prettyName());
} else {
@ -649,7 +645,7 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
}
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
putfs(nodep, nodep->dotted());
puts(".");
if (nodep->varp()) {
@ -658,12 +654,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
puts(nodep->prettyName());
}
}
virtual void visit(AstConst* nodep) override { putfs(nodep, nodep->num().ascii(true, true)); }
void visit(AstConst* nodep) override { putfs(nodep, nodep->num().ascii(true, true)); }
// Just iterate
virtual void visit(AstTopScope* nodep) override { iterateChildrenConst(nodep); }
virtual void visit(AstScope* nodep) override { iterateChildrenConst(nodep); }
virtual void visit(AstVar* nodep) override {
void visit(AstTopScope* nodep) override { iterateChildrenConst(nodep); }
void visit(AstScope* nodep) override { iterateChildrenConst(nodep); }
void visit(AstVar* nodep) override {
if (nodep->isIO()) {
putfs(nodep, nodep->verilogKwd());
puts(" ");
@ -691,21 +687,21 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
}
puts(m_suppressVarSemi ? "\n" : ";\n");
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
m_sensesp = nodep->sensesp();
iterateAndNextConstNull(nodep->stmtsp());
m_sensesp = nullptr;
}
virtual void visit(AstParseRef* nodep) override { puts(nodep->prettyName()); }
virtual void visit(AstVarScope*) override {}
virtual void visit(AstNodeText*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstTraceInc*) override {}
void visit(AstParseRef* nodep) override { puts(nodep->prettyName()); }
void visit(AstVarScope*) override {}
void visit(AstNodeText*) override {}
void visit(AstTraceDecl*) override {}
void visit(AstTraceInc*) override {}
// NOPs
virtual void visit(AstPragma*) override {}
virtual void visit(AstCell*) override {} // Handled outside the Visit class
void visit(AstPragma*) override {}
void visit(AstCell*) override {} // Handled outside the Visit class
// Default
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
puts(std::string{"\n???? // "} + nodep->prettyTypeName() + "\n");
iterateChildrenConst(nodep);
// Not v3fatalSrc so we keep processing
@ -720,7 +716,7 @@ public:
explicit EmitVBaseVisitor(bool suppressUnknown, AstSenTree* domainp)
: m_suppressUnknown{suppressUnknown}
, m_sensesp{domainp} {}
virtual ~EmitVBaseVisitor() override = default;
~EmitVBaseVisitor() override = default;
};
//######################################################################
@ -731,11 +727,11 @@ class EmitVFileVisitor final : public EmitVBaseVisitor {
V3OutFile* m_ofp;
// METHODS
V3OutFile* ofp() const { return m_ofp; }
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); }
void puts(const string& str) override { ofp()->puts(str); }
void putbs(const string& str) override { ofp()->putbs(str); }
void putfs(AstNode*, const string& str) override { putbs(str); }
void putqs(AstNode*, const string& str) override { putbs(str); }
void putsNoTracking(const string& str) override { ofp()->putsNoTracking(str); }
public:
EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp, bool trackText, bool suppressUnknown)
@ -744,7 +740,7 @@ public:
m_trackText = trackText;
iterate(nodep);
}
virtual ~EmitVFileVisitor() override = default;
~EmitVFileVisitor() override = default;
};
//######################################################################
@ -754,11 +750,11 @@ class EmitVStreamVisitor final : public EmitVBaseVisitor {
// MEMBERS
std::ostream& m_os;
// METHODS
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); }
void putsNoTracking(const string& str) override { m_os << str; }
void puts(const string& str) override { putsNoTracking(str); }
void putbs(const string& str) override { puts(str); }
void putfs(AstNode*, const string& str) override { putbs(str); }
void putqs(AstNode*, const string& str) override { putbs(str); }
public:
EmitVStreamVisitor(const AstNode* nodep, std::ostream& os)
@ -766,7 +762,7 @@ public:
, m_os(os) { // Need () or GCC 4.8 false warning
iterate(const_cast<AstNode*>(nodep));
}
virtual ~EmitVStreamVisitor() override = default;
~EmitVStreamVisitor() override = default;
};
//######################################################################
@ -779,7 +775,7 @@ class EmitVPrefixedFormatter final : public V3OutFormatter {
int m_column = 0; // Rough location; need just zero or non-zero
FileLine* m_prefixFl;
// METHODS
virtual void putcOutput(char chr) override {
void putcOutput(char chr) override {
if (chr == '\n') {
m_column = 0;
m_os << chr;
@ -796,7 +792,7 @@ class EmitVPrefixedFormatter final : public V3OutFormatter {
}
}
virtual void putsOutput(const char* strg) override {
void putsOutput(const char* strg) override {
for (const char* cp = strg; *cp; cp++) putcOutput(*cp);
}
@ -812,7 +808,7 @@ public:
m_prefixFl = v3Global.rootp()->fileline(); // NETLIST's fileline instead of nullptr to
// avoid nullptr checks
}
virtual ~EmitVPrefixedFormatter() override {
~EmitVPrefixedFormatter() override {
if (m_column) puts("\n");
}
};
@ -822,13 +818,13 @@ class EmitVPrefixedVisitor final : public EmitVBaseVisitor {
EmitVPrefixedFormatter m_formatter; // Special verilog formatter (Way down the
// inheritance is another unused V3OutFormatter)
// METHODS
virtual void putsNoTracking(const string& str) override { m_formatter.putsNoTracking(str); }
virtual void puts(const string& str) override { m_formatter.puts(str); }
void putsNoTracking(const string& str) override { m_formatter.putsNoTracking(str); }
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) 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 putbs(const string& str) override { m_formatter.puts(str); }
void putfs(AstNode* nodep, const string& str) override { putfsqs(nodep, str, false); }
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());
@ -846,7 +842,7 @@ public:
if (user3mark) VNUser3InUse::check();
iterate(const_cast<AstNode*>(nodep));
}
virtual ~EmitVPrefixedVisitor() override = default;
~EmitVPrefixedVisitor() override = default;
};
//######################################################################

62
src/V3EmitXml.cpp
View File

@ -101,11 +101,11 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
// VISITORS
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
outputTag(nodep, "contassign"); // IEEE: vpiContAssign
outputChildrenEnd(nodep, "contassign");
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
outputTag(nodep, "instance"); // IEEE: vpiInstance
puts(" defName=");
putsQuoted(nodep->modName()); // IEEE vpiDefName
@ -113,7 +113,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
putsQuoted(nodep->origName());
outputChildrenEnd(nodep, "instance");
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
outputTag(nodep, "if");
puts(">\n");
iterateAndNextNull(nodep->op1p());
@ -127,7 +127,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
puts("</if>\n");
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
outputTag(nodep, "while");
puts(">\n");
puts("<begin>\n");
@ -150,19 +150,19 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
puts("</while>\n");
}
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
puts("<netlist>\n");
iterateChildren(nodep);
puts("</netlist>\n");
}
virtual void visit(AstConstPool* nodep) override {
void visit(AstConstPool* nodep) override {
if (!v3Global.opt.xmlOnly()) {
puts("<constpool>\n");
iterateChildren(nodep);
puts("</constpool>\n");
}
}
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
puts("<initarray>\n");
const auto& mapr = nodep->map();
for (const auto& itr : mapr) {
@ -174,7 +174,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
puts("</initarray>\n");
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
outputTag(nodep, "");
puts(" origName=");
putsQuoted(nodep->origName());
@ -184,7 +184,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
if (nodep->modPublic()) puts(" public=\"true\"");
outputChildrenEnd(nodep, "");
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
const VVarType typ = nodep->varType();
const string kw = nodep->verilogKwd();
const string vt = nodep->dtypep()->name();
@ -222,7 +222,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
if (nodep->attrSFormat()) puts(" sformat=\"true\"");
outputChildrenEnd(nodep, "");
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
// What we call a pin in verilator is a port in the IEEE spec.
outputTag(nodep, "port"); // IEEE: vpiPort
if (nodep->modVarp()->isIO()) {
@ -232,12 +232,12 @@ class EmitXmlFileVisitor final : public VNVisitor {
// Children includes vpiHighConn and vpiLowConn; we don't support port bits (yet?)
outputChildrenEnd(nodep, "port");
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
outputTag(nodep, "");
puts(" edgeType=\"" + cvtToStr(nodep->edgeType().ascii()) + "\""); // IEEE vpiTopModule
outputChildrenEnd(nodep, "");
}
virtual void visit(AstModportVarRef* nodep) override {
void visit(AstModportVarRef* nodep) override {
// Dump direction for Modport references
const string kw = nodep->direction().xmlKwd();
outputTag(nodep, "");
@ -245,13 +245,13 @@ class EmitXmlFileVisitor final : public VNVisitor {
putsQuoted(kw);
outputChildrenEnd(nodep, "");
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
outputTag(nodep, "");
puts(" dotted=");
putsQuoted(nodep->dotted());
outputChildrenEnd(nodep, "");
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
outputTag(nodep, "");
puts(" func=");
putsQuoted(nodep->funcp()->name());
@ -259,7 +259,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
// Data types
virtual void visit(AstBasicDType* nodep) override {
void visit(AstBasicDType* nodep) override {
outputTag(nodep, "basicdtype");
if (nodep->isRanged()) {
puts(" left=\"" + cvtToStr(nodep->left()) + "\"");
@ -268,7 +268,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
if (nodep->isSigned()) { puts(" signed=\"true\""); }
puts("/>\n");
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
string mpn;
outputTag(nodep, "");
if (nodep->isModport()) mpn = nodep->modportName();
@ -276,19 +276,19 @@ class EmitXmlFileVisitor final : public VNVisitor {
putsQuoted(mpn);
outputChildrenEnd(nodep, "");
}
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
outputTag(nodep, "");
puts(" displaytype=");
putsQuoted(nodep->verilogKwd());
outputChildrenEnd(nodep, "");
}
virtual void visit(AstElabDisplay* nodep) override {
void visit(AstElabDisplay* nodep) override {
outputTag(nodep, "");
puts(" displaytype=");
putsQuoted(nodep->verilogKwd());
outputChildrenEnd(nodep, "");
}
virtual void visit(AstExtend* nodep) override {
void visit(AstExtend* nodep) override {
outputTag(nodep, "");
puts(" width=");
putsQuoted(cvtToStr(nodep->width()));
@ -296,7 +296,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
putsQuoted(cvtToStr(nodep->lhsp()->widthMinV()));
outputChildrenEnd(nodep, "");
}
virtual void visit(AstExtendS* nodep) override {
void visit(AstExtendS* nodep) override {
outputTag(nodep, "");
puts(" width=");
putsQuoted(cvtToStr(nodep->width()));
@ -306,7 +306,7 @@ class EmitXmlFileVisitor final : public VNVisitor {
}
// Default
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
outputTag(nodep, "");
outputChildrenEnd(nodep, "");
}
@ -316,7 +316,7 @@ public:
: m_ofp{ofp} {
iterate(nodep);
}
virtual ~EmitXmlFileVisitor() override = default;
~EmitXmlFileVisitor() override = default;
};
//######################################################################
@ -333,11 +333,11 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Children are iterated backwards to ensure correct compilation order
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Only list modules and interfaces
// Assumes modules and interfaces list is already sorted level wise
if (!nodep->dead() && (VN_IS(nodep, Module) || VN_IS(nodep, Iface))
@ -346,7 +346,7 @@ private:
}
}
//-----
virtual void visit(AstNode*) override {
void visit(AstNode*) override {
// All modules are present at root so no need to iterate on children
}
@ -364,7 +364,7 @@ public:
}
m_os << "</module_files>\n";
}
virtual ~ModuleFilesXmlVisitor() override = default;
~ModuleFilesXmlVisitor() override = default;
};
//######################################################################
@ -381,9 +381,9 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstConstPool*) override {}
void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (nodep->level() >= 0
&& nodep->level() <= 2) { // ==2 because we don't add wrapper when in XML mode
m_os << "<cells>\n";
@ -402,7 +402,7 @@ private:
m_os << "</cells>\n";
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
if (nodep->modp()->dead()) return;
if (!m_hasChildren) m_os << ">\n";
m_os << "<cell " << nodep->fileline()->xmlDetailedLocation() << " name=\"" << nodep->name()
@ -422,7 +422,7 @@ private:
m_hasChildren = true;
}
//-----
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -431,7 +431,7 @@ public:
// Operate on whole netlist
nodep->accept(*this);
}
virtual ~HierCellsXmlVisitor() override = default;
~HierCellsXmlVisitor() override = default;
};
//######################################################################

28
src/V3Expand.cpp
View File

@ -313,7 +313,7 @@ private:
}
// VISITORS
virtual void visit(AstExtend* nodep) override {
void visit(AstExtend* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -339,7 +339,7 @@ private:
}
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
// Remember, Sel's may have non-integer rhs, so need to optimize for that!
@ -628,7 +628,7 @@ private:
}
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -665,7 +665,7 @@ private:
return true;
}
virtual void visit(AstReplicate* nodep) override {
void visit(AstReplicate* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isWide()) {
@ -750,10 +750,10 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstEq* nodep) override { visitEqNeq(nodep); }
virtual void visit(AstNeq* nodep) override { visitEqNeq(nodep); }
void visit(AstEq* nodep) override { visitEqNeq(nodep); }
void visit(AstNeq* nodep) override { visitEqNeq(nodep); }
virtual void visit(AstRedOr* nodep) override {
void visit(AstRedOr* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
FileLine* const fl = nodep->fileline();
@ -775,7 +775,7 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstRedAnd* nodep) override {
void visit(AstRedAnd* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
FileLine* const fl = nodep->fileline();
@ -805,7 +805,7 @@ private:
VL_DO_DANGLING(replaceWithDelete(nodep, newp), nodep);
}
}
virtual void visit(AstRedXor* nodep) override {
void visit(AstRedXor* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->lhsp()->isWide()) {
@ -825,7 +825,7 @@ private:
// which the inlined function does nicely.
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
if (!nodep->isStatement()) {
iterateChildren(nodep);
@ -835,7 +835,7 @@ private:
iterateChildren(nodep);
m_stmtp = nullptr;
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
m_stmtp = nodep;
iterateChildren(nodep);
@ -876,13 +876,13 @@ private:
}
//--------------------
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't hit varrefs under vars
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ExpandVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ExpandVisitor() override {
~ExpandVisitor() override {
V3Stats::addStat("Optimizations, expand wides", m_statWides);
V3Stats::addStat("Optimizations, expand wide words", m_statWideWords);
V3Stats::addStat("Optimizations, expand limited", m_statWideLimited);

20
src/V3File.h
View File

@ -206,7 +206,7 @@ public:
V3OutFile(V3OutFile&&) = delete;
V3OutFile& operator=(V3OutFile&&) = delete;
virtual ~V3OutFile() override;
~V3OutFile() override;
void putsForceIncs();
private:
@ -216,11 +216,11 @@ private:
}
// CALLBACKS
virtual void putcOutput(char chr) override {
void putcOutput(char chr) override {
m_bufferp->at(m_usedBytes++) = chr;
if (VL_UNLIKELY(m_usedBytes >= WRITE_BUFFER_SIZE_BYTES)) writeBlock();
}
virtual void putsOutput(const char* str) override {
void putsOutput(const char* str) override {
std::size_t len = strlen(str);
std::size_t availableBytes = WRITE_BUFFER_SIZE_BYTES - m_usedBytes;
while (VL_UNLIKELY(len >= availableBytes)) {
@ -246,7 +246,7 @@ public:
: V3OutFile{filename, V3OutFormatter::LA_C} {
resetPrivate();
}
virtual ~V3OutCFile() override = default;
~V3OutCFile() override = default;
virtual void putsHeader() { puts("// Verilated -*- C++ -*-\n"); }
virtual void putsIntTopInclude() { putsForceIncs(); }
virtual void putsGuard();
@ -270,9 +270,9 @@ class V3OutScFile final : public V3OutCFile {
public:
explicit V3OutScFile(const string& filename)
: V3OutCFile{filename} {}
virtual ~V3OutScFile() override = default;
virtual void putsHeader() override { puts("// Verilated -*- SystemC -*-\n"); }
virtual void putsIntTopInclude() override {
~V3OutScFile() override = default;
void putsHeader() override { puts("// Verilated -*- SystemC -*-\n"); }
void putsIntTopInclude() override {
putsForceIncs();
puts("#include \"systemc.h\"\n");
puts("#include \"verilated_sc.h\"\n");
@ -283,7 +283,7 @@ class V3OutVFile final : public V3OutFile {
public:
explicit V3OutVFile(const string& filename)
: V3OutFile{filename, V3OutFormatter::LA_VERILOG} {}
virtual ~V3OutVFile() override = default;
~V3OutVFile() override = default;
virtual void putsHeader() { puts("// Verilated -*- Verilog -*-\n"); }
};
@ -293,7 +293,7 @@ public:
: V3OutFile{filename, V3OutFormatter::LA_XML} {
blockIndent(2);
}
virtual ~V3OutXmlFile() override = default;
~V3OutXmlFile() override = default;
virtual void putsHeader() { puts("<?xml version=\"1.0\" ?>\n"); }
};
@ -301,7 +301,7 @@ class V3OutMkFile final : public V3OutFile {
public:
explicit V3OutMkFile(const string& filename)
: V3OutFile{filename, V3OutFormatter::LA_MK} {}
virtual ~V3OutMkFile() override = default;
~V3OutMkFile() override = default;
virtual void putsHeader() { puts("# Verilated -*- Makefile -*-\n"); }
// No automatic indentation yet.
void puts(const char* strg) { putsNoTracking(strg); }

102
src/V3Gate.cpp
View File

@ -79,9 +79,9 @@ public:
GateEitherVertex(V3Graph* graphp, AstScope* scopep)
: V3GraphVertex{graphp}
, m_scopep{scopep} {}
virtual ~GateEitherVertex() override = default;
~GateEitherVertex() override = default;
// ACCESSORS
virtual string dotStyle() const override { return m_consumed ? "" : "dotted"; }
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; }
@ -137,11 +137,11 @@ public:
GateVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: GateEitherVertex{graphp, scopep}
, m_varScp{varScp} {}
virtual ~GateVarVertex() override = default;
~GateVarVertex() override = default;
// ACCESSORS
AstVarScope* varScp() const { return m_varScp; }
virtual string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
virtual string dotColor() const override { return "blue"; }
string name() const override { return (cvtToHex(m_varScp) + " " + varScp()->name()); }
string dotColor() const override { return "blue"; }
bool isTop() const { return m_isTop; }
void setIsTop() { m_isTop = true; }
bool isClock() const { return m_isClock; }
@ -162,7 +162,7 @@ public:
setIsClock();
}
}
virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
return v.visit(this, vu);
}
};
@ -178,17 +178,15 @@ public:
, m_nodep{nodep}
, m_activep{activep}
, m_slow{slow} {}
virtual ~GateLogicVertex() override = default;
~GateLogicVertex() override = default;
// ACCESSORS
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(); }
string name() const override { return (cvtToHex(m_nodep) + "@" + scopep()->prettyName()); }
string dotColor() const override { return "purple"; }
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; }
virtual VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
VNUser accept(GateGraphBaseVisitor& v, VNUser vu = VNUser{0}) override {
return v.visit(this, vu);
}
};
@ -217,7 +215,7 @@ private:
}
}
// VISITORS
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
++m_ops;
iterateChildren(nodep);
// We only allow a LHS ref for the var being set, and a RHS ref for
@ -243,7 +241,7 @@ private:
m_rhsVarRefs.push_back(nodep);
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
m_substTreep = nodep->rhsp();
if (!VN_IS(nodep->lhsp(), NodeVarRef)) {
clearSimple("ASSIGN(non-VARREF)");
@ -264,7 +262,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// *** Special iterator
if (!m_isSimple) return; // Fastpath
if (++m_ops > v3Global.opt.gateStmts()) clearSimple("--gate-stmts exceeded");
@ -294,7 +292,7 @@ public:
}
if (debug() >= 9 && !m_isSimple) nodep->dumpTree(cout, " gate!Ok: ");
}
virtual ~GateOkVisitor() override = default;
~GateOkVisitor() override = default;
// PUBLIC METHODS
bool isSimple() const { return m_isSimple; }
AstNode* substTree() const { return m_substTreep; }
@ -413,7 +411,7 @@ private:
void decomposeClkVectors();
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
iterateChildren(nodep);
// if (debug() > 6) m_graph.dump();
if (debug() > 6) m_graph.dumpDotFilePrefixed("gate_pre");
@ -445,7 +443,7 @@ private:
// Rewrite assignments
consumedMove();
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
@ -453,14 +451,14 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
m_logicVertexp = nullptr;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
// Create required blocks and add to module
UINFO(4, " BLOCK " << nodep << endl);
m_activeReducible = !(nodep->hasClocked()); // Seq logic outputs aren't reducible
@ -471,7 +469,7 @@ private:
m_activep = nullptr;
m_activeReducible = true;
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
if (m_scopep) {
UASSERT_OBJ(m_logicVertexp, nodep, "Var ref not under a logic block");
AstVarScope* const varscp = nodep->varScopep();
@ -499,17 +497,17 @@ private:
}
}
}
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
VL_RESTORER(m_inSlow);
{
m_inSlow = true;
iterateNewStmt(nodep, "AlwaysPublic", nullptr);
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
iterateNewStmt(nodep, "User C Function", "User C Function");
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
m_inSenItem = true;
if (m_logicVertexp) { // Already under logic; presumably a SenGate
iterateChildren(nodep);
@ -518,7 +516,7 @@ private:
}
m_inSenItem = false;
}
virtual void visit(AstNodeProcedure* nodep) override {
void visit(AstNodeProcedure* nodep) override {
VL_RESTORER(m_inSlow);
{
m_inSlow = VN_IS(nodep, Initial) || VN_IS(nodep, Final);
@ -526,23 +524,23 @@ private:
nullptr);
}
}
virtual void visit(AstAssignAlias* nodep) override { //
void visit(AstAssignAlias* nodep) override { //
iterateNewStmt(nodep, nullptr, nullptr);
}
virtual void visit(AstAssignW* nodep) override { //
void visit(AstAssignW* nodep) override { //
iterateNewStmt(nodep, nullptr, nullptr);
}
virtual void visit(AstCoverToggle* nodep) override {
void visit(AstCoverToggle* nodep) override {
iterateNewStmt(nodep, "CoverToggle", "CoverToggle");
}
virtual void visit(AstTraceDecl* nodep) override {
void visit(AstTraceDecl* nodep) override {
VL_RESTORER(m_inSlow);
{
m_inSlow = true;
iterateNewStmt(nodep, "Tracing", "Tracing");
}
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
UASSERT_OBJ(!(VN_IS(nodep->backp(), NodeAssign)
&& VN_AS(nodep->backp(), NodeAssign)->lhsp() == nodep),
nodep, "Concat on LHS of assignment; V3Const should have deleted it");
@ -550,7 +548,7 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
if (nodep->isOutputter() && m_logicVertexp) m_logicVertexp->setConsumed("outputter");
}
@ -558,7 +556,7 @@ private:
public:
// CONSTRUCTORS
explicit GateVisitor(AstNode* nodep) { iterate(nodep); }
virtual ~GateVisitor() override {
~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);
@ -810,7 +808,7 @@ private:
public:
GateDedupeHash() = default;
virtual ~GateDedupeHash() override {
~GateDedupeHash() override {
if (v3Global.opt.debugCheck()) check();
}
@ -836,7 +834,7 @@ public:
}
// Callback from V3DupFinder::findDuplicate
virtual bool isSame(AstNode* node1p, AstNode* node2p) override {
bool isSame(AstNode* node1p, AstNode* node2p) override {
// Assignment may have been hashReplaced, if so consider non-match (effectively removed)
if (isReplaced(node1p) || isReplaced(node2p)) {
// UINFO(9, "isSame hit on replaced "<<(void*)node1p<<" "<<(void*)node2p<<endl);
@ -908,7 +906,7 @@ private:
bool m_dedupable = true; // Determined the assign to be dedupable
// VISITORS
virtual void visit(AstNodeAssign* assignp) override {
void visit(AstNodeAssign* assignp) override {
if (m_dedupable) {
// I think we could safely dedupe an always block with multiple
// non-blocking statements, but erring on side of caution here
@ -919,7 +917,7 @@ private:
}
}
}
virtual void visit(AstAlways* alwaysp) override {
void visit(AstAlways* alwaysp) override {
if (m_dedupable) {
if (!m_always) {
m_always = true;
@ -933,7 +931,7 @@ private:
// always @(...)
// if (...)
// foo = ...; // or foo <= ...;
virtual void visit(AstNodeIf* ifp) override {
void visit(AstNodeIf* ifp) override {
if (m_dedupable) {
if (m_always && !m_ifCondp && !ifp->elsesp()) {
// we're under an always, this is the first IF, and there's no else
@ -945,16 +943,16 @@ private:
}
}
virtual void visit(AstComment*) override {} // NOP
void visit(AstComment*) override {} // NOP
//--------------------
virtual void visit(AstNode*) override { //
void visit(AstNode*) override { //
m_dedupable = false;
}
public:
// CONSTRUCTORS
GateDedupeVarVisitor() = default;
virtual ~GateDedupeVarVisitor() override = default;
~GateDedupeVarVisitor() override = default;
// PUBLIC METHODS
AstNodeVarRef* findDupe(AstNode* nodep, AstVarScope* consumerVarScopep, AstActive* activep) {
m_assignp = nullptr;
@ -1043,7 +1041,7 @@ private:
GateDedupeVarVisitor m_varVisitor; // Looks for a dupe of the logic
int m_depth = 0; // Iteration depth
virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override {
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
@ -1105,7 +1103,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) override {
VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
lvertexp->iterateInEdges(*this);
const GateVarVertex* const consumerVvertexpp
@ -1185,7 +1183,7 @@ private:
}
}
virtual VNUser visit(GateVarVertex* vvertexp, VNUser) override {
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
@ -1259,7 +1257,7 @@ private:
}
return VNUser{0};
}
virtual VNUser visit(GateLogicVertex*, VNUser) override { //
VNUser visit(GateLogicVertex*, VNUser) override { //
return VNUser{0};
}
@ -1297,7 +1295,7 @@ private:
bool m_found = false; // Offset found
// VISITORS
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
UINFO(9, "CLK DECOMP Concat search var (off = " << m_offset << ") - " << nodep << endl);
if (nodep->varScopep() == m_vscp && !nodep->user2() && !m_found) {
// A concatenation may use the same var multiple times
@ -1309,18 +1307,18 @@ private:
}
m_offset += nodep->dtypep()->width();
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
UINFO(9, "CLK DECOMP Concat search (off = " << m_offset << ") - " << nodep << endl);
iterate(nodep->rhsp());
iterate(nodep->lhsp());
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
GateConcatVisitor() = default;
virtual ~GateConcatVisitor() override = default;
~GateConcatVisitor() override = default;
// PUBLIC METHODS
bool concatOffset(AstConcat* concatp, AstVarScope* vscp, int& offsetr) {
m_vscp = vscp;
@ -1360,7 +1358,7 @@ private:
int m_total_seen_clk_vectors = 0;
int m_total_decomposed_clk_vectors = 0;
virtual VNUser visit(GateVarVertex* vvertexp, VNUser vu) override {
VNUser visit(GateVarVertex* vvertexp, VNUser vu) override {
// Check that we haven't been here before
AstVarScope* const vsp = vvertexp->varScp();
if (vsp->user2SetOnce()) return VNUser{0};
@ -1377,7 +1375,7 @@ private:
return VNUser{0}; // Unused
}
virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
VNUser visit(GateLogicVertex* lvertexp, VNUser vu) override {
const GateClkDecompState* const currState = reinterpret_cast<GateClkDecompState*>(vu.c());
int clk_offset = currState->m_offset;
if (const AstAssignW* const assignp = VN_CAST(lvertexp->nodep(), AssignW)) {
@ -1444,7 +1442,7 @@ private:
public:
explicit GateClkDecompGraphVisitor(V3Graph* graphp)
: GateGraphBaseVisitor{graphp} {}
virtual ~GateClkDecompGraphVisitor() override {
~GateClkDecompGraphVisitor() override {
V3Stats::addStat("Optimizations, Clocker seen vectors", m_total_seen_clk_vectors);
V3Stats::addStat("Optimizations, Clocker decomposed vectors",
m_total_decomposed_clk_vectors);

28
src/V3GenClk.cpp
View File

@ -90,7 +90,7 @@ private:
}
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
if (m_activep && !nodep->user3SetOnce()) {
AstVarScope* const vscp = nodep->varScopep();
@ -105,14 +105,14 @@ private:
}
}
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
m_activep = nodep;
iterate(nodep->sensesp());
m_activep = nullptr;
}
//-----
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -120,7 +120,7 @@ public:
: m_topModp{topModp} {
iterate(nodep);
}
virtual ~GenClkRenameVisitor() override = default;
~GenClkRenameVisitor() override = default;
};
//######################################################################
@ -139,7 +139,7 @@ private:
AstNodeModule* m_topModp = nullptr; // Top module
// VISITORS
virtual void visit(AstTopScope* nodep) override {
void visit(AstTopScope* nodep) override {
{
const VNUser1InUse user1InUse;
iterateChildren(nodep);
@ -148,14 +148,14 @@ private:
// See rename, it does some AstNode::userClearTree()'s
GenClkRenameVisitor{nodep, m_topModp};
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) {
m_topModp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -163,7 +163,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) {
// Only consider logic within a CFunc when looking
// at the call to it, and not when scanning whatever
@ -175,7 +175,7 @@ private:
}
//----
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
AstVarScope* const vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@ -190,13 +190,13 @@ private:
vscp->circular(true);
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// UINFO(8, "ASS " << nodep << endl);
m_assignp = nodep;
iterateChildren(nodep);
m_assignp = nullptr;
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
UINFO(8, "ACTIVE " << nodep << endl);
m_activep = nodep;
UASSERT_OBJ(nodep->sensesp(), nodep, "Unlinked");
@ -206,13 +206,13 @@ private:
}
//-----
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't want varrefs under it
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit GenClkReadVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~GenClkReadVisitor() override = default;
~GenClkReadVisitor() override = default;
};
//######################################################################

14
src/V3GraphAcyc.cpp
View File

@ -42,13 +42,13 @@ public:
GraphAcycVertex(V3Graph* graphp, V3GraphVertex* origVertexp)
: V3GraphVertex{graphp}
, m_origVertexp{origVertexp} {}
virtual ~GraphAcycVertex() override = default;
~GraphAcycVertex() override = default;
V3GraphVertex* origVertexp() const { return m_origVertexp; }
void setDelete() { m_deleted = true; }
bool isDelete() const { return m_deleted; }
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(); }
string name() const override { return m_origVertexp->name(); }
string dotColor() const override { return m_origVertexp->dotColor(); }
FileLine* fileline() const override { return m_origVertexp->fileline(); }
};
//--------------------------------------------------------------------
@ -67,11 +67,9 @@ public:
GraphAcycEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
bool cutable = false)
: V3GraphEdge{graphp, fromp, top, weight, cutable} {}
virtual ~GraphAcycEdge() override = default;
~GraphAcycEdge() override = default;
// yellow=we might still cut it, else oldEdge: yellowGreen=made uncutable, red=uncutable
virtual string dotColor() const override {
return (cutable() ? "yellow" : origEdgep()->dotColor());
}
string dotColor() const override { return (cutable() ? "yellow" : origEdgep()->dotColor()); }
};
//--------------------------------------------------------------------

24
src/V3GraphTest.cpp
View File

@ -56,18 +56,18 @@ public:
V3GraphTestVertex(V3Graph* graphp, const string& name)
: V3GraphVertex{graphp}
, m_name{name} {}
virtual ~V3GraphTestVertex() override = default;
~V3GraphTestVertex() override = default;
// ACCESSORS
virtual string name() const override { return m_name; }
string name() const override { return m_name; }
};
class V3GraphTestVarVertex final : public V3GraphTestVertex {
public:
V3GraphTestVarVertex(V3Graph* graphp, const string& name)
: V3GraphTestVertex{graphp, name} {}
virtual ~V3GraphTestVarVertex() override = default;
~V3GraphTestVarVertex() override = default;
// ACCESSORS
virtual string dotColor() const override { return "blue"; }
string dotColor() const override { return "blue"; }
};
//######################################################################
@ -76,8 +76,8 @@ public:
class V3GraphTestStrong final : public V3GraphTest {
public:
virtual string name() override { return "strong"; }
virtual void runTest() override {
string name() override { return "strong"; }
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
@ -114,8 +114,8 @@ public:
class V3GraphTestAcyc final : public V3GraphTest {
public:
virtual string name() override { return "acyc"; }
virtual void runTest() override {
string name() override { return "acyc"; }
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
@ -142,8 +142,8 @@ public:
class V3GraphTestVars final : public V3GraphTest {
public:
virtual string name() override { return "vars"; }
virtual void runTest() override {
string name() override { return "vars"; }
void runTest() override {
V3Graph* gp = &m_graph;
V3GraphTestVertex* clk = new V3GraphTestVarVertex(gp, "$clk");
@ -268,8 +268,8 @@ class V3GraphTestImport final : public V3GraphTest {
#endif
public:
virtual string name() override { return "import"; }
virtual void runTest() override {
string name() override { return "import"; }
void runTest() override {
V3Graph* const gp = &m_graph;
dotImport();
dump();

152
src/V3Hasher.cpp
View File

@ -80,7 +80,7 @@ private:
//------------------------------------------------------------
// AstNode - Warns to help find missing cases
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
#if VL_DEBUG
UINFO(0, "%Warning: Hashing node as AstNode: " << nodep << endl);
#endif
@ -89,93 +89,93 @@ private:
//------------------------------------------------------------
// AstNodeDType
virtual void visit(AstNodeArrayDType* nodep) override {
void visit(AstNodeArrayDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
iterateNull(nodep->virtRefDTypep());
m_hash += nodep->left();
m_hash += nodep->right();
});
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, false, [=]() { //
m_hash += nodep->uniqueNum();
});
}
virtual void visit(AstParamTypeDType* nodep) override {
void visit(AstParamTypeDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
m_hash += nodep->varType();
});
}
virtual void visit(AstMemberDType* nodep) override {
void visit(AstMemberDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstDefImplicitDType* nodep) override {
void visit(AstDefImplicitDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->uniqueNum();
});
}
virtual void visit(AstAssocArrayDType* nodep) override {
void visit(AstAssocArrayDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
iterateNull(nodep->virtRefDTypep());
iterateNull(nodep->virtRefDType2p());
});
}
virtual void visit(AstDynArrayDType* nodep) override {
void visit(AstDynArrayDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->virtRefDTypep());
});
}
virtual void visit(AstUnsizedArrayDType* nodep) override {
void visit(AstUnsizedArrayDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->virtRefDTypep());
});
}
virtual void visit(AstWildcardArrayDType* nodep) override {
void visit(AstWildcardArrayDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->virtRefDTypep());
});
}
virtual void visit(AstBasicDType* nodep) override {
void visit(AstBasicDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
m_hash += nodep->keyword();
m_hash += nodep->nrange().left();
m_hash += nodep->nrange().right();
});
}
virtual void visit(AstConstDType* nodep) override {
void visit(AstConstDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
iterateNull(nodep->virtRefDTypep());
});
}
virtual void visit(AstClassRefDType* nodep) override {
void visit(AstClassRefDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->classp());
});
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->cellp());
});
}
virtual void visit(AstQueueDType* nodep) override {
void visit(AstQueueDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->virtRefDTypep());
});
}
virtual void visit(AstRefDType* nodep) override {
void visit(AstRefDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
iterateNull(nodep->typedefp());
iterateNull(nodep->refDTypep());
});
}
virtual void visit(AstVoidDType* nodep) override {
void visit(AstVoidDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstEnumDType* nodep) override {
void visit(AstEnumDType* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, false, [=]() { //
m_hash += nodep->uniqueNum();
});
@ -183,23 +183,23 @@ private:
//------------------------------------------------------------
// AstNodeMath
virtual void visit(AstNodeMath* nodep) override {
void visit(AstNodeMath* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->num().toHash();
});
}
virtual void visit(AstNullCheck* nodep) override {
void visit(AstNullCheck* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstCCast* nodep) override {
void visit(AstCCast* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->size();
});
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
if (nodep->varScopep()) {
iterateNull(nodep->varScopep());
@ -209,28 +209,28 @@ private:
}
});
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
iterateNull(nodep->varp());
m_hash += nodep->dotted();
});
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstFScanF* nodep) override {
void visit(AstFScanF* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->text();
});
}
virtual void visit(AstSScanF* nodep) override {
void visit(AstSScanF* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->text();
});
}
virtual void visit(AstAddrOfCFunc* nodep) override {
void visit(AstAddrOfCFunc* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
iterateNull(nodep->funcp());
});
@ -238,56 +238,56 @@ private:
//------------------------------------------------------------
// AstNodeStmt
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstNodeText* nodep) override {
void visit(AstNodeText* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->text();
});
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->funcp());
});
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() {
iterateNull(nodep->taskp());
iterateNull(nodep->classOrPackagep());
});
}
virtual void visit(AstCMethodHard* nodep) override {
void visit(AstCMethodHard* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstCoverInc* nodep) override {
void visit(AstCoverInc* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->declp());
});
}
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->displayType();
});
}
virtual void visit(AstMonitorOff* nodep) override {
void visit(AstMonitorOff* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->off();
});
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->labelp());
});
}
virtual void visit(AstTraceInc* nodep) override {
void visit(AstTraceInc* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
iterateNull(nodep->declp());
});
}
virtual void visit(AstNodeCoverOrAssert* nodep) override {
void visit(AstNodeCoverOrAssert* nodep) override {
m_hash += hashNodeAndIterate(nodep, false, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
@ -295,62 +295,62 @@ private:
//------------------------------------------------------------
// AstNode direct descendents
virtual void visit(AstNodeRange* nodep) override {
void visit(AstNodeRange* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, false, [=]() { //
m_hash += nodep->origName();
});
}
virtual void visit(AstNodePreSel* nodep) override {
void visit(AstNodePreSel* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstClassExtends* nodep) override {
void visit(AstClassExtends* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstSelLoopVars* nodep) override {
void visit(AstSelLoopVars* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstDefParam* nodep) override {
void visit(AstDefParam* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstArg* nodep) override {
void visit(AstArg* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstParseRef* nodep) override {
void visit(AstParseRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->expect();
m_hash += nodep->name();
});
}
virtual void visit(AstClassOrPackageRef* nodep) override {
void visit(AstClassOrPackageRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
iterateNull(nodep->classOrPackageNodep());
});
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->edgeType();
});
}
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->text();
});
}
virtual void visit(AstElabDisplay* nodep) override {
void visit(AstElabDisplay* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->displayType();
});
}
virtual void visit(AstInitItem* nodep) override {
void visit(AstInitItem* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
if (const AstAssocArrayDType* const dtypep = VN_CAST(nodep->dtypep(), AssocArrayDType)) {
if (nodep->defaultp()) {
m_hash
@ -376,22 +376,22 @@ private:
});
}
}
virtual void visit(AstPragma* nodep) override {
void visit(AstPragma* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->pragType();
});
}
virtual void visit(AstAttrOf* nodep) override {
void visit(AstAttrOf* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->attrType();
});
}
virtual void visit(AstNodeFile* nodep) override {
void visit(AstNodeFile* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
// We might be in a recursive function, if so on *second* call
// here we need to break what would be an infinite loop.
@ -402,90 +402,90 @@ private:
m_hash += nodep->isLoose();
});
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
m_hash += nodep->varType();
});
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, false, [=]() {
m_hash += nodep->name();
iterateNull(nodep->aboveScopep());
});
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
iterateNull(nodep->varp());
iterateNull(nodep->scopep());
});
}
virtual void visit(AstEnumItem* nodep) override {
void visit(AstEnumItem* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstTypedefFwd* nodep) override {
void visit(AstTypedefFwd* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
iterateNull(nodep->sensesp());
});
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
iterateNull(nodep->modp());
});
}
virtual void visit(AstCellInline* nodep) override {
void visit(AstCellInline* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
iterateNull(nodep->scopep());
});
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstModport* nodep) override {
void visit(AstModport* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstModportVarRef* nodep) override {
void visit(AstModportVarRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
iterateNull(nodep->varp());
});
}
virtual void visit(AstModportFTaskRef* nodep) override {
void visit(AstModportFTaskRef* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
iterateNull(nodep->ftaskp());
});
}
virtual void visit(AstMTaskBody* nodep) override {
void visit(AstMTaskBody* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstNodeProcedure* nodep) override {
void visit(AstNodeProcedure* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
}
virtual void visit(AstNodeBlock* nodep) override {
void visit(AstNodeBlock* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->name();
});
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {
m_hash += nodep->name();
m_hash += nodep->pinNum();
@ -504,7 +504,7 @@ public:
iterate(const_cast<AstNode*>(nodep));
}
V3Hash finalHash() const { return m_hash; }
virtual ~HasherVisitor() override = default;
~HasherVisitor() override = default;
};
//######################################################################

10
src/V3HierBlock.cpp
View File

@ -250,7 +250,7 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
ModuleSet m_referred; // Modules that have hier_block pragma
V3HierBlock::GParams m_gparams; // list of variables that is VVarType::GPARAM
virtual void visit(AstModule* nodep) override {
void visit(AstModule* nodep) override {
// Don't visit twice
if (nodep->user1SetOnce()) return;
UINFO(5, "Checking " << nodep->prettyNameQ() << " from "
@ -277,7 +277,7 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
}
m_gparams = prevGParams;
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
// Visit used module here to know that the module is hier_block or not.
// This visitor behaves almost depth first search
if (AstModule* const modp = VN_CAST(nodep->modp(), Module)) {
@ -287,15 +287,15 @@ class HierBlockUsageCollectVisitor final : public VNVisitor {
// Nothing to do for interface because hierarchical block does not exist
// beyond interface.
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (m_modp && m_modp->hierBlock() && nodep->isIfaceRef() && !nodep->isIfaceParent()) {
nodep->v3error("Modport cannot be used at the hierarchical block boundary");
}
if (nodep->isGParam() && nodep->overriddenParam()) m_gparams.push_back(nodep);
}
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
HierBlockUsageCollectVisitor(V3HierBlockPlan* planp, AstNetlist* netlist)

84
src/V3Inline.cpp
View File

@ -112,7 +112,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UASSERT_OBJ(!m_modp, nodep, "Unsupported: Nested modules");
m_modp = nodep;
m_allMods.push_back(nodep);
@ -130,19 +130,19 @@ private:
iterateChildren(nodep);
m_modp = nullptr;
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
// TODO allow inlining of modules that have classes
// (Probably wait for new inliner scheme)
cantInline("class", true);
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
m_moduleState(nodep->modp()).m_cellRefs++;
m_moduleState(m_modp).m_childCells.push_back(nodep);
m_instances[m_modp][nodep->modp()]++;
iterateChildren(nodep);
}
virtual void visit(AstPragma* nodep) override {
void visit(AstPragma* nodep) override {
if (nodep->pragType() == VPragmaType::INLINE_MODULE) {
if (!m_modp) {
nodep->v3error("Inline pragma not under a module"); // LCOV_EXCL_LINE
@ -162,28 +162,28 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
// Remove link. V3LinkDot will reestablish it after inlining.
nodep->varp(nullptr);
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
// Remove link. V3LinkDot will reestablish it after inlining.
// MethodCalls not currently supported by inliner, so keep linked
if (!nodep->classOrPackagep() && !VN_IS(nodep, MethodCall)) nodep->taskp(nullptr);
iterateChildren(nodep);
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
m_modp->user4Inc(); // statement count
iterateChildren(nodep);
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// Don't count assignments, as they'll likely flatten out
// Still need to iterate though to nullify VarXRefs
const int oldcnt = m_modp->user4();
iterateChildren(nodep);
m_modp->user4(oldcnt);
}
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Build ModuleState, user2, and user4 for all modules.
// Also build m_allMods and m_instances.
iterateChildren(nodep);
@ -226,7 +226,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (m_modp) m_modp->user4Inc(); // Inc statement count
iterateChildren(nodep);
}
@ -237,7 +237,7 @@ public:
: m_moduleState{moduleState} {
iterate(nodep);
}
virtual ~InlineMarkVisitor() override {
~InlineMarkVisitor() override {
V3Stats::addStat("Optimizations, Inline unsupported", m_statUnsup);
}
};
@ -260,7 +260,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstCellInline* nodep) override {
void visit(AstCellInline* nodep) override {
// Inlined cell under the inline cell, need to move to avoid conflicts
nodep->unlinkFrBack();
m_modp->addInlinesp(nodep);
@ -270,20 +270,20 @@ private:
// Do CellInlines under this, but don't move them
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
// Cell under the inline cell, need to rename to avoid conflicts
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstModule* nodep) override {
void visit(AstModule* nodep) override {
m_renamedInterfaces.clear();
iterateChildren(nodep);
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (nodep->user2p()) {
// Make an assignment, so we'll trace it properly
// user2p is either a const or a var.
@ -360,17 +360,17 @@ private:
if (debug() >= 9) nodep->dumpTree(cout, "varchanged:");
if (debug() >= 9 && nodep->valuep()) nodep->valuep()->dumpTree(cout, "varchangei:");
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
// Function under the inline cell, need to rename to avoid conflicts
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
// Typedef under the inline cell, need to rename to avoid conflicts
nodep->name(m_cellp->name() + "__DOT__" + nodep->name());
iterateChildren(nodep);
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->varp()->user2p() // It's being converted to an alias.
&& !nodep->varp()->user3()
// Don't constant propagate aliases (we just made)
@ -388,7 +388,7 @@ private:
}
nodep->name(nodep->varp()->name());
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
// Track what scope it was originally under so V3LinkDot can resolve it
nodep->inlinedDots(VString::dot(m_cellp->name(), ".", nodep->inlinedDots()));
for (string tryname = nodep->dotted(); true;) {
@ -406,7 +406,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
// Track what scope it was originally under so V3LinkDot can resolve it
nodep->inlinedDots(VString::dot(m_cellp->name(), ".", nodep->inlinedDots()));
if (m_renamedInterfaces.count(nodep->dotted())) {
@ -417,9 +417,9 @@ private:
}
// Not needed, as V3LinkDot doesn't care about typedefs
// virtual void visit(AstRefDType* nodep) override {}
// void visit(AstRefDType* nodep) override {}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
// Similar code in V3Begin
// To keep correct visual order, must add before other Text's
@ -435,12 +435,12 @@ private:
if (afterp) nodep->scopeEntrp(afterp);
iterateChildren(nodep);
}
virtual void visit(AstCoverDecl* nodep) override {
void visit(AstCoverDecl* nodep) override {
// Fix path in coverage statements
nodep->hier(VString::dot(m_cellp->prettyName(), ".", nodep->hier()));
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -449,7 +449,7 @@ public:
, m_cellp{cellp} {
iterate(cloneModp);
}
virtual ~InlineRelinkVisitor() override = default;
~InlineRelinkVisitor() override = default;
};
//######################################################################
@ -576,13 +576,13 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order. Required!
iterateAndNextConstNullBackwards(nodep->modulesp());
// Clean up AstIfaceRefDType references
iterateChildren(nodep->typeTablep());
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UASSERT_OBJ(!m_modp, nodep, "Unsupported: Nested modules");
m_modp = nodep;
// Iterate the stored cells directly to reduce traversal
@ -592,7 +592,7 @@ private:
m_moduleState(nodep).m_childCells.clear();
m_modp = nullptr;
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
if (nodep->user5()) {
// The cell has been removed so let's make sure we don't leave a reference to it
// This dtype may still be in use by the AstAssignVarScope created earlier
@ -602,15 +602,15 @@ private:
}
//--------------------
virtual void visit(AstCell* nodep) override { // LCOV_EXCL_START
void visit(AstCell* nodep) override { // LCOV_EXCL_START
nodep->v3fatal("Traversal should have been short circuited");
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
nodep->v3fatal("Traversal should have been short circuited");
} // LCOV_EXCL_STOP
virtual void visit(AstNodeFile*) override {} // Accelerate
virtual void visit(AstNodeDType*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeFile*) override {} // Accelerate
void visit(AstNodeDType*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -618,7 +618,7 @@ public:
: m_moduleState{moduleState} {
iterate(nodep);
}
virtual ~InlineVisitor() override {
~InlineVisitor() override {
V3Stats::addStat("Optimizations, Inlined instances", m_statCells);
}
};
@ -639,8 +639,8 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstNetlist* nodep) override { iterateChildren(nodep->topModulep()); }
virtual void visit(AstCell* nodep) override {
void visit(AstNetlist* nodep) override { iterateChildren(nodep->topModulep()); }
void visit(AstCell* nodep) override {
VL_RESTORER(m_scope);
if (m_scope.empty()) {
m_scope = nodep->name();
@ -673,7 +673,7 @@ private:
iterateChildren(modp);
}
}
virtual void visit(AstAssignVarScope* nodep) override {
void visit(AstAssignVarScope* nodep) override {
// Reference
const AstVarRef* const reflp = VN_CAST(nodep->lhsp(), VarRef);
// What the reference refers to
@ -698,14 +698,14 @@ private:
cellp->addIntfRefp(new AstIntfRef(varlp->fileline(), alias));
}
//--------------------
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNodeStmt*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit InlineIntfRefVisitor(AstNode* nodep) { iterate(nodep); }
virtual ~InlineIntfRefVisitor() override = default;
~InlineIntfRefVisitor() override = default;
};
//######################################################################

36
src/V3Inst.cpp
View File

@ -49,7 +49,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
UINFO(4, " CELL " << nodep << endl);
m_cellp = nodep;
// VV***** We reset user1p() on each cell!!!
@ -57,7 +57,7 @@ private:
iterateChildren(nodep);
m_cellp = nullptr;
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
// PIN(p,expr) -> ASSIGNW(VARXREF(p),expr) (if sub's input)
// or ASSIGNW(expr,VARXREF(p)) (if sub's output)
UINFO(4, " PIN " << nodep << endl);
@ -116,7 +116,7 @@ private:
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstUdpTable* nodep) override {
void visit(AstUdpTable* nodep) override {
if (!v3Global.opt.bboxUnsup()) {
// If we support primitives, update V3Undriven to remove special case
nodep->v3warn(E_UNSUPPORTED, "Unsupported: Verilog 1995 UDP Tables. "
@ -125,17 +125,17 @@ private:
}
// Save some time
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNodeAssign*) override {}
virtual void visit(AstAlways*) override {}
void visit(AstNodeMath*) override {}
void visit(AstNodeAssign*) override {}
void visit(AstAlways*) override {}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit InstVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~InstVisitor() override = default;
~InstVisitor() override = default;
};
//######################################################################
@ -149,15 +149,15 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (VN_IS(nodep->dtypep(), IfaceRefDType)) {
UINFO(8, " dm-1-VAR " << nodep << endl);
insert(nodep);
}
iterateChildren(nodep);
}
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// METHODS
@ -181,7 +181,7 @@ public:
// CONSTRUCTORS
InstDeModVarVisitor() = default;
virtual ~InstDeModVarVisitor() override = default;
~InstDeModVarVisitor() override = default;
void main(AstNodeModule* nodep) {
UINFO(8, " dmMODULE " << nodep << endl);
m_modVarNameMap.clear();
@ -203,7 +203,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (VN_IS(nodep->dtypep(), UnpackArrayDType)
&& VN_IS(VN_AS(nodep->dtypep(), UnpackArrayDType)->subDTypep(), IfaceRefDType)) {
UINFO(8, " dv-vec-VAR " << nodep << endl);
@ -239,7 +239,7 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
UINFO(4, " CELL " << nodep << endl);
// Find submodule vars
UASSERT_OBJ(nodep->modp(), nodep, "Unlinked");
@ -316,7 +316,7 @@ private:
}
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
// Any non-direct pins need reconnection with a part-select
if (!nodep->exprp()) return; // No-connect
if (m_cellRangep) {
@ -478,13 +478,13 @@ private:
}
//--------------------
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit InstDeVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~InstDeVisitor() override = default;
~InstDeVisitor() override = default;
};
//######################################################################

28
src/V3InstrCount.cpp
View File

@ -75,7 +75,7 @@ public:
, m_osp{osp} {
if (nodep) iterate(nodep);
}
virtual ~InstrCountVisitor() override = default;
~InstrCountVisitor() override = default;
// METHODS
uint32_t instrCount() const { return m_instrCount; }
@ -117,7 +117,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeSel* nodep) override {
void visit(AstNodeSel* nodep) override {
// This covers both AstArraySel and AstWordSel
//
// If some vector is a bazillion dwords long, and we're selecting 1
@ -128,7 +128,7 @@ private:
const VisitBase vb{this, nodep};
iterateAndNextNull(nodep->bitp());
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
// Similar to AstNodeSel above, a small select into a large vector
// is not expensive. Count the cost of the AstSel itself (scales with
// its width) and the cost of the lsbp() and widthp() nodes, but not
@ -137,13 +137,13 @@ private:
iterateAndNextNull(nodep->lsbp());
iterateAndNextNull(nodep->widthp());
}
virtual void visit(AstSliceSel* nodep) override { // LCOV_EXCL_LINE
void visit(AstSliceSel* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("AstSliceSel unhandled");
}
virtual void visit(AstMemberSel* nodep) override { // LCOV_EXCL_LINE
void visit(AstMemberSel* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("AstMemberSel unhandled");
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
// Nop.
//
// Ignore concat. The problem with counting concat is that when we
@ -163,7 +163,7 @@ private:
// the widths of the operands (ignored here).
markCost(nodep);
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
const VisitBase vb{this, nodep};
iterateAndNextNull(nodep->condp());
const uint32_t savedCount = m_instrCount;
@ -188,7 +188,7 @@ private:
if (nodep->ifsp()) nodep->ifsp()->user4(0); // Don't dump it
}
}
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
// Just like if/else above, the ternary operator only evaluates
// one of the two expressions, so only count the max.
const VisitBase vb{this, nodep};
@ -213,7 +213,7 @@ private:
if (nodep->expr2p()) nodep->expr2p()->user4(0); // Don't dump it
}
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
// You'd think that the OrderLogicVertex's would be disjoint trees
// of stuff in the AST, but it isn't so: V3Order makes an
// OrderLogicVertex for each ACTIVE, and then also makes an
@ -229,14 +229,14 @@ private:
markCost(nodep);
UASSERT_OBJ(nodep == m_startNodep, nodep, "Multiple actives, or not start node");
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
const VisitBase vb{this, nodep};
iterateChildren(nodep);
m_tracingCall = true;
iterate(nodep->funcp());
UASSERT_OBJ(!m_tracingCall, nodep, "visit(AstCFunc) should have cleared m_tracingCall.");
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// Don't count a CFunc other than by tracing a call or counting it
// from the root
UASSERT_OBJ(m_tracingCall || nodep == m_startNodep, nodep,
@ -249,7 +249,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
const VisitBase vb{this, nodep};
iterateChildren(nodep);
}
@ -276,12 +276,12 @@ public:
UASSERT_OBJ(osp, nodep, "Don't call if not dumping");
if (nodep) iterate(nodep);
}
virtual ~InstrCountDumpVisitor() override = default;
~InstrCountDumpVisitor() override = default;
private:
// METHODS
string indent() const { return string(m_depth, ':') + " "; }
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
++m_depth;
if (unsigned costPlus1 = nodep->user4()) {
*m_osp << " " << indent() << "cost " << std::setw(6) << std::left << (costPlus1 - 1)

40
src/V3Life.cpp
View File

@ -291,7 +291,7 @@ private:
}
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
// it's used so can't elim assignment before this use.
UASSERT_OBJ(nodep->varScopep(), nodep, "nullptr");
@ -305,7 +305,7 @@ private:
VL_DO_DANGLING(m_lifep->varUsageReplace(vscp, nodep), nodep);
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// Collect any used variables first, as lhs may also be on rhs
// Similar code in V3Dead
const uint64_t lastEdit = AstNode::editCountGbl(); // When it was last edited
@ -325,13 +325,13 @@ private:
iterateAndNextNull(nodep->lhsp());
}
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
// Don't treat as normal assign; V3Life doesn't understand time sense
iterateChildren(nodep);
}
//---- Track control flow changes
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
// Condition is part of PREVIOUS block
iterateAndNextNull(nodep->condp());
@ -357,7 +357,7 @@ private:
VL_DO_DANGLING(delete elseLifep, elseLifep);
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
// While's are a problem, as we don't allow loops in the graph. We
// may go around the cond/body multiple times. Thus a
// lifelication just in the body is ok, but we can't delete an
@ -386,7 +386,7 @@ private:
VL_DO_DANGLING(delete condLifep, condLifep);
VL_DO_DANGLING(delete bodyLifep, bodyLifep);
}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
// As with While's we can't predict if a JumpGo will kill us or not
// It's worse though as an IF(..., JUMPGO) may change the control flow.
// Just don't optimize blocks with labels; they're rare - so far.
@ -404,7 +404,7 @@ private:
bodyLifep->lifeToAbove();
VL_DO_DANGLING(delete bodyLifep, bodyLifep);
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
// UINFO(4, " CCALL " << nodep << endl);
iterateChildren(nodep);
// Enter the function and trace it
@ -414,7 +414,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// UINFO(4, " CFUNC " << nodep << endl);
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
@ -423,17 +423,17 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
m_sideEffect = true; // If appears on assign RHS, don't ever delete the assignment
iterateChildren(nodep);
}
virtual void visit(AstCMath* nodep) override {
void visit(AstCMath* nodep) override {
m_sideEffect = true; // If appears on assign RHS, don't ever delete the assignment
iterateChildren(nodep);
}
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't want varrefs under it
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -446,7 +446,7 @@ public:
if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr);
}
}
virtual ~LifeVisitor() override {
~LifeVisitor() override {
if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr);
}
VL_UNCOPYABLE(LifeVisitor);
@ -462,20 +462,20 @@ private:
LifeState* const m_statep; // Current state
// VISITORS
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (nodep->entryPoint()) {
// Usage model 1: Simulate all C code, doing lifetime analysis
LifeVisitor{nodep, m_statep};
}
}
virtual void visit(AstNodeProcedure* nodep) override {
void visit(AstNodeProcedure* nodep) override {
// Usage model 2: Cleanup basic blocks
LifeVisitor{nodep, m_statep};
}
virtual void visit(AstVar*) override {} // Accelerate
virtual void visit(AstNodeStmt*) override {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Accelerate
void visit(AstNodeStmt*) override {} // Accelerate
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -483,7 +483,7 @@ public:
: m_statep{statep} {
iterate(nodep);
}
virtual ~LifeTopVisitor() override = default;
~LifeTopVisitor() override = default;
};
//######################################################################

38
src/V3LifePost.cpp
View File

@ -54,7 +54,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
const AstVarScope* const vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
if (AstVarScope* const newvscp = reinterpret_cast<AstVarScope*>(vscp->user4p())) {
@ -64,11 +64,11 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -76,23 +76,23 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstExecGraph* nodep) override {
void visit(AstExecGraph* nodep) override {
// Can just iterate across the MTask bodies in any order. Order
// isn't important for LifePostElimVisitor's simple substitution.
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
iterateChildren(nodep);
}
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't want varrefs under it
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LifePostElimVisitor(AstTopScope* nodep) { iterate(nodep); }
virtual ~LifePostElimVisitor() override = default;
~LifePostElimVisitor() override = default;
};
//######################################################################
@ -250,7 +250,7 @@ private:
}
// VISITORS
virtual void visit(AstTopScope* nodep) override {
void visit(AstTopScope* nodep) override {
AstNode::user4ClearTree(); // user4p() used on entire tree
// First, build maps of every location (mtask and sequence
@ -274,7 +274,7 @@ private:
// Replace any node4p varscopes with the new scope
LifePostElimVisitor{nodep};
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Consumption/generation of a variable,
const AstVarScope* const vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Scope not assigned");
@ -283,14 +283,14 @@ private:
if (nodep->access().isWriteOrRW()) m_writes[vscp].insert(loc);
if (nodep->access().isReadOrRW()) m_reads[vscp].insert(loc);
}
virtual void visit(AstAssignPre* nodep) override {
void visit(AstAssignPre* nodep) override {
// Do not record varrefs within assign pre.
//
// The pre-assignment into the dly var should not count as its
// first write; we only want to consider reads and writes that
// would still happen if the dly var were eliminated.
}
virtual void visit(AstAssignPost* nodep) override {
void visit(AstAssignPost* nodep) override {
// Don't record ASSIGNPOST in the read/write maps, record them in a
// separate map
if (const AstVarRef* const rhsp = VN_CAST(nodep->rhsp(), VarRef)) {
@ -302,11 +302,11 @@ private:
m_assignposts[dlyVarp] = LifePostLocation(loc, nodep);
}
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Only track the top scopes, not lower level functions
if (nodep->isTop()) iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
if (!nodep->funcp()->entryPoint()) {
// Enter the function and trace it
@ -314,7 +314,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstExecGraph* nodep) override {
void visit(AstExecGraph* nodep) override {
// Treat the ExecGraph like a call to each mtask body
UASSERT_OBJ(!m_mtasksGraphp, nodep, "Cannot handle more than one AstExecGraph");
m_mtasksGraphp = nodep->depGraphp();
@ -327,19 +327,19 @@ private:
}
m_execMTaskp = nullptr;
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
iterateChildren(nodep);
}
//-----
virtual void visit(AstVar*) override {} // Don't want varrefs under it
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't want varrefs under it
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LifePostDlyVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~LifePostDlyVisitor() override {
~LifePostDlyVisitor() override {
V3Stats::addStat("Optimizations, Lifetime postassign deletions", m_statAssnDel);
}
};

38
src/V3LinkCells.cpp
View File

@ -45,8 +45,8 @@
class LinkCellsGraph final : public V3Graph {
public:
LinkCellsGraph() = default;
virtual ~LinkCellsGraph() override = default;
virtual void loopsMessageCb(V3GraphVertex* vertexp) override;
~LinkCellsGraph() override = default;
void loopsMessageCb(V3GraphVertex* vertexp) override;
};
class LinkCellsVertex final : public V3GraphVertex {
@ -56,12 +56,12 @@ public:
LinkCellsVertex(V3Graph* graphp, AstNodeModule* modp)
: V3GraphVertex{graphp}
, m_modp{modp} {}
virtual ~LinkCellsVertex() override = default;
~LinkCellsVertex() override = default;
AstNodeModule* modp() const { return m_modp; }
virtual string name() const override { return modp()->name(); }
virtual FileLine* fileline() const override { return modp()->fileline(); }
string name() const override { return modp()->name(); }
FileLine* fileline() const override { return modp()->fileline(); }
// Recursive modules get space for maximum recursion
virtual uint32_t rankAdder() const override {
uint32_t rankAdder() const override {
return m_modp->recursiveClone() ? (1 + v3Global.opt.moduleRecursionDepth()) : 1;
}
};
@ -70,8 +70,8 @@ class LibraryVertex final : public V3GraphVertex {
public:
explicit LibraryVertex(V3Graph* graphp)
: V3GraphVertex{graphp} {}
virtual ~LibraryVertex() override = default;
virtual string name() const override { return "*LIBRARY*"; }
~LibraryVertex() override = default;
string name() const override { return "*LIBRARY*"; }
};
void LinkCellsGraph::loopsMessageCb(V3GraphVertex* vertexp) {
@ -161,7 +161,7 @@ private:
}
// VISITs
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
AstNode::user1ClearTree();
readModNames();
iterateChildren(nodep);
@ -181,8 +181,8 @@ private:
<< "' was not found in design.");
}
}
virtual void visit(AstConstPool* nodep) override {}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstConstPool* nodep) override {}
void visit(AstNodeModule* nodep) override {
// Module: Pick up modnames, so we can resolve cells later
VL_RESTORER(m_modp);
{
@ -227,7 +227,7 @@ private:
}
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
// Cell: Resolve its filename. If necessary, parse it.
UINFO(4, "Link IfaceRef: " << nodep << endl);
// Use findIdUpward instead of findIdFlat; it doesn't matter for now
@ -246,14 +246,14 @@ private:
// Note cannot do modport resolution here; modports are allowed underneath generates
}
virtual void visit(AstPackageImport* nodep) override {
void visit(AstPackageImport* nodep) override {
// Package Import: We need to do the package before the use of a package
iterateChildren(nodep);
UASSERT_OBJ(nodep->packagep(), nodep, "Unlinked package"); // Parser should set packagep
new V3GraphEdge(&m_graph, vertex(m_modp), vertex(nodep->packagep()), 1, false);
}
virtual void visit(AstBind* nodep) override {
void visit(AstBind* nodep) override {
// Bind: Has cells underneath that need to be put into the new
// module, and cells which need resolution
// TODO this doesn't allow bind to dotted hier names, that would require
@ -275,7 +275,7 @@ private:
pushDeletep(nodep->unlinkFrBack());
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
// Cell: Resolve its filename. If necessary, parse it.
// Execute only once. Complication is that cloning may result in
// user1 being set (for pre-clone) so check if user1() matches the
@ -452,14 +452,14 @@ private:
UINFO(4, " Link Cell done: " << nodep << endl);
}
virtual void visit(AstRefDType* nodep) override {
void visit(AstRefDType* nodep) override {
iterateChildren(nodep);
for (AstPin* pinp = nodep->paramsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) {
pinp->param(true);
if (pinp->name() == "") pinp->name("__paramNumber" + cvtToStr(pinp->pinNum()));
}
}
virtual void visit(AstClassOrPackageRef* nodep) override {
void visit(AstClassOrPackageRef* nodep) override {
iterateChildren(nodep);
// Inside a class, an extends or reference to another class
// Note we don't add a V3GraphEdge{vertex(m_modp), vertex(nodep->classOrPackagep()}
@ -471,7 +471,7 @@ private:
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
// METHODS
void readModNames() {
@ -528,7 +528,7 @@ public:
}
iterate(nodep);
}
virtual ~LinkCellsVisitor() override = default;
~LinkCellsVisitor() override = default;
};
//######################################################################

200
src/V3LinkDot.cpp
View File

@ -81,25 +81,25 @@
class LinkNodeMatcherClass final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Class); }
bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Class); }
};
class LinkNodeMatcherFTask final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); }
bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, NodeFTask); }
};
class LinkNodeMatcherModport final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); }
bool nodeMatch(const AstNode* nodep) const override { return VN_IS(nodep, Modport); }
};
class LinkNodeMatcherVar final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override {
bool nodeMatch(const AstNode* nodep) const override {
return VN_IS(nodep, Var) || VN_IS(nodep, LambdaArgRef);
}
};
class LinkNodeMatcherVarIO final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override {
bool nodeMatch(const AstNode* nodep) const override {
const AstVar* const varp = VN_CAST(nodep, Var);
if (!varp) return false;
return varp->isIO();
@ -107,7 +107,7 @@ public:
};
class LinkNodeMatcherVarParam final : public VNodeMatcher {
public:
virtual bool nodeMatch(const AstNode* nodep) const override {
bool nodeMatch(const AstNode* nodep) const override {
const AstVar* const varp = VN_CAST(nodep, Var);
if (!varp) return false;
return varp->isParam();
@ -742,7 +742,7 @@ class LinkDotFindVisitor final : public VNVisitor {
}
// VISITs
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Process $unit or other packages
// Not needed - dotted references not allowed from inside packages
// for (AstNodeModule* nodep = v3Global.rootp()->modulesp();
@ -770,9 +770,9 @@ class LinkDotFindVisitor final : public VNVisitor {
m_curSymp = m_modSymp = nullptr;
}
}
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstTypeTable*) override {}
void visit(AstConstPool*) override {}
void visit(AstNodeModule* nodep) override {
// Called on top module from Netlist, other modules from the cell creating them,
// and packages
UINFO(8, " " << nodep << endl);
@ -839,7 +839,7 @@ class LinkDotFindVisitor final : public VNVisitor {
UINFO(5, "Module not under any CELL or top - dead module: " << nodep << endl);
}
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Class not under module/package/$unit");
UINFO(8, " " << nodep << endl);
VL_RESTORER(m_scope);
@ -871,12 +871,12 @@ class LinkDotFindVisitor final : public VNVisitor {
if (!m_explicitNew && m_statep->forPrimary()) makeImplicitNew(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
"Scopes should only exist right after V3Scope");
// Ignored. Processed in next step
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
UINFO(5, " CELL under " << m_scope << " is " << nodep << endl);
// Process XREFs/etc inside pins
if (nodep->recursive() && m_inRecursion) return;
@ -911,7 +911,7 @@ class LinkDotFindVisitor final : public VNVisitor {
if (nodep->modp()) iterate(nodep->modp());
}
}
virtual void visit(AstCellInline* nodep) override {
void visit(AstCellInline* nodep) override {
UINFO(5, " CELLINLINE under " << m_scope << " is " << nodep << endl);
VSymEnt* aboveSymp = m_curSymp;
// If baz__DOT__foo__DOT__bar, we need to find baz__DOT__foo and add bar to it.
@ -931,11 +931,11 @@ class LinkDotFindVisitor final : public VNVisitor {
m_statep->insertInline(aboveSymp, m_modSymp, nodep, nodep->name());
}
}
virtual void visit(AstDefParam* nodep) override {
void visit(AstDefParam* nodep) override {
nodep->user1p(m_curSymp);
iterateChildren(nodep);
}
virtual void visit(AstNodeBlock* nodep) override {
void visit(AstNodeBlock* nodep) override {
UINFO(5, " " << nodep << endl);
if (nodep->name() == "" && nodep->unnamed()) {
// Unnamed blocks are only important when they contain var
@ -967,7 +967,7 @@ class LinkDotFindVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
// NodeTask: Remember its name for later resolution
UINFO(5, " " << nodep << endl);
UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Function/Task not under module?");
@ -1040,7 +1040,7 @@ class LinkDotFindVisitor final : public VNVisitor {
m_ftaskp = nullptr;
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
// Var: Remember its name for later resolution
UASSERT_OBJ(m_curSymp && m_modSymp, nodep, "Var not under module?");
iterateChildren(nodep);
@ -1173,18 +1173,18 @@ class LinkDotFindVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstTypedef* nodep) override {
void visit(AstTypedef* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
iterateChildren(nodep);
m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
}
virtual void visit(AstTypedefFwd* nodep) override {
void visit(AstTypedefFwd* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Typedef not under module/package/$unit");
iterateChildren(nodep);
// No need to insert, only the real typedef matters, but need to track for errors
nodep->user1p(m_curSymp);
}
virtual void visit(AstParamTypeDType* nodep) override {
void visit(AstParamTypeDType* nodep) override {
UASSERT_OBJ(m_curSymp, nodep, "Parameter type not under module/package/$unit");
iterateChildren(nodep);
m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
@ -1195,11 +1195,11 @@ class LinkDotFindVisitor final : public VNVisitor {
symp->exported(false);
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// For dotted resolution, ignore all AstVars under functions, otherwise shouldn't exist
UASSERT_OBJ(!m_statep->forScopeCreation(), nodep, "No CFuncs expected in tree yet");
}
virtual void visit(AstEnumItem* nodep) override {
void visit(AstEnumItem* nodep) override {
// EnumItem: Remember its name for later resolution
iterateChildren(nodep);
// Find under either a task or the module's vars
@ -1238,7 +1238,7 @@ class LinkDotFindVisitor final : public VNVisitor {
}
if (ins) m_statep->insertSym(m_curSymp, nodep->name(), nodep, m_classOrPackagep);
}
virtual void visit(AstPackageImport* nodep) override {
void visit(AstPackageImport* nodep) override {
UINFO(4, " Link: " << nodep << endl);
VSymEnt* const srcp = m_statep->getNodeSym(nodep->packagep());
if (nodep->name() == "*") {
@ -1256,7 +1256,7 @@ class LinkDotFindVisitor final : public VNVisitor {
UINFO(9, " Link Done: " << nodep << endl);
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstPackageExport* nodep) override {
void visit(AstPackageExport* nodep) override {
UINFO(9, " Link: " << nodep << endl);
VSymEnt* const srcp = m_statep->getNodeSym(nodep->packagep());
if (nodep->name() != "*") {
@ -1270,13 +1270,13 @@ class LinkDotFindVisitor final : public VNVisitor {
UINFO(9, " Link Done: " << nodep << endl);
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstPackageExportStarStar* nodep) override {
void visit(AstPackageExportStarStar* nodep) override {
UINFO(4, " Link: " << nodep << endl);
m_curSymp->exportStarStar(m_statep->symsp());
// No longer needed, but can't delete until any multi-instantiated modules are expanded
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
// Symbol table needs nodep->name() as the index variable's name
VL_RESTORER(m_curSymp);
VSymEnt* const oldCurSymp = m_curSymp;
@ -1327,7 +1327,7 @@ class LinkDotFindVisitor final : public VNVisitor {
}
}
virtual void visit(AstWithParse* nodep) override {
void visit(AstWithParse* nodep) override {
// Change WITHPARSE(FUNCREF, equation) to FUNCREF(WITH(equation))
const auto funcrefp = VN_AS(nodep->funcrefp(), NodeFTaskRef);
UASSERT_OBJ(funcrefp, nodep, "'with' only can operate on a function/task");
@ -1355,7 +1355,7 @@ class LinkDotFindVisitor final : public VNVisitor {
nodep->replaceWith(funcrefp->unlinkFrBack());
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstWith* nodep) override {
void visit(AstWith* nodep) override {
// Symbol table needs nodep->name() as the index variable's name
// Iteration will pickup the AstVar we made under AstWith
VL_RESTORER(m_curSymp);
@ -1373,7 +1373,7 @@ class LinkDotFindVisitor final : public VNVisitor {
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1383,7 +1383,7 @@ public:
iterate(rootp);
}
virtual ~LinkDotFindVisitor() override = default;
~LinkDotFindVisitor() override = default;
};
//======================================================================
@ -1425,9 +1425,9 @@ private:
}
// VISITs
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstTypeTable*) override {}
void visit(AstConstPool*) override {}
void visit(AstNodeModule* nodep) override {
UINFO(5, " " << nodep << endl);
if (nodep->dead() || !nodep->user4()) {
UINFO(4, "Mark dead module " << nodep << endl);
@ -1444,7 +1444,7 @@ private:
m_modp = nullptr;
}
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
// Pin: Link to submodule's port
// Deal with implicit definitions - do before Resolve visitor as may
// be referenced above declaration
@ -1453,7 +1453,7 @@ private:
pinImplicitExprRecurse(nodep->exprp());
}
}
virtual void visit(AstDefParam* nodep) override {
void visit(AstDefParam* nodep) override {
iterateChildren(nodep);
nodep->v3warn(DEFPARAM, "defparam is deprecated (IEEE 1800-2017 C.4.1)\n"
<< nodep->warnMore()
@ -1475,7 +1475,7 @@ private:
}
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPort* nodep) override {
void visit(AstPort* nodep) override {
// Port: Stash the pin number
// Need to set pin numbers after varnames are created
// But before we do the final resolution based on names
@ -1508,14 +1508,14 @@ private:
// Ports not needed any more
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
// Deal with implicit definitions
// We used to nodep->allowImplicit() here, but it turns out
// normal "assigns" can also make implicit wires. Yuk.
pinImplicitExprRecurse(nodep->lhsp());
iterateChildren(nodep);
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
// tran gates need implicit creation
// As VarRefs don't exist in forPrimary, sanity check
UASSERT_OBJ(!m_statep->forPrimary(), nodep, "Assign aliases unexpected pre-dot");
@ -1527,13 +1527,13 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstImplicit* nodep) override {
void visit(AstImplicit* nodep) override {
// Unsupported gates need implicit creation
pinImplicitExprRecurse(nodep);
// We're done with implicit gates
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstClassOrPackageRef* nodep) override {
void visit(AstClassOrPackageRef* nodep) override {
if (auto* const fwdp = VN_CAST(nodep->classOrPackageNodep(), TypedefFwd)) {
// Relink forward definitions to the "real" definition
VSymEnt* const foundp = m_statep->getNodeSym(fwdp)->findIdFallback(fwdp->name());
@ -1555,7 +1555,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstTypedefFwd* nodep) override {
void visit(AstTypedefFwd* nodep) override {
VSymEnt* const foundp = m_statep->getNodeSym(nodep)->findIdFallback(nodep->name());
if (!foundp && v3Global.opt.pedantic()) {
// We only check it was ever really defined in pedantic mode, as it
@ -1570,7 +1570,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1579,7 +1579,7 @@ public:
UINFO(4, __FUNCTION__ << ": " << endl);
iterate(rootp);
}
virtual ~LinkDotParamVisitor() override = default;
~LinkDotParamVisitor() override = default;
};
//======================================================================
@ -1594,12 +1594,12 @@ class LinkDotScopeVisitor final : public VNVisitor {
static int debug() { return LinkDotState::debug(); }
// VISITs
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Recurse..., backward as must do packages before using packages
iterateChildrenBackwards(nodep);
}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstScope* nodep) override {
void visit(AstConstPool*) override {}
void visit(AstScope* nodep) override {
UINFO(8, " SCOPE " << nodep << endl);
UASSERT_OBJ(m_statep->forScopeCreation(), nodep,
"Scopes should only exist right after V3Scope");
@ -1611,7 +1611,7 @@ class LinkDotScopeVisitor final : public VNVisitor {
m_modSymp = nullptr;
m_scopep = nullptr;
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
if (!nodep->varp()->isFuncLocal() && !nodep->varp()->isClassMember()) {
VSymEnt* const varSymp
= m_statep->insertSym(m_modSymp, nodep->varp()->name(), nodep, nullptr);
@ -1649,22 +1649,22 @@ class LinkDotScopeVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
symp->fallbackp(m_modSymp);
// No recursion, we don't want to pick up variables
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
symp->fallbackp(m_modSymp);
// No recursion, we don't want to pick up variables
}
virtual void visit(AstWith* nodep) override {
void visit(AstWith* nodep) override {
VSymEnt* const symp = m_statep->insertBlock(m_modSymp, nodep->name(), nodep, nullptr);
symp->fallbackp(m_modSymp);
// No recursion, we don't want to pick up variables
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
// Track aliases created by V3Inline; if we get a VARXREF(aliased_from)
// we'll need to replace it with a VARXREF(aliased_to)
if (debug() >= 9) nodep->dumpTree(cout, "- alias: ");
@ -1674,7 +1674,7 @@ class LinkDotScopeVisitor final : public VNVisitor {
fromVscp->user2p(toVscp);
iterateChildren(nodep);
}
virtual void visit(AstAssignVarScope* nodep) override {
void visit(AstAssignVarScope* nodep) override {
UINFO(5, "ASSIGNVARSCOPE " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, "- avs: ");
VSymEnt* rhsSymp;
@ -1734,9 +1734,9 @@ class LinkDotScopeVisitor final : public VNVisitor {
}
// For speed, don't recurse things that can't have scope
// Note we allow AstNodeStmt's as generates may be under them
virtual void visit(AstCell*) override {}
virtual void visit(AstVar*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstCell*) override {}
void visit(AstVar*) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1745,7 +1745,7 @@ public:
UINFO(4, __FUNCTION__ << ": " << endl);
iterate(rootp);
}
virtual ~LinkDotScopeVisitor() override = default;
~LinkDotScopeVisitor() override = default;
};
//======================================================================
@ -1760,7 +1760,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
static int debug() { return LinkDotState::debug(); }
// VISITs
virtual void visit(AstModport* nodep) override {
void visit(AstModport* nodep) override {
// Modport: Remember its name for later resolution
UINFO(5, " fiv: " << nodep << endl);
VL_RESTORER(m_curSymp);
@ -1772,7 +1772,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstModportFTaskRef* nodep) override {
void visit(AstModportFTaskRef* nodep) override {
UINFO(5, " fif: " << nodep << endl);
iterateChildren(nodep);
if (nodep->isExport()) nodep->v3warn(E_UNSUPPORTED, "Unsupported: modport export");
@ -1795,7 +1795,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstModportVarRef* nodep) override {
void visit(AstModportVarRef* nodep) override {
UINFO(5, " fiv: " << nodep << endl);
iterateChildren(nodep);
VSymEnt* const symp = m_curSymp->findIdFallback(nodep->name());
@ -1820,7 +1820,7 @@ class LinkDotIfaceVisitor final : public VNVisitor {
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1830,7 +1830,7 @@ public:
UINFO(4, __FUNCTION__ << ": " << endl);
iterate(nodep);
}
virtual ~LinkDotIfaceVisitor() override = default;
~LinkDotIfaceVisitor() override = default;
};
void LinkDotState::computeIfaceModSyms() {
@ -2005,13 +2005,13 @@ private:
}
// VISITs
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Recurse..., backward as must do packages before using packages
iterateChildrenBackwards(nodep);
}
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstTypeTable*) override {}
void visit(AstConstPool*) override {}
void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
checkNoDot(nodep);
UINFO(8, " " << nodep << endl);
@ -2025,7 +2025,7 @@ private:
m_modp = nullptr;
m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UINFO(8, " " << nodep << endl);
VL_RESTORER(m_modSymp);
VL_RESTORER(m_curSymp);
@ -2036,14 +2036,14 @@ private:
m_ds.m_dotSymp = m_curSymp = m_modSymp = nullptr;
}
}
virtual void visit(AstCellInline* nodep) override {
void visit(AstCellInline* nodep) override {
checkNoDot(nodep);
if (m_statep->forScopeCreation() && !v3Global.opt.vpi()) {
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
// Cell: Recurse inside or cleanup not founds
checkNoDot(nodep);
AstNode::user5ClearTree();
@ -2072,7 +2072,7 @@ private:
// Parent module inherits child's publicity
// This is done bottom up in the LinkBotupVisitor stage
}
virtual void visit(AstClassRefDType* nodep) override {
void visit(AstClassRefDType* nodep) override {
// Cell: Recurse inside or cleanup not founds
checkNoDot(nodep);
AstNode::user5ClearTree();
@ -2089,7 +2089,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
// Pin: Link to submodule's port
checkNoDot(nodep);
iterateChildren(nodep);
@ -2130,7 +2130,7 @@ private:
}
// Early return() above when deleted
}
virtual void visit(AstDot* nodep) override {
void visit(AstDot* nodep) override {
// Legal under a DOT: AstDot, AstParseRef, AstPackageRef, AstNodeSel
// also a DOT can be part of an expression, but only above plus
// AstFTaskRef are legal children
@ -2239,7 +2239,7 @@ private:
m_ds.m_dotp = lastStates.m_dotp;
}
}
virtual void visit(AstParseRef* nodep) override {
void visit(AstParseRef* nodep) override {
if (nodep->user3SetOnce()) return;
UINFO(9, " linkPARSEREF " << m_ds.ascii() << " n=" << nodep << endl);
// m_curSymp is symbol table of outer expression
@ -2538,7 +2538,7 @@ private:
}
if (start) m_ds = lastStates;
}
virtual void visit(AstClassOrPackageRef* nodep) override {
void visit(AstClassOrPackageRef* nodep) override {
// Class: Recurse inside or cleanup not founds
// checkNoDot not appropriate, can be under a dot
AstNode::user5ClearTree();
@ -2559,7 +2559,7 @@ private:
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// VarRef: Resolve its reference
// ParseRefs are used the first pass (forPrimary) so we shouldn't get can't find
// errors here now that we have a VarRef.
@ -2581,7 +2581,7 @@ private:
}
}
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
// VarRef: Resolve its reference
// We always link even if varp() is set, because the module we choose may change
// due to creating new modules, flattening, etc.
@ -2661,18 +2661,18 @@ private:
}
}
}
virtual void visit(AstEnumDType* nodep) override {
void visit(AstEnumDType* nodep) override {
iterateChildren(nodep);
AstRefDType* const refdtypep = VN_CAST(nodep->subDTypep(), RefDType);
if (refdtypep && (nodep == refdtypep->subDTypep())) {
refdtypep->v3error("Self-referential enumerated type definition");
}
}
virtual void visit(AstEnumItemRef* nodep) override {
void visit(AstEnumItemRef* nodep) override {
// EnumItemRef may be under a dot. Should already be resolved.
iterateChildren(nodep);
}
virtual void visit(AstMethodCall* nodep) override {
void visit(AstMethodCall* nodep) override {
// Created here so should already be resolved.
VL_RESTORER(m_ds);
{
@ -2680,7 +2680,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
checkNoDot(nodep);
iterateChildren(nodep);
if (m_statep->forPrimary() && nodep->isIO() && !m_ftaskp && !nodep->user4()) {
@ -2688,7 +2688,7 @@ private:
"Input/output/inout does not appear in port list: " << nodep->prettyNameQ());
}
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
if (nodep->user3SetOnce()) return;
UINFO(8, " " << nodep << endl);
UINFO(8, " " << m_ds.ascii() << endl);
@ -2854,7 +2854,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstSelBit* nodep) override {
void visit(AstSelBit* nodep) override {
if (nodep->user3SetOnce()) return;
iterateAndNextNull(nodep->fromp());
if (m_ds.m_dotPos
@ -2882,7 +2882,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstNodePreSel* nodep) override {
void visit(AstNodePreSel* nodep) override {
// Excludes simple AstSelBit, see above
if (nodep->user3SetOnce()) return;
if (m_ds.m_dotPos
@ -2901,11 +2901,11 @@ private:
iterateAndNextNull(nodep->attrp());
}
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
// checkNoDot not appropriate, can be under a dot
iterateChildren(nodep);
}
virtual void visit(AstNodeBlock* nodep) override {
void visit(AstNodeBlock* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VSymEnt* const oldCurSymp = m_curSymp;
@ -2919,7 +2919,7 @@ private:
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
UINFO(5, " cur=se" << cvtToHex(m_curSymp) << endl);
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
if (nodep->isExternDef()) {
@ -2941,7 +2941,7 @@ private:
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
m_ftaskp = nullptr;
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VSymEnt* const oldCurSymp = m_curSymp;
@ -2951,7 +2951,7 @@ private:
}
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
}
virtual void visit(AstWith* nodep) override {
void visit(AstWith* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VSymEnt* const oldCurSymp = m_curSymp;
@ -2961,12 +2961,12 @@ private:
}
m_ds.m_dotSymp = m_curSymp = oldCurSymp;
}
virtual void visit(AstLambdaArgRef* nodep) override {
void visit(AstLambdaArgRef* nodep) override {
UINFO(5, " " << nodep << endl);
// No checknodot(nodep), visit(AstScope) will check for LambdaArgRef
iterateChildren(nodep);
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
UINFO(5, " " << nodep << endl);
checkNoDot(nodep);
VL_RESTORER(m_curSymp);
@ -3041,7 +3041,7 @@ private:
}
}
}
virtual void visit(AstRefDType* nodep) override {
void visit(AstRefDType* nodep) override {
// Resolve its reference
if (nodep->user3SetOnce()) return;
if (AstNode* const cpackagep = nodep->classOrPackageOpp()) {
@ -3112,7 +3112,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstDpiExport* nodep) override {
void visit(AstDpiExport* nodep) override {
// AstDpiExport: Make sure the function referenced exists, then dump it
iterateChildren(nodep);
checkNoDot(nodep);
@ -3130,35 +3130,35 @@ private:
}
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageImport* nodep) override {
void visit(AstPackageImport* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageExport* nodep) override {
void visit(AstPackageExport* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstPackageExportStarStar* nodep) override {
void visit(AstPackageExportStarStar* nodep) override {
// No longer needed
checkNoDot(nodep);
VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
}
virtual void visit(AstCellRef* nodep) override {
void visit(AstCellRef* nodep) override {
UINFO(5, " AstCellRef: " << nodep << " " << m_ds.ascii() << endl);
iterateChildren(nodep);
}
virtual void visit(AstCellArrayRef* nodep) override {
void visit(AstCellArrayRef* nodep) override {
UINFO(5, " AstCellArrayRef: " << nodep << " " << m_ds.ascii() << endl);
// Expression already iterated
}
virtual void visit(AstUnlinkedRef* nodep) override {
void visit(AstUnlinkedRef* nodep) override {
UINFO(5, " AstCellArrayRef: " << nodep << " " << m_ds.ascii() << endl);
// No need to iterate, if we have a UnlinkedVarXRef, we're already done
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
checkNoDot(nodep);
iterateChildren(nodep);
}
@ -3170,7 +3170,7 @@ public:
UINFO(4, __FUNCTION__ << ": " << endl);
iterate(rootp);
}
virtual ~LinkDotResolveVisitor() override = default;
~LinkDotResolveVisitor() override = default;
};
//######################################################################

40
src/V3LinkInc.cpp
View File

@ -89,12 +89,12 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modIncrementsNum);
m_modIncrementsNum = 0;
iterateChildren(nodep);
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
// Special, as statements need to be put in different places
// Preconditions insert first just before themselves (the normal
// rule for other statement types)
@ -111,7 +111,7 @@ private:
// Done the loop
m_insStmtp = nullptr; // Next thing should be new statement
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
// Special, as statements need to be put in different places
// Body insert just before themselves
m_insStmtp = nullptr; // First thing should be new statement
@ -119,7 +119,7 @@ private:
// Done the loop
m_insStmtp = nullptr; // Next thing should be new statement
}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
// Special, as statements need to be put in different places
// Body insert just before themselves
m_insStmtp = nullptr; // First thing should be new statement
@ -127,7 +127,7 @@ private:
// Done the loop
m_insStmtp = nullptr; // Next thing should be new statement
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
m_insStmtp = nodep;
iterateAndNextNull(nodep->condp());
m_insStmtp = nullptr;
@ -135,7 +135,7 @@ private:
iterateAndNextNull(nodep->elsesp());
m_insStmtp = nullptr;
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
m_insMode = IM_BEFORE;
{
VL_RESTORER(m_unsupportedHere);
@ -145,11 +145,11 @@ private:
m_insStmtp = nullptr; // Next thing should be new statement
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin.cpp");
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -165,11 +165,11 @@ private:
UINFO(9, "Marking unsupported " << nodep << endl);
iterateChildren(nodep);
}
virtual void visit(AstLogAnd* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogOr* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogEq* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstLogIf* nodep) override { unsupported_visit(nodep); }
virtual void visit(AstNodeCond* nodep) override { unsupported_visit(nodep); }
void visit(AstLogAnd* nodep) override { unsupported_visit(nodep); }
void visit(AstLogOr* nodep) override { unsupported_visit(nodep); }
void visit(AstLogEq* nodep) override { unsupported_visit(nodep); }
void visit(AstLogIf* nodep) override { unsupported_visit(nodep); }
void visit(AstNodeCond* nodep) override { unsupported_visit(nodep); }
void prepost_visit(AstNodeTriop* nodep) {
// Check if we are underneath a statement
if (!m_insStmtp) {
@ -257,17 +257,17 @@ private:
nodep->replaceWith(new AstVarRef(varrefp->fileline(), varp, VAccess::WRITE));
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstGenFor* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
void visit(AstGenFor* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LinkIncVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~LinkIncVisitor() override = default;
~LinkIncVisitor() override = default;
};
//######################################################################

30
src/V3LinkJump.cpp
View File

@ -122,7 +122,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (nodep->dead()) return;
VL_RESTORER(m_modp);
VL_RESTORER(m_modRepeatNum);
@ -132,12 +132,12 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
iterateChildren(nodep);
m_ftaskp = nullptr;
}
virtual void visit(AstNodeBlock* nodep) override {
void visit(AstNodeBlock* nodep) override {
UINFO(8, " " << nodep << endl);
VL_RESTORER(m_inFork);
m_blockStack.push_back(nodep);
@ -147,7 +147,7 @@ private:
}
m_blockStack.pop_back();
}
virtual void visit(AstRepeat* nodep) override {
void visit(AstRepeat* nodep) override {
// So later optimizations don't need to deal with them,
// REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
// Note var can be signed or unsigned based on original number.
@ -175,7 +175,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstWait* nodep) override {
void visit(AstWait* nodep) override {
nodep->v3warn(E_UNSUPPORTED, "Unsupported: wait statements");
// Statements we'll just execute immediately; equivalent to if they followed this
if (AstNode* const bodysp = nodep->bodysp()) {
@ -186,7 +186,7 @@ private:
}
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
// Don't need to track AstRepeat/AstFor as they have already been converted
VL_RESTORER(m_loopp);
VL_RESTORER(m_loopInc);
@ -200,14 +200,14 @@ private:
iterateAndNextNull(nodep->incsp());
}
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
VL_RESTORER(m_loopp);
{
m_loopp = nodep;
iterateAndNextNull(nodep->bodysp());
}
}
virtual void visit(AstReturn* nodep) override {
void visit(AstReturn* nodep) override {
iterateChildren(nodep);
const AstFunc* const funcp = VN_CAST(m_ftaskp, Func);
if (m_inFork) {
@ -235,7 +235,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstBreak* nodep) override {
void visit(AstBreak* nodep) override {
iterateChildren(nodep);
if (!m_loopp) {
nodep->v3error("break isn't underneath a loop");
@ -247,7 +247,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstContinue* nodep) override {
void visit(AstContinue* nodep) override {
iterateChildren(nodep);
if (!m_loopp) {
nodep->v3error("continue isn't underneath a loop");
@ -260,7 +260,7 @@ private:
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstDisable* nodep) override {
void visit(AstDisable* nodep) override {
UINFO(8, " DISABLE " << nodep << endl);
iterateChildren(nodep);
AstNodeBlock* blockp = nullptr;
@ -285,16 +285,16 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
// if (debug() >= 9) { UINFO(0, "\n"); beginp->dumpTree(cout, " labelo: "); }
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (m_loopInc && nodep->varp()) nodep->varp()->usedLoopIdx(true);
}
virtual void visit(AstConst*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstConst*) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LinkJumpVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~LinkJumpVisitor() override = default;
~LinkJumpVisitor() override = default;
};
//######################################################################

68
src/V3LinkLValue.cpp
View File

@ -46,7 +46,7 @@ private:
// VISITs
// Result handing
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
// VarRef: LValue its reference
if (m_setRefLvalue != VAccess::NOCHANGE) nodep->access(m_setRefLvalue);
if (nodep->varp()) {
@ -65,7 +65,7 @@ private:
}
// Nodes that start propagating down lvalues
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
if (nodep->modVarp() && nodep->modVarp()->isWritable()) {
// When the varref's were created, we didn't know the I/O state
// Now that we do, and it's from a output, we know it's a lvalue
@ -76,7 +76,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
VL_RESTORER(m_setRefLvalue);
VL_RESTORER(m_setContinuously);
{
@ -92,7 +92,7 @@ private:
iterateAndNextNull(nodep->rhsp());
}
}
virtual void visit(AstRelease* nodep) override {
void visit(AstRelease* nodep) override {
VL_RESTORER(m_setRefLvalue);
VL_RESTORER(m_setContinuously);
{
@ -101,7 +101,7 @@ private:
iterateAndNextNull(nodep->lhsp());
}
}
virtual void visit(AstCastDynamic* nodep) override {
void visit(AstCastDynamic* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::NOCHANGE;
@ -110,7 +110,7 @@ private:
iterateAndNextNull(nodep->top());
}
}
virtual void visit(AstFOpen* nodep) override {
void visit(AstFOpen* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -120,7 +120,7 @@ private:
iterateAndNextNull(nodep->modep());
}
}
virtual void visit(AstFOpenMcd* nodep) override {
void visit(AstFOpenMcd* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -129,14 +129,14 @@ private:
iterateAndNextNull(nodep->filenamep());
}
}
virtual void visit(AstFClose* nodep) override {
void visit(AstFClose* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->filep());
}
}
virtual void visit(AstFError* nodep) override {
void visit(AstFError* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -144,21 +144,21 @@ private:
iterateAndNextNull(nodep->strp());
}
}
virtual void visit(AstFFlush* nodep) override {
void visit(AstFFlush* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->filep());
}
}
virtual void visit(AstFGetC* nodep) override {
void visit(AstFGetC* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->filep());
}
}
virtual void visit(AstFGetS* nodep) override {
void visit(AstFGetS* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -166,7 +166,7 @@ private:
iterateAndNextNull(nodep->strgp());
}
}
virtual void visit(AstFRead* nodep) override {
void visit(AstFRead* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -174,7 +174,7 @@ private:
iterateAndNextNull(nodep->filep());
}
}
virtual void visit(AstFScanF* nodep) override {
void visit(AstFScanF* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -182,33 +182,33 @@ private:
iterateAndNextNull(nodep->exprsp());
}
}
virtual void visit(AstFUngetC* nodep) override {
void visit(AstFUngetC* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->filep());
}
}
virtual void visit(AstSScanF* nodep) override {
void visit(AstSScanF* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->exprsp());
}
}
virtual void visit(AstSysIgnore* nodep) override {
void visit(AstSysIgnore* nodep) override {
// Can't know if lvalue or not; presume so as stricter
VL_RESTORER(m_setRefLvalue);
iterateChildren(nodep);
}
virtual void visit(AstRand* nodep) override {
void visit(AstRand* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
if (!nodep->urandom()) m_setRefLvalue = VAccess::WRITE;
iterateAndNextNull(nodep->seedp());
}
}
virtual void visit(AstReadMem* nodep) override {
void visit(AstReadMem* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -219,14 +219,14 @@ private:
iterateAndNextNull(nodep->msbp());
}
}
virtual void visit(AstTestPlusArgs* nodep) override {
void visit(AstTestPlusArgs* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::NOCHANGE;
iterateAndNextNull(nodep->searchp());
}
}
virtual void visit(AstValuePlusArgs* nodep) override {
void visit(AstValuePlusArgs* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::NOCHANGE;
@ -235,7 +235,7 @@ private:
iterateAndNextNull(nodep->outp());
}
}
virtual void visit(AstSFormat* nodep) override {
void visit(AstSFormat* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
m_setRefLvalue = VAccess::WRITE;
@ -254,13 +254,13 @@ private:
iterateAndNextNull(nodep->thsp());
}
}
virtual void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
virtual void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
void visit(AstPreAdd* nodep) override { prepost_visit(nodep); }
void visit(AstPostAdd* nodep) override { prepost_visit(nodep); }
void visit(AstPreSub* nodep) override { prepost_visit(nodep); }
void visit(AstPostSub* nodep) override { prepost_visit(nodep); }
// Nodes that change LValue state
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
VL_RESTORER(m_setRefLvalue);
{
iterateAndNextNull(nodep->lhsp());
@ -270,7 +270,7 @@ private:
iterateAndNextNull(nodep->thsp());
}
}
virtual void visit(AstNodeSel* nodep) override {
void visit(AstNodeSel* nodep) override {
VL_RESTORER(m_setRefLvalue);
{ // Only set lvalues on the from
iterateAndNextNull(nodep->lhsp());
@ -278,14 +278,14 @@ private:
iterateAndNextNull(nodep->rhsp());
}
}
virtual void visit(AstCellArrayRef* nodep) override {
void visit(AstCellArrayRef* nodep) override {
VL_RESTORER(m_setRefLvalue);
{ // selp is not an lvalue
m_setRefLvalue = VAccess::NOCHANGE;
iterateAndNextNull(nodep->selp());
}
}
virtual void visit(AstNodePreSel* nodep) override {
void visit(AstNodePreSel* nodep) override {
VL_RESTORER(m_setRefLvalue);
{ // Only set lvalues on the from
iterateAndNextNull(nodep->fromp());
@ -294,12 +294,12 @@ private:
iterateAndNextNull(nodep->thsp());
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
m_ftaskp = nodep;
iterateChildren(nodep);
m_ftaskp = nullptr;
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
AstNode* pinp = nodep->pinsp();
const AstNodeFTask* const taskp = nodep->taskp();
// We'll deal with mismatching pins later
@ -321,7 +321,7 @@ private:
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -329,7 +329,7 @@ public:
: m_setRefLvalue{start} {
iterate(nodep);
}
virtual ~LinkLValueVisitor() override = default;
~LinkLValueVisitor() override = default;
};
//######################################################################

56
src/V3LinkParse.cpp
View File

@ -122,7 +122,7 @@ private:
}
// VISITs
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
if (!nodep->user1SetOnce()) { // Process only once.
V3Config::applyFTask(m_modp, nodep);
cleanFileline(nodep);
@ -139,7 +139,7 @@ private:
}
}
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
if (!nodep->user1SetOnce()) { // Process only once.
cleanFileline(nodep);
UINFO(5, " " << nodep << endl);
@ -150,20 +150,20 @@ private:
}
}
}
virtual void visit(AstNodeDType* nodep) override { visitIterateNodeDType(nodep); }
virtual void visit(AstEnumDType* nodep) override {
void visit(AstNodeDType* nodep) override { visitIterateNodeDType(nodep); }
void visit(AstEnumDType* nodep) override {
if (nodep->name() == "") {
nodep->name(nameFromTypedef(nodep)); // Might still remain ""
}
visitIterateNodeDType(nodep);
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
if (nodep->name() == "") {
nodep->name(nameFromTypedef(nodep)); // Might still remain ""
}
visitIterateNodeDType(nodep);
}
virtual void visit(AstEnumItem* nodep) override {
void visit(AstEnumItem* nodep) override {
// Expand ranges
cleanFileline(nodep);
iterateChildren(nodep);
@ -198,7 +198,7 @@ private:
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
cleanFileline(nodep);
if (nodep->lifetime().isNone()) {
if (m_ftaskp) {
@ -296,7 +296,7 @@ private:
}
}
virtual void visit(AstAttrOf* nodep) override {
void visit(AstAttrOf* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
if (nodep->attrType() == VAttrType::DT_PUBLIC) {
@ -365,7 +365,7 @@ private:
}
}
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
// AlwaysPublic was attached under a var, but it's a statement that should be
// at the same level as the var
cleanFileline(nodep);
@ -381,7 +381,7 @@ private:
}
}
virtual void visit(AstDefImplicitDType* nodep) override {
void visit(AstDefImplicitDType* nodep) override {
cleanFileline(nodep);
UINFO(8, " DEFIMPLICIT " << nodep << endl);
// Must remember what names we've already created, and combine duplicates
@ -422,7 +422,7 @@ private:
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstForeach* nodep) override {
void visit(AstForeach* nodep) override {
// FOREACH(array, loopvars, body)
UINFO(9, "FOREACH " << nodep << endl);
// Separate iteration vars from base from variable
@ -457,7 +457,7 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
V3Config::applyModule(nodep);
VL_RESTORER(m_modp);
@ -490,16 +490,16 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeProcedure* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstAlways* nodep) override {
void visit(AstNodeProcedure* nodep) override { visitIterateNoValueMod(nodep); }
void visit(AstAlways* nodep) override {
VL_RESTORER(m_inAlways);
m_inAlways = true;
visitIterateNoValueMod(nodep);
}
virtual void visit(AstCover* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstRestrict* nodep) override { visitIterateNoValueMod(nodep); }
void visit(AstCover* nodep) override { visitIterateNoValueMod(nodep); }
void visit(AstRestrict* nodep) override { visitIterateNoValueMod(nodep); }
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
V3Config::applyCoverageBlock(m_modp, nodep);
cleanFileline(nodep);
const AstNode* const backp = nodep->backp();
@ -525,7 +525,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstGenCase* nodep) override {
void visit(AstGenCase* nodep) override {
++m_genblkNum;
cleanFileline(nodep);
{
@ -536,7 +536,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstGenIf* nodep) override {
void visit(AstGenIf* nodep) override {
cleanFileline(nodep);
const bool nestedIf
= (VN_IS(nodep->backp(), Begin) && nestedIfBegin(VN_CAST(nodep->backp(), Begin)));
@ -551,39 +551,39 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstCase* nodep) override {
void visit(AstCase* nodep) override {
V3Config::applyCase(nodep);
cleanFileline(nodep);
iterateChildren(nodep);
}
virtual void visit(AstPrintTimeScale* nodep) override {
void visit(AstPrintTimeScale* nodep) override {
// Inlining may change hierarchy, so just save timescale where needed
cleanFileline(nodep);
iterateChildren(nodep);
nodep->name(m_modp->name());
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTime* nodep) override {
void visit(AstTime* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTimeD* nodep) override {
void visit(AstTimeD* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstTimeImport* nodep) override {
void visit(AstTimeImport* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
nodep->timeunit(m_modp->timeunit());
}
virtual void visit(AstEventControl* nodep) override {
void visit(AstEventControl* nodep) override {
cleanFileline(nodep);
iterateChildren(nodep);
AstAlways* const alwaysp = VN_CAST(nodep->backp(), Always);
@ -605,7 +605,7 @@ private:
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// Default: Just iterate
cleanFileline(nodep);
iterateChildren(nodep);
@ -614,7 +614,7 @@ private:
public:
// CONSTRUCTORS
explicit LinkParseVisitor(AstNetlist* rootp) { iterate(rootp); }
virtual ~LinkParseVisitor() override = default;
~LinkParseVisitor() override = default;
};
//######################################################################

74
src/V3LinkResolve.cpp
View File

@ -62,7 +62,7 @@ private:
// TODO: Most of these visitors are here for historical reasons.
// TODO: ExpectDecriptor can move to data type resolution, and the rest
// TODO: could move to V3LinkParse to get them out of the way of elaboration
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Module: Create sim table for entire module and iterate
UINFO(8, "MODULE " << nodep << endl);
if (nodep->dead()) return;
@ -74,14 +74,14 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
VL_RESTORER(m_classp);
{
m_classp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstInitialAutomatic* nodep) override {
void visit(AstInitialAutomatic* nodep) override {
iterateChildren(nodep);
// Initial assignments under function/tasks can just be simple
// assignments without the initial
@ -89,13 +89,13 @@ private:
VL_DO_DANGLING(nodep->replaceWith(nodep->bodysp()->unlinkFrBackWithNext()), nodep);
}
}
virtual void visit(AstNodeCoverOrAssert* nodep) override {
void visit(AstNodeCoverOrAssert* nodep) override {
if (m_assertp) nodep->v3error("Assert not allowed under another assert");
m_assertp = nodep;
iterateChildren(nodep);
m_assertp = nullptr;
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
if (m_classp && !nodep->isParam()) nodep->varType(VVarType::MEMBER);
if (m_ftaskp) nodep->funcLocal(true);
@ -105,13 +105,13 @@ private:
}
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
// VarRef: Resolve its reference
if (nodep->varp()) nodep->varp()->usedParam(true);
iterateChildren(nodep);
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
// NodeTask: Remember its name for later resolution
if (m_underGenerate) nodep->underGenerate(true);
// Remember the existing symbol table scope
@ -139,14 +139,14 @@ private:
m_ftaskp = nullptr;
if (nodep->dpiExport()) nodep->scopeNamep(new AstScopeName{nodep->fileline(), false});
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
iterateChildren(nodep);
if (nodep->taskp() && (nodep->taskp()->dpiContext() || nodep->taskp()->dpiExport())) {
nodep->scopeNamep(new AstScopeName{nodep->fileline(), false});
}
}
virtual void visit(AstSenItem* nodep) override {
void visit(AstSenItem* nodep) override {
// Remove bit selects, and bark if it's not a simple variable
iterateChildren(nodep);
if (nodep->isClocked()) {
@ -214,7 +214,7 @@ private:
}
}
virtual void visit(AstNodePreSel* nodep) override {
void visit(AstNodePreSel* nodep) override {
if (!nodep->attrp()) {
iterateChildren(nodep);
// Constification may change the fromp() to a constant, which will lose the
@ -249,7 +249,7 @@ private:
}
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
// Move default caseItems to the bottom of the list
// That saves us from having to search each case list twice, for non-defaults and defaults
iterateChildren(nodep);
@ -261,7 +261,7 @@ private:
}
}
virtual void visit(AstPragma* nodep) override {
void visit(AstPragma* nodep) override {
if (nodep->pragType() == VPragmaType::HIER_BLOCK) {
UASSERT_OBJ(m_modp, nodep, "HIER_BLOCK not under a module");
// If this is hierarchical mode which is to lib-create,
@ -411,39 +411,39 @@ private:
if (filep && filep->varp()) filep->varp()->attrFileDescr(true);
}
virtual void visit(AstFOpen* nodep) override {
void visit(AstFOpen* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFOpenMcd* nodep) override {
void visit(AstFOpenMcd* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFClose* nodep) override {
void visit(AstFClose* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFError* nodep) override {
void visit(AstFError* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFEof* nodep) override {
void visit(AstFEof* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFRead* nodep) override {
void visit(AstFRead* nodep) override {
iterateChildren(nodep);
expectDescriptor(nodep, VN_CAST(nodep->filep(), NodeVarRef));
}
virtual void visit(AstFScanF* nodep) override {
void visit(AstFScanF* nodep) override {
iterateChildren(nodep);
expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSScanF* nodep) override {
void visit(AstSScanF* nodep) override {
iterateChildren(nodep);
expectFormat(nodep, nodep->text(), nodep->exprsp(), true);
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
// Cleanup old-school displays without format arguments
if (!nodep->hasFormat()) {
@ -466,7 +466,7 @@ private:
}
}
virtual void visit(AstUdpTable* nodep) override {
void visit(AstUdpTable* nodep) override {
UINFO(5, "UDPTABLE " << nodep << endl);
if (!v3Global.opt.bboxUnsup()) {
// We don't warn until V3Inst, so that UDPs that are in libraries and
@ -497,49 +497,49 @@ private:
}
}
virtual void visit(AstScCtor* nodep) override {
void visit(AstScCtor* nodep) override {
// Constructor info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstScDtor* nodep) override {
void visit(AstScDtor* nodep) override {
// Destructor info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstScInt* nodep) override {
void visit(AstScInt* nodep) override {
// Special class info means the module must remain public
m_modp->modPublic(true);
iterateChildren(nodep);
}
virtual void visit(AstIfaceRefDType* nodep) override {
void visit(AstIfaceRefDType* nodep) override {
// LinkDot checked modports, now remove references to them
// Keeping them later caused problems with InstDeArray,
// as it needed to make new modport arrays and such
nodep->modportp(nullptr);
iterateChildren(nodep);
}
// virtual void visit(AstModport* nodep) override { ... }
// void visit(AstModport* nodep) override { ... }
// We keep Modport's themselves around for XML dump purposes
virtual void visit(AstGenFor* nodep) override {
void visit(AstGenFor* nodep) override {
VL_RESTORER(m_underGenerate);
m_underGenerate = true;
iterateChildren(nodep);
}
virtual void visit(AstGenIf* nodep) override {
void visit(AstGenIf* nodep) override {
VL_RESTORER(m_underGenerate);
m_underGenerate = true;
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LinkResolveVisitor(AstNetlist* rootp) { iterate(rootp); }
virtual ~LinkResolveVisitor() override = default;
~LinkResolveVisitor() override = default;
};
//######################################################################
@ -556,29 +556,29 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITs
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
// Iterate modules backwards, in bottom-up order.
iterateChildrenBackwards(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
// Parent module inherits child's publicity
if (nodep->modp()->modPublic()) m_modp->modPublic(true);
//** No iteration for speed
}
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit LinkBotupVisitor(AstNetlist* rootp) { iterate(rootp); }
virtual ~LinkBotupVisitor() override = default;
~LinkBotupVisitor() override = default;
};
//######################################################################

16
src/V3Localize.cpp
View File

@ -123,12 +123,12 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
iterateChildrenConst(nodep);
moveVarScopes();
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
UINFO(4, " CFUNC " << nodep << endl);
VL_RESTORER(m_cfuncp);
VL_RESTORER(m_nodeDepth);
@ -140,12 +140,12 @@ private:
}
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
m_cfuncp->user1(true); // Mark caller as not a leaf function
iterateChildrenConst(nodep);
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// Analyze RHS first so "a = a + 1" is detected as a read before write
iterate(nodep->rhsp());
// For now we only consider an assignment that is directly under the function, (in
@ -163,7 +163,7 @@ private:
iterate(nodep->lhsp());
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
if (!nodep->varp()->isPrimaryIO() // Not an IO the user wants to interact with
&& !nodep->varp()->isSigPublic() // Not something the user wants to interact with
&& !nodep->varp()->isFuncLocal() // Not already a function local (e.g.: argument)
@ -177,7 +177,7 @@ private:
// No iterate; Don't want varrefs under it (e.g.: in child dtype?)
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
UASSERT_OBJ(m_cfuncp, nodep, "AstVarRef not under function");
AstVarScope* const varScopep = nodep->varScopep();
@ -201,7 +201,7 @@ private:
// No iterate; Don't want varrefs under it (e.g.: in child dtype?)
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
++m_nodeDepth;
iterateChildrenConst(nodep);
--m_nodeDepth;
@ -210,7 +210,7 @@ private:
public:
// CONSTRUCTORS
explicit LocalizeVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~LocalizeVisitor() override {
~LocalizeVisitor() override {
V3Stats::addStat("Optimizations, Vars localized", m_statLocVars);
}
};

16
src/V3MergeCond.cpp
View File

@ -823,7 +823,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (AstNode* const condp = (*m_stmtPropertiesp)(nodep).m_condp) {
// Check if mergeable
if (!checkOrMakeMergeable(nodep)) return;
@ -836,7 +836,7 @@ private:
}
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
// Check if mergeable
if (!checkOrMakeMergeable(nodep)) {
// If not mergeable, try to merge the branches
@ -850,25 +850,25 @@ private:
addToList(nodep, nodep->condp());
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (m_mgFirstp && addIfHelpfulElseEndMerge(nodep)) return;
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// Merge function body
if (nodep->stmtsp()) process(nodep->stmtsp());
}
// For speed, only iterate what is necessary.
virtual void visit(AstNetlist* nodep) override { iterateAndNextNull(nodep->modulesp()); }
virtual void visit(AstNodeModule* nodep) override { iterateAndNextNull(nodep->stmtsp()); }
virtual void visit(AstNode* nodep) override {}
void visit(AstNetlist* nodep) override { iterateAndNextNull(nodep->modulesp()); }
void visit(AstNodeModule* nodep) override { iterateAndNextNull(nodep->stmtsp()); }
void visit(AstNode* nodep) override {}
public:
// CONSTRUCTORS
explicit MergeCondVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~MergeCondVisitor() override {
~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);

20
src/V3Name.cpp
View File

@ -68,7 +68,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
@ -76,44 +76,44 @@ private:
}
}
// Add __PVT__ to names of local signals
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
// Don't iterate... Don't need temps for RANGES under the Var.
rename(nodep,
((!m_modp || !m_modp->isTop()) && !nodep->isSigPublic()
&& !nodep->isFuncLocal() // Isn't exposed, and would mess up dpi import wrappers
&& !nodep->isTemp())); // Don't bother to rename internal signals
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!nodep->user1()) {
iterateChildren(nodep);
rename(nodep, false);
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->varp()) {
iterate(nodep->varp());
nodep->name(nodep->varp()->name());
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
if (!nodep->user1()) {
rename(nodep, (!nodep->modp()->modPublic() && !VN_IS(nodep->modp(), ClassPackage)));
iterateChildren(nodep);
}
}
virtual void visit(AstMemberDType* nodep) override {
void visit(AstMemberDType* nodep) override {
if (!nodep->user1()) {
rename(nodep, false);
iterateChildren(nodep);
}
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
if (!nodep->user1()) {
rename(nodep, false);
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
if (!nodep->user1SetOnce()) {
if (nodep->aboveScopep()) iterate(nodep->aboveScopep());
if (nodep->aboveCellp()) iterate(nodep->aboveCellp());
@ -130,12 +130,12 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit NameVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~NameVisitor() override = default;
~NameVisitor() override = default;
};
//######################################################################

16
src/V3OptionParser.cpp
View File

@ -39,12 +39,12 @@ struct V3OptionParser::Impl {
class ActionBase VL_NOT_FINAL : public ActionIfs {
bool m_undocumented = false; // This option is not documented
public:
virtual bool isValueNeeded() const override final { return MODE == en::VALUE; }
virtual bool isFOnOffAllowed() const override final { return MODE == en::FONOFF; }
virtual bool isOnOffAllowed() const override final { return MODE == en::ONOFF; }
virtual bool isPartialMatchAllowed() const override final { return ALLOW_PARTIAL_MATCH; }
virtual bool isUndocumented() const override { return m_undocumented; }
virtual void undocumented() override { m_undocumented = true; }
bool isValueNeeded() const override final { return MODE == en::VALUE; }
bool isFOnOffAllowed() const override final { return MODE == en::FONOFF; }
bool isOnOffAllowed() const override final { return MODE == en::ONOFF; }
bool isPartialMatchAllowed() const override final { return ALLOW_PARTIAL_MATCH; }
bool isUndocumented() const override { return m_undocumented; }
void undocumented() override { m_undocumented = true; }
};
// Actual action classes
@ -78,7 +78,7 @@ struct V3OptionParser::Impl {
public: \
explicit className(type* valp) \
: m_valp(valp) {} \
virtual void exec(const char* optp, const char* argp) override { body; } \
void exec(const char* optp, const char* argp) override { body; } \
}
V3OPTION_PARSER_DEF_ACT_CLASS(ActionSet, bool, *m_valp = true, en::NONE);
@ -104,7 +104,7 @@ V3OPTION_PARSER_DEF_ACT_CLASS(ActionOnOff, VOptionBool, m_valp->setTrueOrFalse(!
using CbType = std::function<funcType>; \
explicit className(CbType cb) \
: m_cb(std::move(cb)) {} \
virtual void exec(const char* optp, const char* argp) override { body; } \
void exec(const char* optp, const char* argp) override { body; } \
}
V3OPTION_PARSER_DEF_ACT_CB_CLASS(ActionCbCall, void(void), m_cb(), en::NONE);

95
src/V3Order.cpp
View File

@ -157,7 +157,7 @@ static bool isClockerAssignment(AstNodeAssign* nodep) {
private:
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (const AstVarRef* const varrefp = VN_CAST(nodep->lhsp(), VarRef)) {
if (varrefp->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
m_clkAss = true;
@ -166,8 +166,8 @@ static bool isClockerAssignment(AstNodeAssign* nodep) {
}
iterateChildren(nodep->rhsp());
}
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
} visitor;
visitor.iterate(nodep);
return visitor.m_clkAss;
@ -212,7 +212,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
// METHODS
VL_DEBUG_FUNC; // Declare debug()
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
m_hasClk = false;
m_inAss = true;
m_childClkWidth = 0;
@ -236,7 +236,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (m_inAss && nodep->varp()->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
if (m_inClocked) {
nodep->v3warn(CLKDATA,
@ -249,7 +249,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
if (m_inAss) {
iterateAndNextNull(nodep->lhsp());
const int lw = m_childClkWidth;
@ -258,20 +258,20 @@ class OrderClkMarkVisitor final : public VNVisitor {
m_childClkWidth = lw + rw; // Pass up
}
}
virtual void visit(AstNodeSel* nodep) override {
void visit(AstNodeSel* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
// Pass up result width
if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
}
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
if (m_childClkWidth > nodep->width()) m_childClkWidth = nodep->width();
}
}
virtual void visit(AstReplicate* nodep) override {
void visit(AstReplicate* nodep) override {
if (m_inAss) {
iterateChildren(nodep);
if (VN_IS(nodep->rhsp(), Const)) {
@ -281,12 +281,12 @@ class OrderClkMarkVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
m_inClocked = nodep->hasClocked();
iterateChildren(nodep);
m_inClocked = false;
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
// CONSTRUCTORS
explicit OrderClkMarkVisitor(AstNode* nodep) {
@ -295,7 +295,7 @@ class OrderClkMarkVisitor final : public VNVisitor {
iterate(nodep);
} while (m_newClkMarked);
}
virtual ~OrderClkMarkVisitor() override = default;
~OrderClkMarkVisitor() override = default;
public:
static void process(AstNetlist* nodep) { OrderClkMarkVisitor{nodep}; }
@ -416,19 +416,19 @@ class OrderBuildVisitor final : public VNVisitor {
}
// VISITORS
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
// This should only find the global AstSenTrees under the AstTopScope, which we ignore
// here. We visit AstSenTrees separately when encountering the AstActive that references
// them.
UASSERT_OBJ(!m_scopep, nodep, "AstSenTrees should have been made global in V3ActiveTop");
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UASSERT_OBJ(!m_scopep, nodep, "Should not nest");
m_scopep = nodep;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstActive* nodep) override {
void visit(AstActive* nodep) override {
UASSERT_OBJ(!nodep->sensesStorep(), nodep,
"AstSenTrees should have been made global in V3ActiveTop");
UASSERT_OBJ(m_scopep, nodep, "AstActive not under AstScope");
@ -460,7 +460,7 @@ class OrderBuildVisitor final : public VNVisitor {
m_activeSenVxp = nullptr;
m_domainp = nullptr;
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
// As we explicitly not visit (see ignored nodes below) any subtree that is not relevant
// for ordering, we should be able to assert this:
UASSERT_OBJ(m_scopep, nodep, "AstVarRef not under scope");
@ -635,7 +635,7 @@ class OrderBuildVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstDpiExportUpdated* nodep) override {
void visit(AstDpiExportUpdated* nodep) override {
// This is under a logic block (AstAlways) sensitive to a change in the DPI export trigger.
// We just need to add an edge to the enclosing logic vertex (the vertex for the
// AstAlways).
@ -645,7 +645,7 @@ class OrderBuildVisitor final : public VNVisitor {
nodep->unlinkFrBack();
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
// Calls to 'context' imported DPI function may call DPI exported functions
if (m_dpiExportTriggerVxp && nodep->funcp()->dpiImportWrapper()
&& nodep->funcp()->dpiContext()) {
@ -656,45 +656,45 @@ class OrderBuildVisitor final : public VNVisitor {
}
//--- Logic akin to SystemVerilog Processes (AstNodeProcedure)
virtual void visit(AstInitial* nodep) override { //
void visit(AstInitial* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstInitialAutomatic* nodep) override { //
void visit(AstInitialAutomatic* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstInitialStatic* nodep) override { //
void visit(AstInitialStatic* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstAlways* nodep) override { //
void visit(AstAlways* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstAlwaysPost* nodep) override {
void visit(AstAlwaysPost* nodep) override {
UASSERT_OBJ(!m_inPost, nodep, "Should not nest");
m_inPost = true;
iterateLogic(nodep);
m_inPost = false;
}
virtual void visit(AstAlwaysPostponed* nodep) override {
void visit(AstAlwaysPostponed* nodep) override {
UASSERT_OBJ(!m_inPostponed, nodep, "Should not nest");
m_inPostponed = true;
iterateLogic(nodep);
m_inPostponed = false;
}
virtual void visit(AstFinal* nodep) override { // LCOV_EXCL_START
void visit(AstFinal* nodep) override { // LCOV_EXCL_START
nodep->v3fatalSrc("AstFinal should have been removed already");
} // LCOV_EXCL_STOP
//--- Logic akin go SystemVerilog continuous assignments
virtual void visit(AstAssignAlias* nodep) override { //
void visit(AstAssignAlias* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
UASSERT_OBJ(!m_inClkAss, nodep, "Should not nest");
m_inClkAss = isClockerAssignment(nodep);
iterateLogic(nodep);
m_inClkAss = false;
}
virtual void visit(AstAssignPre* nodep) override {
void visit(AstAssignPre* nodep) override {
UASSERT_OBJ(!m_inClkAss && !m_inPre, nodep, "Should not nest");
m_inClkAss = isClockerAssignment(nodep);
m_inPre = true;
@ -702,7 +702,7 @@ class OrderBuildVisitor final : public VNVisitor {
m_inPre = false;
m_inClkAss = false;
}
virtual void visit(AstAssignPost* nodep) override {
void visit(AstAssignPost* nodep) override {
UASSERT_OBJ(!m_inClkAss && !m_inPost, nodep, "Should not nest");
m_inClkAss = isClockerAssignment(nodep);
m_inPost = true;
@ -712,21 +712,21 @@ class OrderBuildVisitor final : public VNVisitor {
}
//--- Verilator concoctions
virtual void visit(AstAlwaysPublic* nodep) override { //
void visit(AstAlwaysPublic* nodep) override { //
iterateLogic(nodep);
}
virtual void visit(AstCoverToggle* nodep) override { //
void visit(AstCoverToggle* nodep) override { //
iterateLogic(nodep);
}
//--- Ignored nodes
virtual void visit(AstVar*) override {}
virtual void visit(AstVarScope* nodep) override {}
virtual void visit(AstCell*) override {} // Only interested in the respective AstScope
virtual void visit(AstTypeTable*) override {}
virtual void visit(AstConstPool*) override {}
virtual void visit(AstClass*) override {}
virtual void visit(AstCFunc*) override {
void visit(AstVar*) override {}
void visit(AstVarScope* nodep) override {}
void visit(AstCell*) override {} // Only interested in the respective AstScope
void visit(AstTypeTable*) override {}
void visit(AstConstPool*) override {}
void visit(AstClass*) override {}
void visit(AstCFunc*) override {
// Calls to DPI exports handled with AstCCall. /* verilator public */ functions are
// ignored for now (and hence potentially mis-ordered), but could use the same or
// similar mechanism as DPI exports. Every other impure function (including those
@ -734,7 +734,7 @@ class OrderBuildVisitor final : public VNVisitor {
}
//---
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
// CONSTRUCTOR
explicit OrderBuildVisitor(AstNetlist* nodep) {
@ -981,15 +981,14 @@ public:
: m_pomGraphp{pomGraphp}
, m_pomWaitingp{pomWaitingp} {}
// METHODS
virtual OrderMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex*,
const AstScope* scopep,
const AstSenTree* domainp) override {
OrderMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex*,
const AstScope* scopep, const AstSenTree* domainp) override {
OrderMoveVertex* const resultp = new OrderMoveVertex(m_pomGraphp, lvertexp);
resultp->domScopep(OrderMoveDomScope::findCreate(domainp, scopep));
resultp->m_pomWaitingE.pushBack(*m_pomWaitingp, resultp);
return resultp;
}
virtual void freeVertexp(OrderMoveVertex* freeMep) override {
void freeVertexp(OrderMoveVertex* freeMep) override {
freeMep->m_pomWaitingE.unlink(*m_pomWaitingp, freeMep);
freeMep->unlinkDelete(m_pomGraphp);
}
@ -1005,18 +1004,14 @@ class OrderMTaskMoveVertexMaker final
public:
explicit OrderMTaskMoveVertexMaker(V3Graph* pomGraphp)
: m_pomGraphp{pomGraphp} {}
virtual MTaskMoveVertex* makeVertexp(OrderLogicVertex* lvertexp,
const OrderEitherVertex* varVertexp,
const AstScope* scopep,
const AstSenTree* domainp) override {
MTaskMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex* varVertexp,
const AstScope* scopep, const AstSenTree* domainp) override {
// Exclude initial/settle logic from the mtasks graph.
// We'll output time-zero logic separately.
if (domainp->hasInitial() || domainp->hasSettle()) return nullptr;
return new MTaskMoveVertex(m_pomGraphp, lvertexp, varVertexp, scopep, domainp);
}
virtual void freeVertexp(MTaskMoveVertex* freeMep) override {
freeMep->unlinkDelete(m_pomGraphp);
}
void freeVertexp(MTaskMoveVertex* freeMep) override { freeMep->unlinkDelete(m_pomGraphp); }
private:
VL_UNCOPYABLE(OrderMTaskMoveVertexMaker);

165
src/V3OrderGraph.h
View File

@ -112,9 +112,9 @@ inline bool operator==(OrderVEdgeType::en lhs, const OrderVEdgeType& rhs) {
class OrderGraph final : public V3Graph {
public:
OrderGraph() = default;
virtual ~OrderGraph() override = default;
~OrderGraph() override = default;
// Methods
virtual void loopsVertexCb(V3GraphVertex* vertexp) override;
void loopsVertexCb(V3GraphVertex* vertexp) override;
};
//######################################################################
@ -136,12 +136,12 @@ public:
: V3GraphVertex{graphp}
, m_scopep{scopep}
, m_domainp{domainp} {}
virtual ~OrderEitherVertex() override = default;
virtual OrderEitherVertex* clone(V3Graph* graphp) const override = 0;
~OrderEitherVertex() override = default;
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 override { return cvtToHex(m_scopep) + "_"; }
string dotName() const override { return cvtToHex(m_scopep) + "_"; }
// ACCESSORS
void domainp(AstSenTree* domainp) { m_domainp = domainp; }
AstScope* scopep() const { return m_scopep; }
@ -159,16 +159,16 @@ public:
: OrderEitherVertex{graphp, nullptr, domainp} {
isFromInput(true); // By definition
}
virtual ~OrderInputsVertex() override = default;
virtual OrderInputsVertex* clone(V3Graph* graphp) const override {
~OrderInputsVertex() override = default;
OrderInputsVertex* clone(V3Graph* graphp) const override {
return new OrderInputsVertex(graphp, *this);
}
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 string dotShape() const override { return "invhouse"; }
virtual bool domainMatters() override { return false; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_INPUTS; }
string name() const override { return "*INPUTS*"; }
string dotColor() const override { return "green"; }
string dotName() const override { return ""; }
string dotShape() const override { return "invhouse"; }
bool domainMatters() override { return false; }
};
class OrderLogicVertex final : public OrderEitherVertex {
@ -183,20 +183,18 @@ public:
OrderLogicVertex(V3Graph* graphp, AstScope* scopep, AstSenTree* domainp, AstNode* nodep)
: OrderEitherVertex{graphp, scopep, domainp}
, m_nodep{nodep} {}
virtual ~OrderLogicVertex() override = default;
virtual OrderLogicVertex* clone(V3Graph* graphp) const override {
~OrderLogicVertex() override = default;
OrderLogicVertex* clone(V3Graph* graphp) const override {
return new OrderLogicVertex(graphp, *this);
}
virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_LOGIC; }
virtual bool domainMatters() override { return true; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_LOGIC; }
bool domainMatters() override { return true; }
// ACCESSORS
virtual string name() const override {
string name() const override {
return (cvtToHex(m_nodep) + "\\n " + cvtToStr(nodep()->typeName()));
}
AstNode* nodep() const { return m_nodep; }
virtual string dotShape() const override {
return VN_IS(m_nodep, Active) ? "doubleoctagon" : "rect";
}
string dotShape() const override { return VN_IS(m_nodep, Active) ? "doubleoctagon" : "rect"; }
};
class OrderVarVertex VL_NOT_FINAL : public OrderEitherVertex {
@ -214,17 +212,17 @@ public:
OrderVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: OrderEitherVertex{graphp, scopep, nullptr}
, m_varScp{varScp} {}
virtual ~OrderVarVertex() override = default;
virtual OrderVarVertex* clone(V3Graph* graphp) const override = 0;
virtual OrderVEdgeType type() const override = 0;
virtual FileLine* fileline() const override { return varScp()->fileline(); }
~OrderVarVertex() override = default;
OrderVarVertex* clone(V3Graph* graphp) const override = 0;
OrderVEdgeType type() const override = 0;
FileLine* fileline() const override { return varScp()->fileline(); }
// ACCESSORS
AstVarScope* varScp() const { return m_varScp; }
void isClock(bool flag) { m_isClock = flag; }
bool isClock() const { return m_isClock; }
void isDelayed(bool flag) { m_isDelayed = flag; }
bool isDelayed() const { return m_isDelayed; }
virtual string dotShape() const override { return "ellipse"; }
string dotShape() const override { return "ellipse"; }
};
class OrderVarStdVertex final : public OrderVarVertex {
@ -234,16 +232,14 @@ class OrderVarStdVertex final : public OrderVarVertex {
public:
OrderVarStdVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: OrderVarVertex{graphp, scopep, varScp} {}
virtual ~OrderVarStdVertex() override = default;
virtual OrderVarStdVertex* clone(V3Graph* graphp) const override {
~OrderVarStdVertex() override = default;
OrderVarStdVertex* clone(V3Graph* graphp) const override {
return new OrderVarStdVertex(graphp, *this);
}
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 "grey"; }
virtual bool domainMatters() override { return true; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARSTD; }
string name() const override { return (cvtToHex(varScp()) + "\\n " + varScp()->name()); }
string dotColor() const override { return "grey"; }
bool domainMatters() override { return true; }
};
class OrderVarPreVertex final : public OrderVarVertex {
OrderVarPreVertex(V3Graph* graphp, const OrderVarPreVertex& old)
@ -252,16 +248,14 @@ class OrderVarPreVertex final : public OrderVarVertex {
public:
OrderVarPreVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: OrderVarVertex{graphp, scopep, varScp} {}
virtual ~OrderVarPreVertex() override = default;
virtual OrderVarPreVertex* clone(V3Graph* graphp) const override {
~OrderVarPreVertex() override = default;
OrderVarPreVertex* clone(V3Graph* graphp) const override {
return new OrderVarPreVertex(graphp, *this);
}
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 "green"; }
virtual bool domainMatters() override { return false; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPRE; }
string name() const override { return (cvtToHex(varScp()) + " PRE\\n " + varScp()->name()); }
string dotColor() const override { return "green"; }
bool domainMatters() override { return false; }
};
class OrderVarPostVertex final : public OrderVarVertex {
OrderVarPostVertex(V3Graph* graphp, const OrderVarPostVertex& old)
@ -270,16 +264,14 @@ class OrderVarPostVertex final : public OrderVarVertex {
public:
OrderVarPostVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: OrderVarVertex{graphp, scopep, varScp} {}
virtual OrderVarPostVertex* clone(V3Graph* graphp) const override {
OrderVarPostVertex* clone(V3Graph* graphp) const override {
return new OrderVarPostVertex(graphp, *this);
}
virtual OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPOST; }
virtual ~OrderVarPostVertex() override = default;
virtual string name() const override {
return (cvtToHex(varScp()) + " POST\\n " + varScp()->name());
}
virtual string dotColor() const override { return "red"; }
virtual bool domainMatters() override { return false; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPOST; }
~OrderVarPostVertex() override = default;
string name() const override { return (cvtToHex(varScp()) + " POST\\n " + varScp()->name()); }
string dotColor() const override { return "red"; }
bool domainMatters() override { return false; }
};
class OrderVarPordVertex final : public OrderVarVertex {
OrderVarPordVertex(V3Graph* graphp, const OrderVarPordVertex& old)
@ -288,16 +280,14 @@ class OrderVarPordVertex final : public OrderVarVertex {
public:
OrderVarPordVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
: OrderVarVertex{graphp, scopep, varScp} {}
virtual ~OrderVarPordVertex() override = default;
virtual OrderVarPordVertex* clone(V3Graph* graphp) const override {
~OrderVarPordVertex() override = default;
OrderVarPordVertex* clone(V3Graph* graphp) const override {
return new OrderVarPordVertex(graphp, *this);
}
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 "blue"; }
virtual bool domainMatters() override { return false; }
OrderVEdgeType type() const override { return OrderVEdgeType::VERTEX_VARPORD; }
string name() const override { return (cvtToHex(varScp()) + " PORD\\n " + varScp()->name()); }
string dotColor() const override { return "blue"; }
bool domainMatters() override { return false; }
};
//######################################################################
@ -324,28 +314,28 @@ public:
, m_logicp{logicp}
, m_state{POM_WAIT}
, m_domScopep{nullptr} {}
virtual ~OrderMoveVertex() override = default;
virtual OrderMoveVertex* clone(V3Graph* graphp) const override {
~OrderMoveVertex() override = default;
OrderMoveVertex* clone(V3Graph* graphp) const override {
v3fatalSrc("Unsupported");
return nullptr;
}
// METHODS
virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; }
virtual string dotColor() const override {
string dotColor() const override {
if (logicp()) {
return logicp()->dotColor();
} else {
return "";
}
}
virtual FileLine* fileline() const override {
FileLine* fileline() const override {
if (logicp()) {
return logicp()->fileline();
} else {
return nullptr;
}
}
virtual string name() const override {
string name() const override {
string nm;
if (VL_UNCOVERABLE(!logicp())) { // Avoid crash when debugging
nm = "nul"; // LCOV_EXCL_LINE
@ -394,20 +384,20 @@ public:
, m_domainp{domainp} {
UASSERT(!(logicp && varp), "MTaskMoveVertex: logicp and varp may not both be set!\n");
}
virtual ~MTaskMoveVertex() override = default;
virtual MTaskMoveVertex* clone(V3Graph* graphp) const override {
~MTaskMoveVertex() override = default;
MTaskMoveVertex* clone(V3Graph* graphp) const override {
v3fatalSrc("Unsupported");
return nullptr;
}
virtual OrderVEdgeType type() const { return OrderVEdgeType::VERTEX_MOVE; }
virtual string dotColor() const override {
string dotColor() const override {
if (logicp()) {
return logicp()->dotColor();
} else {
return "yellow";
}
}
virtual string name() const override {
string name() const override {
string nm;
if (logicp()) {
nm = logicp()->name();
@ -439,10 +429,9 @@ public:
OrderEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
bool cutable = false)
: V3GraphEdge{graphp, fromp, top, weight, cutable} {}
virtual ~OrderEdge() override = default;
~OrderEdge() override = default;
virtual OrderVEdgeType type() const { return OrderVEdgeType::EDGE_STD; }
virtual OrderEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
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
@ -466,14 +455,14 @@ class OrderComboCutEdge final : public OrderEdge {
public:
OrderComboCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: OrderEdge{graphp, fromp, top, WEIGHT_COMBO, CUTABLE} {}
virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_COMBOCUT; }
virtual ~OrderComboCutEdge() override = default;
virtual OrderComboCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_COMBOCUT; }
~OrderComboCutEdge() override = default;
OrderComboCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
return new OrderComboCutEdge(graphp, fromp, top, *this);
}
virtual string dotColor() const override { return "yellowGreen"; }
virtual bool followComboConnected() const override { return true; }
string dotColor() const override { return "yellowGreen"; }
bool followComboConnected() const override { return true; }
};
class OrderPostCutEdge final : public OrderEdge {
@ -487,14 +476,14 @@ class OrderPostCutEdge final : public OrderEdge {
public:
OrderPostCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: OrderEdge{graphp, fromp, top, WEIGHT_COMBO, CUTABLE} {}
virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_POSTCUT; }
virtual ~OrderPostCutEdge() override = default;
virtual OrderPostCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_POSTCUT; }
~OrderPostCutEdge() override = default;
OrderPostCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
return new OrderPostCutEdge(graphp, fromp, top, *this);
}
virtual string dotColor() const override { return "PaleGreen"; }
virtual bool followComboConnected() const override { return false; }
string dotColor() const override { return "PaleGreen"; }
bool followComboConnected() const override { return false; }
};
class OrderPreCutEdge final : public OrderEdge {
@ -508,14 +497,14 @@ class OrderPreCutEdge final : public OrderEdge {
public:
OrderPreCutEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: OrderEdge{graphp, fromp, top, WEIGHT_PRE, CUTABLE} {}
virtual OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_PRECUT; }
virtual OrderPreCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
OrderVEdgeType type() const override { return OrderVEdgeType::EDGE_PRECUT; }
OrderPreCutEdge* clone(V3Graph* graphp, V3GraphVertex* fromp,
V3GraphVertex* top) const override {
return new OrderPreCutEdge(graphp, fromp, top, *this);
}
virtual ~OrderPreCutEdge() override = default;
virtual string dotColor() const override { return "khaki"; }
virtual bool followComboConnected() const override { return false; }
~OrderPreCutEdge() override = default;
string dotColor() const override { return "khaki"; }
bool followComboConnected() const override { return false; }
};
#endif // Guard

30
src/V3Param.cpp
View File

@ -977,7 +977,7 @@ class ParamVisitor final : public VNVisitor {
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (nodep->recursiveClone()) nodep->dead(true); // Fake, made for recursive elimination
if (nodep->dead()) return; // Marked by LinkDot (and above)
@ -995,14 +995,14 @@ class ParamVisitor final : public VNVisitor {
}
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
visitCellOrClassRef(nodep, VN_IS(nodep->modp(), Iface));
}
virtual void visit(AstClassRefDType* nodep) override { visitCellOrClassRef(nodep, false); }
virtual void visit(AstClassOrPackageRef* nodep) override { visitCellOrClassRef(nodep, false); }
void visit(AstClassRefDType* nodep) override { visitCellOrClassRef(nodep, false); }
void visit(AstClassOrPackageRef* nodep) override { visitCellOrClassRef(nodep, false); }
// Make sure all parameters are constantified
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (nodep->user5SetOnce()) return; // Process once
iterateChildren(nodep);
if (nodep->isParam()) {
@ -1015,7 +1015,7 @@ class ParamVisitor final : public VNVisitor {
}
}
// Make sure varrefs cause vars to constify before things above
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Might jump across functions, so beware if ever add a m_funcp
if (nodep->varp()) iterate(nodep->varp());
}
@ -1036,7 +1036,7 @@ class ParamVisitor final : public VNVisitor {
}
return false;
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
// Check to see if the scope is just an interface because interfaces are special
const string dotted = nodep->dotted();
if (!dotted.empty() && nodep->varp() && nodep->varp()->isParam()) {
@ -1082,7 +1082,7 @@ class ParamVisitor final : public VNVisitor {
nodep->varp(nullptr); // Needs relink, as may remove pointed-to var
}
virtual void visit(AstUnlinkedRef* nodep) override {
void visit(AstUnlinkedRef* nodep) override {
AstVarXRef* const varxrefp = VN_CAST(nodep->op1p(), VarXRef);
AstNodeFTaskRef* const taskrefp = VN_CAST(nodep->op1p(), NodeFTaskRef);
if (varxrefp) {
@ -1103,7 +1103,7 @@ class ParamVisitor final : public VNVisitor {
nodep->replaceWith(nodep->op1p()->unlinkFrBack());
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
virtual void visit(AstCellArrayRef* nodep) override {
void visit(AstCellArrayRef* nodep) override {
V3Const::constifyParamsEdit(nodep->selp());
if (const AstConst* const constp = VN_CAST(nodep->selp(), Const)) {
const string index = AstNode::encodeNumber(constp->toSInt());
@ -1122,7 +1122,7 @@ class ParamVisitor final : public VNVisitor {
}
// Generate Statements
virtual void visit(AstGenIf* nodep) override {
void visit(AstGenIf* nodep) override {
UINFO(9, " GENIF " << nodep << endl);
iterateAndNextNull(nodep->condp());
// We suppress errors when widthing params since short-circuiting in
@ -1149,7 +1149,7 @@ class ParamVisitor final : public VNVisitor {
//! @todo Unlike generated IF, we don't have to worry about short-circuiting the conditional
//! expression, since this is currently restricted to simple comparisons. If we ever do
//! move to more generic constant expressions, such code will be needed here.
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
if (nodep->genforp()) {
AstGenFor* const forp = VN_AS(nodep->genforp(), GenFor);
UASSERT_OBJ(forp, nodep, "Non-GENFOR under generate-for BEGIN");
@ -1181,10 +1181,10 @@ class ParamVisitor final : public VNVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstGenFor* nodep) override { // LCOV_EXCL_LINE
void visit(AstGenFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("GENFOR should have been wrapped in BEGIN");
}
virtual void visit(AstGenCase* nodep) override {
void visit(AstGenCase* nodep) override {
UINFO(9, " GENCASE " << nodep << endl);
AstNode* keepp = nullptr;
iterateAndNextNull(nodep->exprp());
@ -1235,7 +1235,7 @@ class ParamVisitor final : public VNVisitor {
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1272,7 +1272,7 @@ public:
for (AstNodeModule* const modp : modps) netlistp->addModulep(modp);
}
}
virtual ~ParamVisitor() override = default;
~ParamVisitor() override = default;
VL_UNCOPYABLE(ParamVisitor);
};

16
src/V3Partition.cpp
View File

@ -253,7 +253,7 @@ public:
m_vertices.splice(m_vertices.end(), otherp->m_vertices);
m_cost += otherp->m_cost;
}
virtual const VxList* vertexListp() const override { return &m_vertices; }
const VxList* vertexListp() const override { return &m_vertices; }
static uint64_t incGeneration() {
static uint64_t s_generation = 0;
++s_generation;
@ -263,10 +263,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 override { return m_serialId; }
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 override { return m_cost; }
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) {
@ -319,7 +319,7 @@ public:
void checkRelativesCp(GraphWay way) const;
virtual string name() const override {
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;
@ -1850,7 +1850,7 @@ private:
// METHODS
VL_DEBUG_FUNC;
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (!m_tracingCall) return;
m_tracingCall = false;
if (nodep->dpiImportWrapper()) {
@ -1861,19 +1861,19 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
iterateChildren(nodep);
// Enter the function and trace it
m_tracingCall = true;
iterate(nodep->funcp());
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit DpiImportCallVisitor(AstNode* nodep) { iterate(nodep); }
bool hasDpiHazard() const { return m_hasDpiHazard; }
virtual ~DpiImportCallVisitor() override = default;
~DpiImportCallVisitor() override = default;
private:
VL_UNCOPYABLE(DpiImportCallVisitor);

14
src/V3PartitionGraph.h
View File

@ -32,7 +32,7 @@ class AbstractMTask VL_NOT_FINAL : public V3GraphVertex {
public:
explicit AbstractMTask(V3Graph* graphp)
: V3GraphVertex{graphp} {}
virtual ~AbstractMTask() override = default;
~AbstractMTask() override = default;
virtual uint32_t id() const = 0;
virtual uint32_t cost() const = 0;
};
@ -44,12 +44,12 @@ public:
// CONSTRUCTORS
explicit AbstractLogicMTask(V3Graph* graphp)
: AbstractMTask{graphp} {}
virtual ~AbstractLogicMTask() override = default;
~AbstractLogicMTask() override = default;
// METHODS
// Set of logic vertices in this mtask. Order is not significant.
virtual const VxList* vertexListp() const = 0;
virtual uint32_t id() const override = 0; // Unique id of this mtask.
virtual uint32_t cost() const override = 0;
uint32_t id() const override = 0; // Unique id of this mtask.
uint32_t cost() const override = 0;
};
class ExecMTask final : public AbstractMTask {
@ -72,10 +72,10 @@ public:
, m_bodyp{bodyp}
, m_id{id} {}
AstMTaskBody* bodyp() const { return m_bodyp; }
virtual uint32_t id() const override { return m_id; }
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 override { return m_cost; }
uint32_t cost() const override { return m_cost; }
void cost(uint32_t cost) { m_cost = cost; }
void predictStart(uint64_t time) { m_predictStart = time; }
uint64_t predictStart() const { return m_predictStart; }
@ -85,7 +85,7 @@ public:
// If this MTask maps to a C function, this should be the name
return std::string{"__Vmtask"} + "__" + cvtToStr(m_id);
}
virtual string name() const override { return std::string{"mt"} + cvtToStr(id()); }
string name() const override { return std::string{"mt"} + cvtToStr(id()); }
string hashName() const { return m_hashName; }
void hashName(const string& name) { m_hashName = name; }
void dump(std::ostream& str) const {

12
src/V3PreProc.cpp
View File

@ -250,13 +250,13 @@ public:
void candidateDefines(VSpellCheck* spellerp) override;
// METHODS, callbacks
virtual void comment(const string& text) override; // Comment detected (if keepComments==2)
virtual void include(const string& filename) override; // Request a include file be processed
virtual void undef(const string& name) override;
void comment(const string& text) override; // Comment detected (if keepComments==2)
void include(const string& filename) override; // Request a include file be processed
void undef(const string& name) override;
virtual void undefineall();
virtual void define(FileLine* fl, const string& name, const string& value,
const string& params, bool cmdline) override;
virtual string removeDefines(const string& text) override; // Remove defines in a text string
void define(FileLine* fl, const string& name, const string& value, const string& params,
bool cmdline) override;
string removeDefines(const string& text) override; // Remove defines in a text string
// CONSTRUCTORS
V3PreProcImp() {

46
src/V3Premit.cpp
View File

@ -151,11 +151,11 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_cfuncp);
{
m_cfuncp = nodep;
@ -167,7 +167,7 @@ private:
m_assignLhs = false;
if (m_cfuncp) m_stmtp = nodep;
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
UINFO(4, " WHILE " << nodep << endl);
startStatement(nodep);
iterateAndNextNull(nodep->precondsp());
@ -180,7 +180,7 @@ private:
iterateAndNextNull(nodep->incsp());
m_stmtp = nullptr;
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
startStatement(nodep);
{
bool noopt = false;
@ -207,7 +207,7 @@ private:
m_assignLhs = false;
m_stmtp = nullptr;
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -217,7 +217,7 @@ private:
iterateChildren(nodep);
m_stmtp = nullptr;
}
virtual void visit(AstTraceInc* nodep) override {
void visit(AstTraceInc* nodep) override {
startStatement(nodep);
m_inTracep = nodep;
iterateChildren(nodep);
@ -271,31 +271,31 @@ private:
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstShiftL* nodep) override { visitShift(nodep); }
virtual void visit(AstShiftR* nodep) override { visitShift(nodep); }
virtual void visit(AstShiftRS* nodep) override { visitShift(nodep); }
void visit(AstShiftL* nodep) override { visitShift(nodep); }
void visit(AstShiftR* nodep) override { visitShift(nodep); }
void visit(AstShiftRS* nodep) override { visitShift(nodep); }
// Operators
virtual void visit(AstNodeTermop* nodep) override {
void visit(AstNodeTermop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeUniop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstRand* nodep) override {
void visit(AstRand* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstUCFunc* nodep) override {
void visit(AstUCFunc* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
VL_RESTORER(m_assignLhs);
@ -305,7 +305,7 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
VL_RESTORER(m_assignLhs);
@ -314,7 +314,7 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstAssocSel* nodep) override {
void visit(AstAssocSel* nodep) override {
iterateAndNextNull(nodep->fromp());
{ // Only the 'from' is part of the assignment LHS
VL_RESTORER(m_assignLhs);
@ -323,11 +323,11 @@ private:
}
checkNode(nodep);
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
iterateChildren(nodep);
checkNode(nodep);
}
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
iterateChildren(nodep);
if (nodep->expr1p()->isWide() && !VN_IS(nodep->condp(), Const)
&& !VN_IS(nodep->condp(), VarRef)) {
@ -339,7 +339,7 @@ private:
}
// Autoflush
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
startStatement(nodep);
iterateChildren(nodep);
m_stmtp = nullptr;
@ -356,7 +356,7 @@ private:
}
}
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
iterateChildren(nodep);
// Any strings sent to a display must be var of string data type,
// to avoid passing a pointer to a temporary.
@ -370,8 +370,8 @@ private:
//--------------------
// Default: Just iterate
virtual void visit(AstVar*) override {} // Don't hit varrefs under vars
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Don't hit varrefs under vars
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS

8
src/V3ProtectLib.cpp
View File

@ -64,7 +64,7 @@ private:
bool m_hasClk = false; // True if the top module has sequential logic
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
m_vfilep
= new AstVFile{nodep->fileline(), v3Global.opt.makeDir() + "/" + m_libName + ".sv"};
nodep->addFilesp(m_vfilep);
@ -74,7 +74,7 @@ private:
iterateChildren(nodep);
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (!nodep->isTop()) {
return;
} else {
@ -422,7 +422,7 @@ private:
m_cfilep->tblockp(txtp);
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (!nodep->isIO()) return;
if (nodep->direction() == VDirection::INPUT) {
if (nodep->isUsedClock() || nodep->attrClocker() == VVarAttrClocker::CLOCKER_YES) {
@ -439,7 +439,7 @@ private:
}
}
virtual void visit(AstNode*) override {}
void visit(AstNode*) override {}
string cInputConnection(AstVar* varp) {
return V3Task::assignDpiToInternal("handlep__V->" + varp->name(), varp);

14
src/V3Randomize.cpp
View File

@ -82,7 +82,7 @@ private:
}
// VISITORS
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
iterateChildren(nodep);
if (nodep->extendsp()) {
// Save pointer to derived class
@ -90,7 +90,7 @@ private:
m_baseToDerivedMap[basep].insert(nodep);
}
}
virtual void visit(AstMethodCall* nodep) override {
void visit(AstMethodCall* nodep) override {
iterateChildren(nodep);
if (nodep->name() != "randomize") return;
if (const AstClassRefDType* const classRefp
@ -100,7 +100,7 @@ private:
markMembers(classp);
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -108,7 +108,7 @@ public:
iterate(nodep);
markAllDerived();
}
virtual ~RandomizeMarkVisitor() override = default;
~RandomizeMarkVisitor() override = default;
};
//######################################################################
@ -199,7 +199,7 @@ private:
}
// VISITORS
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
iterateChildren(nodep);
if (!nodep->user1()) return; // Doesn't need randomize, or already processed
UINFO(9, "Define randomize() for " << nodep << endl);
@ -241,12 +241,12 @@ private:
}
nodep->user1(false);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit RandomizeVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~RandomizeVisitor() override = default;
~RandomizeVisitor() override = default;
};
//######################################################################

12
src/V3Reloop.cpp
View File

@ -151,7 +151,7 @@ private:
}
// VISITORS
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
VL_RESTORER(m_cfuncp);
{
m_cfuncp = nodep;
@ -159,7 +159,7 @@ private:
mergeEnd(); // Finish last pending merge, if any
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (!m_cfuncp) return;
// Left select WordSel or ArraySel
@ -250,14 +250,14 @@ private:
UINFO(9, "Start merge i=" << lindex << " o=" << m_mgOffset << nodep << endl);
}
//--------------------
virtual void visit(AstVar*) override {} // Accelerate
virtual void visit(AstNodeMath*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar*) override {} // Accelerate
void visit(AstNodeMath*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ReloopVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ReloopVisitor() override {
~ReloopVisitor() override {
V3Stats::addStat("Optimizations, Reloops", m_statReloops);
V3Stats::addStat("Optimizations, Reloop iterations", m_statReItems);
}

66
src/V3Scope.cpp
View File

@ -81,7 +81,7 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
AstNodeModule* const modp = nodep->topModulep();
if (!modp) {
nodep->v3error("No top level module found");
@ -93,7 +93,7 @@ private:
iterate(modp);
cleanupVarRefs();
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
// Create required blocks and add to module
string scopename;
if (!m_aboveScopep) {
@ -144,7 +144,7 @@ private:
// ***Note m_scopep is passed back to the caller of the routine (above)
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
// Create required blocks and add to module
VL_RESTORER(m_scopep);
VL_RESTORER(m_aboveCellp);
@ -177,13 +177,13 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstCellInline* nodep) override { //
void visit(AstCellInline* nodep) override { //
nodep->scopep(m_scopep);
}
virtual void visit(AstActive* nodep) override { // LCOV_EXCL_LINE
void visit(AstActive* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc("Actives now made after scoping");
}
virtual void visit(AstNodeProcedure* nodep) override {
void visit(AstNodeProcedure* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -191,7 +191,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignAlias* nodep) override {
void visit(AstAssignAlias* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -199,7 +199,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignVarScope* nodep) override {
void visit(AstAssignVarScope* nodep) override {
// Copy under the scope but don't recurse
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -207,7 +207,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -215,7 +215,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -223,7 +223,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstCoverToggle* nodep) override {
void visit(AstCoverToggle* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " Move " << nodep << endl);
AstNode* const clonep = nodep->cloneTree(false);
@ -231,7 +231,7 @@ private:
m_scopep->addActivep(clonep);
iterateChildren(clonep); // We iterate under the *clone*
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " CFUNC " << nodep << endl);
AstCFunc* const clonep = nodep->cloneTree(false);
@ -241,7 +241,7 @@ private:
// We iterate under the *clone*
iterateChildren(clonep);
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
// Add to list of blocks under this scope
UINFO(4, " FTASK " << nodep << endl);
AstNodeFTask* clonep;
@ -257,7 +257,7 @@ private:
// We iterate under the *clone*
iterateChildren(clonep);
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
// Make new scope variable
if (!nodep->user1p()) {
AstVarScope* const varscp = new AstVarScope(nodep->fileline(), m_scopep, nodep);
@ -275,7 +275,7 @@ private:
m_scopep->addVarp(varscp);
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// VarRef needs to point to VarScope
// Make sure variable has made user1p.
UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@ -289,7 +289,7 @@ private:
m_varRefScopes.emplace(nodep, m_scopep);
}
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
// If there's a %m in the display text, we add a special node that will contain the name()
const string prefix = std::string{"__DOT__"} + m_scopep->name();
// TOP and above will be the user's name().
@ -305,17 +305,17 @@ private:
if (afterp) nodep->scopeEntrp(afterp);
iterateChildren(nodep);
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// Scope that was made by this module for different cell;
// Want to ignore blocks under it, so just do nothing
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ScopeVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ScopeVisitor() override = default;
~ScopeVisitor() override = default;
};
//######################################################################
@ -330,7 +330,7 @@ private:
VL_DEBUG_FUNC; // Declare debug()
// VISITORS
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// Want to ignore blocks under it
VL_RESTORER(m_scopep);
{
@ -351,20 +351,20 @@ private:
}
}
virtual void visit(AstNodeProcedure* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignAlias* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignVarScope* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAssignW* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstAlwaysPublic* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstCoverToggle* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstNodeFTask* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstCFunc* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstNodeProcedure* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstAssignAlias* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstAssignVarScope* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstAssignW* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstAlwaysPublic* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstCoverToggle* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstNodeFTask* nodep) override { movedDeleteOrIterate(nodep); }
void visit(AstCFunc* nodep) override { movedDeleteOrIterate(nodep); }
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
// The crossrefs are dealt with in V3LinkDot
nodep->varp(nullptr);
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
// The crossrefs are dealt with in V3LinkDot
UINFO(9, " Old pkg-taskref " << nodep << endl);
if (nodep->classOrPackagep()) {
@ -380,7 +380,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstModportFTaskRef* nodep) override {
void visit(AstModportFTaskRef* nodep) override {
// The modport persists only for xml dump
// The crossrefs are dealt with in V3LinkDot
nodep->ftaskp(nullptr);
@ -388,12 +388,12 @@ private:
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit ScopeCleanupVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ScopeCleanupVisitor() override = default;
~ScopeCleanupVisitor() override = default;
};
//######################################################################

72
src/V3Simulate.h
View File

@ -397,15 +397,15 @@ private:
}
// VISITORS
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstSenTree* nodep) override {
void visit(AstSenTree* nodep) override {
// Sensitivities aren't inputs per se; we'll keep our tree under the same sens.
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
UASSERT_OBJ(nodep->varp(), nodep, "Unlinked");
@ -473,7 +473,7 @@ private:
}
}
}
virtual void visit(AstVarXRef* nodep) override {
void visit(AstVarXRef* nodep) override {
if (jumpingOver(nodep)) return;
if (m_scoped) {
badNodeType(nodep);
@ -483,7 +483,7 @@ private:
"allowed in constant functions");
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
if (jumpingOver(nodep)) return;
if (!m_params) {
badNodeType(nodep);
@ -503,7 +503,7 @@ private:
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
if (jumpingOver(nodep)) return;
UINFO(5, " IF " << nodep << endl);
checkNodeInfo(nodep);
@ -520,15 +520,15 @@ private:
}
}
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
checkNodeInfo(nodep);
if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
}
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
checkNodeInfo(nodep);
if (!m_checkOnly && optimizable()) newValue(nodep, nodep);
}
virtual void visit(AstEnumItemRef* nodep) override {
void visit(AstEnumItemRef* nodep) override {
checkNodeInfo(nodep);
UASSERT_OBJ(nodep->itemp(), nodep, "Not linked");
if (!m_checkOnly && optimizable()) {
@ -541,7 +541,7 @@ private:
}
}
}
virtual void visit(AstNodeUniop* nodep) override {
void visit(AstNodeUniop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -549,7 +549,7 @@ private:
nodep->numberOperate(newConst(nodep)->num(), fetchConst(nodep->lhsp())->num());
}
}
virtual void visit(AstNodeBiop* nodep) override {
void visit(AstNodeBiop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -558,7 +558,7 @@ private:
fetchConst(nodep->rhsp())->num());
}
}
virtual void visit(AstNodeTriop* nodep) override {
void visit(AstNodeTriop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -568,7 +568,7 @@ private:
fetchConst(nodep->thsp())->num());
}
}
virtual void visit(AstNodeQuadop* nodep) override {
void visit(AstNodeQuadop* nodep) override {
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
iterateChildren(nodep);
@ -579,7 +579,7 @@ private:
fetchConst(nodep->fhsp())->num());
}
}
virtual void visit(AstLogAnd* nodep) override {
void visit(AstLogAnd* nodep) override {
// Need to short circuit
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -597,7 +597,7 @@ private:
}
}
}
virtual void visit(AstLogOr* nodep) override {
void visit(AstLogOr* nodep) override {
// Need to short circuit
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -615,7 +615,7 @@ private:
}
}
}
virtual void visit(AstLogIf* nodep) override {
void visit(AstLogIf* nodep) override {
// Need to short circuit, same as (!A || B)
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -635,7 +635,7 @@ private:
}
}
}
virtual void visit(AstNodeCond* nodep) override {
void visit(AstNodeCond* nodep) override {
// We could use above visit(AstNodeTriop), but need to do short circuiting.
// It's also slower even O(n^2) to evaluate both sides when we
// really only need to evaluate one side.
@ -755,7 +755,7 @@ private:
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -795,7 +795,7 @@ private:
}
m_inDlyAssign = false;
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
checkNodeInfo(nodep);
iterateChildren(nodep);
if (AstInitArray* const initp = VN_CAST(fetchValueNull(nodep->fromp()), InitArray)) {
@ -812,11 +812,11 @@ private:
clearOptimizable(nodep, "Array select of non-array");
}
}
virtual void visit(AstBegin* nodep) override {
void visit(AstBegin* nodep) override {
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstNodeCase* nodep) override {
void visit(AstNodeCase* nodep) override {
if (jumpingOver(nodep)) return;
UINFO(5, " CASE " << nodep << endl);
checkNodeInfo(nodep);
@ -854,20 +854,20 @@ private:
}
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
// Real handling is in AstNodeCase
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
iterateChildren(nodep);
}
virtual void visit(AstComment*) override {}
void visit(AstComment*) override {}
virtual void visit(AstJumpBlock* nodep) override {
void visit(AstJumpBlock* nodep) override {
if (jumpingOver(nodep)) return;
iterateChildren(nodep);
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
if (jumpingOver(nodep)) return;
checkNodeInfo(nodep);
if (!m_checkOnly) {
@ -875,7 +875,7 @@ private:
m_jumpp = nodep;
}
}
virtual void visit(AstJumpLabel* nodep) override {
void visit(AstJumpLabel* nodep) override {
// This only supports forward jumps. That's all we make at present,
// AstJumpGo::broken uses brokeExistsBelow() to check this.
if (jumpingOver(nodep)) return;
@ -886,7 +886,7 @@ private:
m_jumpp = nullptr;
}
}
virtual void visit(AstStop* nodep) override {
void visit(AstStop* nodep) override {
if (jumpingOver(nodep)) return;
if (m_params) { // This message seems better than an obscure $stop
// The spec says $stop is just ignored, it seems evil to ignore assertions
@ -897,7 +897,7 @@ private:
checkNodeInfo(nodep);
}
virtual void visit(AstNodeFor* nodep) override {
void visit(AstNodeFor* nodep) override {
// Doing lots of Whiles is slow, so only for parameters
UINFO(5, " FOR " << nodep << endl);
if (!m_params) {
@ -929,7 +929,7 @@ private:
}
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
// Doing lots of Whiles is slow, so only for parameters
if (jumpingOver(nodep)) return;
UINFO(5, " WHILE " << nodep << endl);
@ -969,7 +969,7 @@ private:
}
}
virtual void visit(AstFuncRef* nodep) override {
void visit(AstFuncRef* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
UINFO(5, " FUNCREF " << nodep << endl);
@ -1041,7 +1041,7 @@ private:
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (jumpingOver(nodep)) return;
if (!m_params) {
badNodeType(nodep);
@ -1049,12 +1049,12 @@ private:
}
}
virtual void visit(AstScopeName* nodep) override {
void visit(AstScopeName* nodep) override {
if (jumpingOver(nodep)) return;
// Ignore
}
virtual void visit(AstSFormatF* nodep) override {
void visit(AstSFormatF* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
checkNodeInfo(nodep);
@ -1108,7 +1108,7 @@ private:
}
}
virtual void visit(AstDisplay* nodep) override {
void visit(AstDisplay* nodep) override {
if (jumpingOver(nodep)) return;
if (!optimizable()) return; // Accelerate
// We ignore isPredictOptimizable as $display is often in constant
@ -1133,7 +1133,7 @@ private:
// These types are definitely not reducible
// AstCoverInc, AstFinish,
// AstRand, AstTime, AstUCFunc, AstCCall, AstCStmt, AstUCStmt
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (jumpingOver(nodep)) return;
badNodeType(nodep);
}
@ -1188,7 +1188,7 @@ public:
setMode(false /*scoped*/, false /*checking*/, true /*params*/);
mainGuts(nodep);
}
virtual ~SimulateVisitor() override {
~SimulateVisitor() override {
for (const auto& pair : m_constps) {
for (AstConst* const constp : pair.second) { delete constp; }
}

16
src/V3Slice.cpp
View File

@ -128,7 +128,7 @@ class SliceVisitor final : public VNVisitor {
return newp;
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// Called recursively on newly created assignments
if (!nodep->user1() && !VN_IS(nodep, AssignAlias)) {
nodep->user1(true);
@ -162,7 +162,7 @@ class SliceVisitor final : public VNVisitor {
}
}
virtual void visit(AstInitArray* nodep) override {
void visit(AstInitArray* nodep) override {
UASSERT_OBJ(!m_assignp, nodep, "Array initialization should have been removed earlier");
}
@ -221,17 +221,17 @@ class SliceVisitor final : public VNVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstEq* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNeq* nodep) override { expandBiOp(nodep); }
virtual void visit(AstEqCase* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNeqCase* nodep) override { expandBiOp(nodep); }
void visit(AstEq* nodep) override { expandBiOp(nodep); }
void visit(AstNeq* nodep) override { expandBiOp(nodep); }
void visit(AstEqCase* nodep) override { expandBiOp(nodep); }
void visit(AstNeqCase* nodep) override { expandBiOp(nodep); }
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit SliceVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~SliceVisitor() override = default;
~SliceVisitor() override = default;
};
//######################################################################

116
src/V3Split.cpp
View File

@ -103,14 +103,12 @@ protected:
SplitNodeVertex(V3Graph* graphp, AstNode* nodep)
: V3GraphVertex{graphp}
, m_nodep{nodep} {}
virtual ~SplitNodeVertex() override = default;
~SplitNodeVertex() override = default;
// 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 override {
return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName();
}
virtual FileLine* fileline() const override { return nodep()->fileline(); }
string name() const override { return cvtToHex(m_nodep) + ' ' + m_nodep->prettyTypeName(); }
FileLine* fileline() const override { return nodep()->fileline(); }
public:
virtual AstNode* nodep() const { return m_nodep; }
@ -120,34 +118,34 @@ class SplitPliVertex final : public SplitNodeVertex {
public:
explicit SplitPliVertex(V3Graph* graphp, AstNode* nodep)
: SplitNodeVertex{graphp, nodep} {}
virtual ~SplitPliVertex() override = default;
virtual string name() const override { return "*PLI*"; }
virtual string dotColor() const override { return "green"; }
~SplitPliVertex() override = default;
string name() const override { return "*PLI*"; }
string dotColor() const override { return "green"; }
};
class SplitLogicVertex final : public SplitNodeVertex {
public:
SplitLogicVertex(V3Graph* graphp, AstNode* nodep)
: SplitNodeVertex{graphp, nodep} {}
virtual ~SplitLogicVertex() override = default;
virtual string dotColor() const override { return "yellow"; }
~SplitLogicVertex() override = default;
string dotColor() const override { return "yellow"; }
};
class SplitVarStdVertex final : public SplitNodeVertex {
public:
SplitVarStdVertex(V3Graph* graphp, AstNode* nodep)
: SplitNodeVertex{graphp, nodep} {}
virtual ~SplitVarStdVertex() override = default;
virtual string dotColor() const override { return "skyblue"; }
~SplitVarStdVertex() override = default;
string dotColor() const override { return "skyblue"; }
};
class SplitVarPostVertex final : public SplitNodeVertex {
public:
SplitVarPostVertex(V3Graph* graphp, AstNode* nodep)
: SplitNodeVertex{graphp, nodep} {}
virtual ~SplitVarPostVertex() override = default;
virtual string name() const override { return string("POST ") + SplitNodeVertex::name(); }
virtual string dotColor() const override { return "CadetBlue"; }
~SplitVarPostVertex() override = default;
string name() const override { return string("POST ") + SplitNodeVertex::name(); }
string dotColor() const override { return "CadetBlue"; }
};
//######################################################################
@ -161,7 +159,7 @@ protected:
SplitEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top, int weight,
bool cutable = CUTABLE)
: V3GraphEdge{graphp, fromp, top, weight, cutable} {}
virtual ~SplitEdge() override = default;
~SplitEdge() override = default;
public:
// Iterator for graph functions
@ -180,7 +178,7 @@ public:
if (!oedgep) v3fatalSrc("Following edge of non-SplitEdge type");
return (!oedgep->ignoreThisStep());
}
virtual string dotStyle() const override {
string dotStyle() const override {
return ignoreThisStep() ? "dotted" : V3GraphEdge::dotStyle();
}
};
@ -190,36 +188,36 @@ class SplitPostEdge final : public SplitEdge {
public:
SplitPostEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
virtual ~SplitPostEdge() override = default;
virtual bool followScoreboard() const override { return false; }
virtual string dotColor() const override { return "khaki"; }
~SplitPostEdge() override = default;
bool followScoreboard() const override { return false; }
string dotColor() const override { return "khaki"; }
};
class SplitLVEdge final : public SplitEdge {
public:
SplitLVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
virtual ~SplitLVEdge() override = default;
virtual bool followScoreboard() const override { return true; }
virtual string dotColor() const override { return "yellowGreen"; }
~SplitLVEdge() override = default;
bool followScoreboard() const override { return true; }
string dotColor() const override { return "yellowGreen"; }
};
class SplitRVEdge final : public SplitEdge {
public:
SplitRVEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: SplitEdge{graphp, fromp, top, WEIGHT_NORMAL} {}
virtual ~SplitRVEdge() override = default;
virtual bool followScoreboard() const override { return true; }
virtual string dotColor() const override { return "green"; }
~SplitRVEdge() override = default;
bool followScoreboard() const override { return true; }
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() override = default;
virtual bool followScoreboard() const override { return true; }
virtual string dotColor() const override { return "blue"; }
~SplitScorebdEdge() override = default;
bool followScoreboard() const override { return true; }
string dotColor() const override { return "blue"; }
};
struct SplitStrictEdge : public SplitEdge {
@ -228,9 +226,9 @@ struct SplitStrictEdge : public SplitEdge {
public:
SplitStrictEdge(V3Graph* graphp, V3GraphVertex* fromp, V3GraphVertex* top)
: SplitEdge{graphp, fromp, top, WEIGHT_NORMAL, NOT_CUTABLE} {}
virtual ~SplitStrictEdge() override = default;
virtual bool followScoreboard() const override { return true; }
virtual string dotColor() const override { return "blue"; }
~SplitStrictEdge() override = default;
bool followScoreboard() const override { return true; }
string dotColor() const override { return "blue"; }
};
//######################################################################
@ -259,7 +257,7 @@ protected:
// CONSTRUCTORS
public:
SplitReorderBaseVisitor() { scoreboardClear(); }
virtual ~SplitReorderBaseVisitor() override = default;
~SplitReorderBaseVisitor() override = default;
// METHODS
protected:
@ -335,19 +333,19 @@ protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) = 0;
// VISITORS
virtual void visit(AstAlways* nodep) override = 0;
virtual void visit(AstNodeIf* nodep) override = 0;
void visit(AstAlways* nodep) override = 0;
void visit(AstNodeIf* nodep) override = 0;
// We don't do AstNodeFor/AstWhile loops, due to the standard question
// of what is before vs. after
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
m_inDly = true;
UINFO(4, " ASSIGNDLY " << nodep << endl);
iterateChildren(nodep);
m_inDly = false;
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (!m_stmtStackps.empty()) {
AstVarScope* const vscp = nodep->varScopep();
UASSERT_OBJ(vscp, nodep, "Not linked");
@ -410,7 +408,7 @@ protected:
}
}
virtual void visit(AstJumpGo* nodep) override {
void visit(AstJumpGo* nodep) override {
// Jumps will disable reordering at all levels
// This is overly pessimistic; we could treat jumps as barriers, and
// reorder everything between jumps/labels, however jumps are rare
@ -422,7 +420,7 @@ protected:
//--------------------
// Default
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// **** SPECIAL default type that sets PLI_ORDERING
if (!m_stmtStackps.empty() && !nodep->isPure()) {
UINFO(9, " NotSplittable " << nodep << endl);
@ -439,11 +437,11 @@ class ReorderVisitor final : public SplitReorderBaseVisitor {
// CONSTRUCTORS
public:
explicit ReorderVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~ReorderVisitor() override = default;
~ReorderVisitor() override = default;
// METHODS
protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
for (SplitLogicVertex* vxp : m_stmtStackps) new SplitRVEdge(&m_graph, vxp, vstdp);
}
@ -599,7 +597,7 @@ protected:
firstp->user3p(oldBlockUser3);
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
UINFO(4, " ALW " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, " alwIn:: ");
scoreboardClear();
@ -607,7 +605,7 @@ protected:
if (debug() >= 9) nodep->dumpTree(cout, " alwOut: ");
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
iterateAndNextNull(nodep->condp());
processBlock(nodep->ifsp());
@ -636,7 +634,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() override = default;
~IfColorVisitor() override = default;
// METHODS
const ColorSet& colors() const { return m_colors; }
@ -663,13 +661,13 @@ private:
}
protected:
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
m_ifStack.push_back(nodep);
trackNode(nodep);
iterateChildren(nodep);
m_ifStack.pop_back();
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
trackNode(nodep);
iterateChildren(nodep);
}
@ -701,7 +699,7 @@ public:
UINFO(6, " splitting always " << nodep << endl);
}
virtual ~EmitSplitVisitor() override = default;
~EmitSplitVisitor() override = default;
// METHODS
void go() {
@ -732,7 +730,7 @@ protected:
return new AstSplitPlaceholder(m_origAlwaysp->fileline());
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
// Anything that's not an if/else we assume is a leaf
// (that is, something we won't split.) Don't visit further
// into the leaf.
@ -754,7 +752,7 @@ protected:
m_addAfter[color] = clonedp;
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
const ColorSet& colors = m_ifColorp->colors(nodep);
using CloneMap = std::unordered_map<uint32_t, AstNodeIf*>;
CloneMap clones;
@ -798,17 +796,17 @@ class RemovePlaceholdersVisitor final : public VNVisitor {
// CONSTRUCTORS
RemovePlaceholdersVisitor() = default;
virtual ~RemovePlaceholdersVisitor() override = default;
~RemovePlaceholdersVisitor() override = default;
// VISITORS
virtual void visit(AstSplitPlaceholder* nodep) override { pushDeletep(nodep->unlinkFrBack()); }
virtual void visit(AstNodeIf* nodep) override {
void visit(AstSplitPlaceholder* nodep) override { pushDeletep(nodep->unlinkFrBack()); }
void visit(AstNodeIf* nodep) override {
VL_RESTORER(m_isPure);
m_isPure = true;
iterateChildren(nodep);
if (!nodep->ifsp() && !nodep->elsesp() && m_isPure) pushDeletep(nodep->unlinkFrBack());
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
VL_RESTORER(m_isPure);
m_isPure = true;
iterateChildren(nodep);
@ -828,7 +826,7 @@ class RemovePlaceholdersVisitor final : public VNVisitor {
}
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
m_isPure &= nodep->isPure();
iterateChildren(nodep); // must visit regardless of m_isPure to remove placeholders
}
@ -875,13 +873,11 @@ public:
}
}
virtual ~SplitVisitor() override {
V3Stats::addStat("Optimizations, Split always", m_statSplits);
}
~SplitVisitor() override { V3Stats::addStat("Optimizations, Split always", m_statSplits); }
// METHODS
protected:
virtual void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
void makeRvalueEdges(SplitVarStdVertex* vstdp) override {
// Each 'if' depends on rvalues in its own conditional ONLY,
// not rvalues in the if/else bodies.
for (auto it = m_stmtStackps.cbegin(); it != m_stmtStackps.cend(); ++it) {
@ -956,7 +952,7 @@ protected:
if (debug() >= 9) m_graph.dumpDotFilePrefixed("splitg_colored", false);
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
// build the scoreboard
scoreboardClear();
scanBlock(nodep->bodysp());
@ -988,7 +984,7 @@ protected:
emitSplit.go();
}
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
UINFO(4, " IF " << nodep << endl);
m_curIfConditional = nodep;
iterateAndNextNull(nodep->condp());

22
src/V3SplitAs.cpp
View File

@ -49,17 +49,17 @@ private:
AstVarScope* m_splitVscp = nullptr; // Variable we want to split
// METHODS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->access().isWriteOrRW() && !m_splitVscp && nodep->varp()->attrIsolateAssign()) {
m_splitVscp = nodep->varScopep();
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit SplitAsFindVisitor(AstAlways* nodep) { iterate(nodep); }
virtual ~SplitAsFindVisitor() override = default;
~SplitAsFindVisitor() override = default;
// METHODS
AstVarScope* splitVscp() const { return m_splitVscp; }
};
@ -76,7 +76,7 @@ private:
bool m_matches = false; // Statement below has matching lvalue reference
// METHODS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (nodep->access().isWriteOrRW()) {
if (nodep->varScopep() == m_splitVscp) {
UINFO(6, " CL VAR " << nodep << endl);
@ -84,7 +84,7 @@ private:
}
}
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -110,7 +110,7 @@ private:
m_keepStmt = oldKeep || m_keepStmt;
UINFO(9, " upKeep=" << m_keepStmt << " STMT " << nodep << endl);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -119,7 +119,7 @@ public:
, m_modeMatch{modeMatch} {
iterate(nodep);
}
virtual ~SplitAsCleanVisitor() override = default;
~SplitAsCleanVisitor() override = default;
};
//######################################################################
@ -154,7 +154,7 @@ private:
}
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
// Are there any lvalue references below this?
// There could be more than one. So, we process the first one found first.
const AstVarScope* lastSplitVscp = nullptr;
@ -179,13 +179,13 @@ private:
}
// Speedup; no always under math
virtual void visit(AstNodeMath*) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeMath*) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit SplitAsVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~SplitAsVisitor() override {
~SplitAsVisitor() override {
V3Stats::addStat("Optimizations, isolate_assignments blocks", m_statSplits);
}
};

46
src/V3SplitVar.cpp
View File

@ -362,10 +362,10 @@ public:
void remove(AstNode* nodep) {
struct Visitor : public VNVisitor {
RefsInModule& m_parent;
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
virtual void visit(AstVarRef* nodep) override { m_parent.m_refs.erase(nodep); }
virtual void visit(AstSel* nodep) override {
void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstVar* nodep) override { m_parent.m_vars.erase(nodep); }
void visit(AstVarRef* nodep) override { m_parent.m_refs.erase(nodep); }
void visit(AstSel* nodep) override {
m_parent.m_sels.erase(nodep);
iterateChildren(nodep);
}
@ -456,8 +456,8 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
return refp;
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeModule* nodep) override {
UINFO(4, "Start checking " << nodep->prettyNameQ() << "\n");
if (!VN_IS(nodep, Module)) {
UINFO(4, "Skip " << nodep->prettyNameQ() << "\n");
@ -471,9 +471,9 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
split();
m_modp = nullptr;
}
virtual void visit(AstNodeStmt* nodep) override { setContextAndIterateChildren(nodep); }
virtual void visit(AstCell* nodep) override { setContextAndIterateChildren(nodep); }
virtual void visit(AstAlways* nodep) override {
void visit(AstNodeStmt* nodep) override { setContextAndIterateChildren(nodep); }
void visit(AstCell* nodep) override { setContextAndIterateChildren(nodep); }
void visit(AstAlways* nodep) override {
if (nodep->sensesp()) { // When visiting sensitivity list, always is the context
setContextAndIterate(nodep, nodep->sensesp());
}
@ -481,7 +481,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
iterate(bodysp);
}
};
virtual void visit(AstAlwaysPublic* nodep) override {
void visit(AstAlwaysPublic* nodep) override {
if (nodep->sensesp()) { // When visiting sensitivity list, always is the context
setContextAndIterate(nodep, nodep->sensesp());
}
@ -489,7 +489,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
iterate(bodysp);
}
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
VL_RESTORER(m_contextp);
{
m_contextp = nodep;
@ -524,7 +524,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
}
}
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
UINFO(5, nodep->modVarp()->prettyNameQ() << " pin \n");
AstNode* const exprp = nodep->exprp();
if (!exprp) return; // Not connected pin
@ -538,7 +538,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
m_foundTargetVar.clear();
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
UASSERT_OBJ(!m_inFTask, nodep, "Nested func/task");
if (!cannotSplitTaskReason(nodep)) {
m_inFTask = nodep;
@ -546,7 +546,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
m_inFTask = nullptr;
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (!nodep->attrSplitVar()) return; // Nothing to do
if (!cannotSplitReason(nodep)) {
m_refs.registerVar(nodep);
@ -554,18 +554,18 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
}
m_refsForPackedSplit[m_modp].add(nodep);
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (!nodep->varp()->attrSplitVar()) return; // Nothing to do
if (m_refs.tryAdd(m_contextp, nodep, m_inFTask)) {
m_foundTargetVar.insert(nodep->varp());
}
m_refsForPackedSplit[m_modp].add(nodep);
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
if (VN_IS(nodep->fromp(), VarRef)) m_refsForPackedSplit[m_modp].add(nodep);
iterateChildren(nodep);
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
if (AstVarRef* const refp = isTargetVref(nodep->fromp())) {
const AstConst* const indexp = VN_CAST(nodep->bitp(), Const);
if (indexp) { // OK
@ -585,7 +585,7 @@ class SplitUnpackedVarVisitor final : public VNVisitor, public SplitVarImpl {
iterateChildren(nodep);
}
}
virtual void visit(AstSliceSel* nodep) override {
void visit(AstSliceSel* nodep) override {
if (AstVarRef* const refp = isTargetVref(nodep->fromp())) {
const AstUnpackArrayDType* const dtypep
= VN_AS(refp->varp()->dtypep()->skipRefp(), UnpackArrayDType);
@ -966,10 +966,10 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
int m_numSplit = 0; // Total number of split variables
// key:variable to be split. value:location where the variable is referenced.
std::map<AstVar*, PackedVarRef, AstNodeComparator> m_refs;
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
if (!cannotSplitTaskReason(nodep)) iterateChildren(nodep);
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
if (!nodep->attrSplitVar()) return; // Nothing to do
if (const char* const reason = cannotSplitReason(nodep, true)) {
warnNoSplit(nodep, nodep, reason);
@ -979,7 +979,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
if (inserted) UINFO(3, nodep->prettyNameQ() << " is added to candidate list.\n");
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
AstVar* const varp = nodep->varp();
visit(varp);
const auto refit = m_refs.find(varp);
@ -993,7 +993,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
UINFO(5, varp->prettyName()
<< " Entire bit of [" << basicp->lo() << "+:" << varp->width() << "] \n");
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
const AstVarRef* const vrefp = VN_CAST(nodep->fromp(), VarRef);
if (!vrefp) {
iterateChildren(nodep);
@ -1032,7 +1032,7 @@ class SplitPackedVarVisitor final : public VNVisitor, public SplitVarImpl {
iterateChildren(nodep);
}
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
// Extract necessary bit range from a newly created variable to meet ref
static AstNode* extractBits(const PackedVarRefEntry& ref, const SplitNewVar& var,

20
src/V3Stats.cpp
View File

@ -76,7 +76,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
allNodes(nodep);
if (!m_fast) {
// Count all CFuncs below this module
@ -85,7 +85,7 @@ private:
// Else we recursively trace fast CFuncs from the top _eval
// func, see visit(AstNetlist*)
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_counting && nodep->dtypep()) {
@ -111,7 +111,7 @@ private:
}
}
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_counting) {
@ -120,7 +120,7 @@ private:
}
}
}
virtual void visit(AstNodeIf* nodep) override {
void visit(AstNodeIf* nodep) override {
UINFO(4, " IF i=" << m_instrs << " " << nodep << endl);
allNodes(nodep);
// Condition is part of cost allocated to PREVIOUS block
@ -166,9 +166,9 @@ private:
}
}
// While's we assume evaluate once.
// virtual void visit(AstWhile* nodep) override {
// void visit(AstWhile* nodep) override {
virtual void visit(AstNodeCCall* nodep) override {
void visit(AstNodeCCall* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
if (m_fast && !nodep->funcp()->entryPoint()) {
@ -177,7 +177,7 @@ private:
iterate(nodep->funcp());
}
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
if (m_fast) {
if (!m_tracingCall && !nodep->entryPoint()) return;
m_tracingCall = false;
@ -189,11 +189,11 @@ private:
iterateChildrenConst(nodep);
}
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
allNodes(nodep);
iterateChildrenConst(nodep);
}
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
if (m_fast && nodep->evalp()) {
m_instrs = 0;
m_counting = true;
@ -219,7 +219,7 @@ public:
// Process
iterate(nodep);
}
virtual ~StatsVisitor() override {
~StatsVisitor() override {
// Done. Publish statistics
V3Stats::addStat(m_stage, "Instruction count, TOTAL", m_statInstr);
V3Stats::addStat(m_stage, "Instruction count, fast critical", m_statInstrFast);

24
src/V3Subst.cpp
View File

@ -189,7 +189,7 @@ private:
return reinterpret_cast<SubstVarEntry*>(nodep->varp()->user1p()); // Might be nullptr
}
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
const SubstVarEntry* const entryp = findEntryp(nodep);
if (entryp) {
// Don't sweat it. We assign a new temp variable for every new assignment,
@ -204,8 +204,8 @@ private:
}
}
}
virtual void visit(AstConst*) override {} // Accelerate
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstConst*) override {} // Accelerate
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -214,7 +214,7 @@ public:
UINFO(9, " SubstUseVisitor " << origStep << " " << nodep << endl);
iterate(nodep);
}
virtual ~SubstUseVisitor() override = default;
~SubstUseVisitor() override = default;
// METHODS
bool ok() const { return m_ok; }
};
@ -258,7 +258,7 @@ private:
inline bool isSubstVar(AstVar* nodep) { return nodep->isStatementTemp() && !nodep->noSubst(); }
// VISITORS
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
m_ops = 0;
m_assignStep++;
iterateAndNextNull(nodep->rhsp());
@ -304,7 +304,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
++m_statSubsts;
}
virtual void visit(AstWordSel* nodep) override {
void visit(AstWordSel* nodep) override {
iterate(nodep->rhsp());
AstVarRef* const varrefp = VN_CAST(nodep->lhsp(), VarRef);
const AstConst* const constp = VN_CAST(nodep->rhsp(), Const);
@ -329,7 +329,7 @@ private:
iterate(nodep->lhsp());
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
// Any variable
if (nodep->access().isWriteOrRW()) {
m_assignStep++;
@ -357,16 +357,16 @@ private:
}
}
}
virtual void visit(AstVar*) override {}
virtual void visit(AstConst*) override {}
virtual void visit(AstModule* nodep) override {
void visit(AstVar*) override {}
void visit(AstConst*) override {}
void visit(AstModule* nodep) override {
++m_ops;
if (!nodep->isSubstOptimizable()) m_ops = SUBST_MAX_OPS_NA;
iterateChildren(nodep);
// Reduce peak memory usage by reclaiming the edited AstNodes
doDeletes();
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
m_ops++;
if (!nodep->isSubstOptimizable()) m_ops = SUBST_MAX_OPS_NA;
iterateChildren(nodep);
@ -375,7 +375,7 @@ private:
public:
// CONSTRUCTORS
explicit SubstVisitor(AstNode* nodep) { iterate(nodep); }
virtual ~SubstVisitor() override {
~SubstVisitor() override {
V3Stats::addStat("Optimizations, Substituted temps", m_statSubsts);
for (SubstVarEntry* ip : m_entryps) {
ip->deleteUnusedAssign();

8
src/V3TSP.cpp
View File

@ -61,7 +61,7 @@ public:
TspVertexTmpl(V3Graph* graphp, const T_Key& k)
: V3GraphVertex{graphp}
, m_key{k} {}
virtual ~TspVertexTmpl() override = default;
~TspVertexTmpl() override = default;
const T_Key& key() const { return m_key; }
private:
@ -84,7 +84,7 @@ public:
// CONSTRUCTORS
TspGraphTmpl()
: V3Graph{} {}
virtual ~TspGraphTmpl() override = default;
~TspGraphTmpl() override = default;
// METHODS
void addVertex(const T_Key& key) {
@ -542,8 +542,8 @@ public:
: m_xpos{xpos}
, m_ypos{ypos}
, m_serial{++s_serialNext} {}
virtual ~TspTestState() override = default;
virtual int cost(const TspStateBase* otherp) const override {
~TspTestState() override = default;
int cost(const TspStateBase* otherp) const override {
return cost(dynamic_cast<const TspTestState*>(otherp));
}
static unsigned diff(unsigned a, unsigned b) {

16
src/V3Table.cpp
View File

@ -59,12 +59,12 @@ class TableSimulateVisitor final : public SimulateVisitor {
public:
///< Call other-this function on all new var references
virtual void varRefCb(AstVarRef* nodep) override;
void varRefCb(AstVarRef* nodep) override;
// CONSTRUCTORS
explicit TableSimulateVisitor(TableVisitor* cbthis)
: m_cbthis{cbthis} {}
virtual ~TableSimulateVisitor() override = default;
~TableSimulateVisitor() override = default;
};
//######################################################################
@ -379,8 +379,8 @@ private:
}
// VISITORS
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
VL_RESTORER(m_modTables);
{
@ -389,20 +389,20 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UINFO(4, " SCOPE " << nodep << endl);
m_scopep = nodep;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
UINFO(4, " ALWAYS " << nodep << endl);
if (treeTest(nodep)) {
// Well, then, I'll be a memory hog.
replaceWithTable(nodep);
}
}
virtual void visit(AstNodeAssign* nodep) override {
void visit(AstNodeAssign* nodep) override {
// It's nearly impossible to have a large enough assign to make this worthwhile
// For now we won't bother.
// Accelerated: no iterate
@ -411,7 +411,7 @@ private:
public:
// CONSTRUCTORS
explicit TableVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~TableVisitor() override { //
~TableVisitor() override { //
V3Stats::addStat("Optimizations, Tables created", m_statTablesCre);
}
};

58
src/V3Task.cpp
View File

@ -47,7 +47,7 @@ class TaskBaseVertex VL_NOT_FINAL : public V3GraphVertex {
public:
explicit TaskBaseVertex(V3Graph* graphp)
: V3GraphVertex{graphp} {}
virtual ~TaskBaseVertex() override = default;
~TaskBaseVertex() override = default;
bool pure() const { return m_impurep == nullptr; }
AstNode* impureNode() const { return m_impurep; }
void impure(AstNode* nodep) { m_impurep = nodep; }
@ -64,10 +64,10 @@ public:
TaskFTaskVertex(V3Graph* graphp, AstNodeFTask* nodep)
: TaskBaseVertex{graphp}
, m_nodep{nodep} {}
virtual ~TaskFTaskVertex() override = default;
~TaskFTaskVertex() override = default;
AstNodeFTask* nodep() const { return m_nodep; }
virtual string name() const override { return nodep()->name(); }
virtual string dotColor() const override { return pure() ? "black" : "red"; }
string name() const override { return nodep()->name(); }
string dotColor() const override { return pure() ? "black" : "red"; }
AstCFunc* cFuncp() const { return m_cFuncp; }
void cFuncp(AstCFunc* nodep) { m_cFuncp = nodep; }
};
@ -77,17 +77,17 @@ class TaskCodeVertex final : public TaskBaseVertex {
public:
explicit TaskCodeVertex(V3Graph* graphp)
: TaskBaseVertex{graphp} {}
virtual ~TaskCodeVertex() override = default;
virtual string name() const override { return "*CODE*"; }
virtual string dotColor() const override { return "green"; }
~TaskCodeVertex() override = default;
string name() const override { return "*CODE*"; }
string dotColor() const override { return "green"; }
};
class TaskEdge final : public V3GraphEdge {
public:
TaskEdge(V3Graph* graphp, TaskBaseVertex* fromp, TaskBaseVertex* top)
: V3GraphEdge{graphp, fromp, top, 1, false} {}
virtual ~TaskEdge() override = default;
virtual string dotLabel() const override { return "w" + cvtToStr(weight()); }
~TaskEdge() override = default;
string dotLabel() const override { return "w" + cvtToStr(weight()); }
};
//######################################################################
@ -166,7 +166,7 @@ private:
}
// VISITORS
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
// Each FTask is unique per-scope, so AstNodeFTaskRefs do not need
// pointers to what scope the FTask is to be invoked under.
// However, to create variables, we need to track the scopes involved.
@ -186,12 +186,12 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
m_assignwp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
m_assignwp = nullptr;
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
// Includes handling AstMethodCall, AstNew
if (m_assignwp) {
// Wire assigns must become always statements to deal with insertion
@ -204,7 +204,7 @@ private:
UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked task");
new TaskEdge(&m_callGraph, m_curVxp, getFTaskVertex(nodep->taskp()));
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
UINFO(9, " TASK " << nodep << endl);
{
VL_RESTORER(m_curVxp);
@ -221,7 +221,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstPragma* nodep) override {
void visit(AstPragma* nodep) override {
if (nodep->pragType() == VPragmaType::NO_INLINE_TASK) {
// Just mark for the next steps, and we're done with it.
m_curVxp->noInline(true);
@ -230,17 +230,17 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
nodep->user4p(m_curVxp); // Remember what task it's under
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
iterateChildren(nodep);
if (nodep->varp()->user4u().toGraphVertex() != m_curVxp) {
if (m_curVxp->pure() && !nodep->varp()->isXTemp()) m_curVxp->impure(nodep);
}
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
// Move initial statements into the constructor
m_initialps.clear();
m_ctorp = nullptr;
@ -264,12 +264,12 @@ private:
m_ctorp = nullptr;
m_classp = nullptr;
}
virtual void visit(AstInitialAutomatic* nodep) override {
void visit(AstInitialAutomatic* nodep) override {
m_initialps.push_back(nodep);
iterateChildren(nodep);
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -283,7 +283,7 @@ public:
m_callGraph.removeRedundantEdgesSum(&TaskEdge::followAlwaysTrue);
m_callGraph.dumpDotFilePrefixed("task_call");
}
virtual ~TaskStateVisitor() override = default;
~TaskStateVisitor() override = default;
VL_UNCOPYABLE(TaskStateVisitor);
};
@ -1366,7 +1366,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
VL_RESTORER(m_modNCalls);
{
@ -1376,13 +1376,13 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
m_scopep = nodep;
m_insStmtp = nullptr;
iterateChildren(nodep);
m_scopep = nullptr;
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
// Includes handling AstMethodCall, AstNew
UASSERT_OBJ(nodep->taskp(), nodep, "Unlinked?");
iterateIntoFTask(nodep->taskp()); // First, do hierarchical funcs
@ -1436,7 +1436,7 @@ private:
// Visit nodes that normal iteration won't find
if (visitp) iterateAndNextNull(visitp);
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
UINFO(4, " visitFTask " << nodep << endl);
VL_RESTORER(m_insMode);
VL_RESTORER(m_insStmtp);
@ -1504,7 +1504,7 @@ private:
VL_DO_DANGLING(pushDeletep(nodep), nodep);
}
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
// Special, as statements need to be put in different places
// Preconditions insert first just before themselves (the normal
// rule for other statement types)
@ -1521,11 +1521,11 @@ private:
// Done the loop
m_insStmtp = nullptr; // Next thing should be new statement
}
virtual void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodeFor* nodep) override { // LCOV_EXCL_LINE
nodep->v3fatalSrc(
"For statements should have been converted to while statements in V3Begin.cpp");
}
virtual void visit(AstNodeStmt* nodep) override {
void visit(AstNodeStmt* nodep) override {
if (!nodep->isStatement()) {
iterateChildren(nodep);
return;
@ -1536,7 +1536,7 @@ private:
m_insStmtp = nullptr; // Next thing should be new statement
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -1544,7 +1544,7 @@ public:
: m_statep{statep} {
iterate(nodep);
}
virtual ~TaskVisitor() override = default;
~TaskVisitor() override = default;
};
//######################################################################

46
src/V3Trace.cpp
View File

@ -73,20 +73,20 @@ public:
m_activityCode = code;
m_slow = false;
}
virtual ~TraceActivityVertex() override = default;
~TraceActivityVertex() override = default;
// ACCESSORS
AstNode* insertp() const {
if (!m_insertp) v3fatalSrc("Null insertp; probably called on a special always/slow.");
return m_insertp;
}
virtual string name() const override {
string name() const override {
if (activityAlways()) {
return "*ALWAYS*";
} else {
return std::string{slow() ? "*SLOW* " : ""} + insertp()->name();
}
}
virtual string dotColor() const override { return slow() ? "yellowGreen" : "green"; }
string dotColor() const override { return slow() ? "yellowGreen" : "green"; }
int32_t activityCode() const { return m_activityCode; }
bool activityAlways() const { return activityCode() == ACTIVITY_ALWAYS; }
bool activitySlow() const { return activityCode() == ACTIVITY_SLOW; }
@ -104,12 +104,12 @@ public:
TraceCFuncVertex(V3Graph* graphp, AstCFunc* nodep)
: V3GraphVertex{graphp}
, m_nodep{nodep} {}
virtual ~TraceCFuncVertex() override = default;
~TraceCFuncVertex() override = default;
// ACCESSORS
AstCFunc* nodep() const { return m_nodep; }
virtual string name() const override { return nodep()->name(); }
virtual string dotColor() const override { return "yellow"; }
virtual FileLine* fileline() const override { return nodep()->fileline(); }
string name() const override { return nodep()->name(); }
string dotColor() const override { return "yellow"; }
FileLine* fileline() const override { return nodep()->fileline(); }
};
class TraceTraceVertex final : public V3GraphVertex {
@ -121,12 +121,12 @@ public:
TraceTraceVertex(V3Graph* graphp, AstTraceDecl* nodep)
: V3GraphVertex{graphp}
, m_nodep{nodep} {}
virtual ~TraceTraceVertex() override = default;
~TraceTraceVertex() override = default;
// ACCESSORS
AstTraceDecl* nodep() const { return m_nodep; }
virtual string name() const override { return nodep()->name(); }
virtual string dotColor() const override { return "red"; }
virtual FileLine* fileline() const override { return nodep()->fileline(); }
string name() const override { return nodep()->name(); }
string dotColor() const override { return "red"; }
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");
@ -141,12 +141,12 @@ public:
TraceVarVertex(V3Graph* graphp, AstVarScope* nodep)
: V3GraphVertex{graphp}
, m_nodep{nodep} {}
virtual ~TraceVarVertex() override = default;
~TraceVarVertex() override = default;
// ACCESSORS
AstVarScope* nodep() const { return m_nodep; }
virtual string name() const override { return nodep()->name(); }
virtual string dotColor() const override { return "skyblue"; }
virtual FileLine* fileline() const override { return nodep()->fileline(); }
string name() const override { return nodep()->name(); }
string dotColor() const override { return "skyblue"; }
FileLine* fileline() const override { return nodep()->fileline(); }
};
//######################################################################
@ -796,7 +796,7 @@ private:
}
// VISITORS
virtual void visit(AstNetlist* nodep) override {
void visit(AstNetlist* nodep) override {
m_code = 1; // Multiple TopScopes will require fixing how code#s
// are assigned as duplicate varscopes must result in the same tracing code#.
@ -811,11 +811,11 @@ private:
// Create the trace functions and insert them into the tree
createTraceFunctions();
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
if (nodep->isTop()) m_topModp = nodep;
iterateChildren(nodep);
}
virtual void visit(AstCCall* nodep) override {
void visit(AstCCall* nodep) override {
UINFO(8, " CCALL " << nodep << endl);
if (!m_finding && !nodep->user2()) {
// See if there are other calls in same statement list;
@ -834,7 +834,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstCFunc* nodep) override {
void visit(AstCFunc* nodep) override {
UINFO(8, " CFUNC " << nodep << endl);
V3GraphVertex* const funcVtxp = getCFuncVertexp(nodep);
if (!m_finding) { // If public, we need a unique activity code to allow for sets
@ -851,7 +851,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstTraceDecl* nodep) override {
void visit(AstTraceDecl* nodep) override {
UINFO(8, " TRACE " << nodep << endl);
if (!m_finding) {
V3GraphVertex* const vertexp = new TraceTraceVertex(&m_graph, nodep);
@ -863,7 +863,7 @@ private:
m_tracep = nullptr;
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (m_tracep) {
UASSERT_OBJ(nodep->varScopep(), nodep, "No var scope?");
UASSERT_OBJ(nodep->access().isReadOnly(), nodep, "Lvalue in trace? Should be const.");
@ -888,7 +888,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -896,7 +896,7 @@ public:
: m_alwaysVtxp{new TraceActivityVertex{&m_graph, TraceActivityVertex::ACTIVITY_ALWAYS}} {
iterate(nodep);
}
virtual ~TraceVisitor() override {
~TraceVisitor() override {
V3Stats::addStat("Tracing, Unique traced signals", m_statUniqSigs);
V3Stats::addStat("Tracing, Unique trace codes", m_statUniqCodes);
}

24
src/V3TraceDecl.cpp
View File

@ -241,7 +241,7 @@ private:
}
// VISITORS
virtual void visit(AstScope* nodep) override {
void visit(AstScope* nodep) override {
UASSERT_OBJ(!m_currScopep, nodep, "Should not nest");
UASSERT_OBJ(m_subFuncps.empty(), nodep, "Should not nest");
UASSERT_OBJ(m_signals.empty(), nodep, "Should not nest");
@ -330,7 +330,7 @@ private:
m_scopeSubFuncps.emplace(scopeName, std::move(m_subFuncps));
}
}
virtual void visit(AstVarScope* nodep) override {
void visit(AstVarScope* nodep) override {
UASSERT_OBJ(m_currScopep, nodep, "AstVarScope not under AstScope");
// Prefilter - things that get added to m_vscps will either get traced or get a comment as
@ -345,13 +345,13 @@ private:
}
// VISITORS - Data types when tracing
virtual void visit(AstConstDType* nodep) override {
void visit(AstConstDType* nodep) override {
if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
}
virtual void visit(AstRefDType* nodep) override {
void visit(AstRefDType* nodep) override {
if (m_traVscp) iterate(nodep->subDTypep()->skipRefToEnump());
}
virtual void visit(AstUnpackArrayDType* nodep) override {
void visit(AstUnpackArrayDType* nodep) override {
// Note more specific dtypes above
if (m_traVscp) {
if (static_cast<int>(nodep->arrayUnpackedElements()) > v3Global.opt.traceMaxArray()) {
@ -386,7 +386,7 @@ private:
}
}
}
virtual void visit(AstPackArrayDType* nodep) override {
void visit(AstPackArrayDType* nodep) override {
if (m_traVscp) {
if (!v3Global.opt.traceStructs()) {
// Everything downstream is packed, so deal with as one trace unit.
@ -412,7 +412,7 @@ private:
}
}
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
if (m_traVscp) {
if (nodep->packed() && !v3Global.opt.traceStructs()) {
// Everything downstream is packed, so deal with as one trace unit
@ -449,7 +449,7 @@ private:
}
}
}
virtual void visit(AstBasicDType* nodep) override {
void visit(AstBasicDType* nodep) override {
if (m_traVscp) {
if (nodep->isString()) {
addIgnore("Unsupported: strings");
@ -458,15 +458,15 @@ private:
}
}
}
virtual void visit(AstEnumDType* nodep) override { iterate(nodep->skipRefp()); }
virtual void visit(AstNodeDType*) override {
void visit(AstEnumDType* nodep) override { iterate(nodep->skipRefp()); }
void visit(AstNodeDType*) override {
// Note more specific dtypes above
if (!m_traVscp) return;
addIgnore("Unsupported: data type");
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -513,7 +513,7 @@ public:
AstCFunc* const topFuncp = m_topFuncps.front();
topFuncp->name("trace_init_top");
}
virtual ~TraceDeclVisitor() override {
~TraceDeclVisitor() override {
V3Stats::addStat("Tracing, Traced signals", m_statSigs);
V3Stats::addStat("Tracing, Ignored signals", m_statIgnSigs);
}

70
src/V3Tristate.cpp
View File

@ -118,17 +118,17 @@ public:
TristateVertex(V3Graph* graphp, AstNode* nodep)
: V3GraphVertex{graphp}
, m_nodep{nodep} {}
virtual ~TristateVertex() override = default;
~TristateVertex() override = default;
// ACCESSORS
AstNode* nodep() const { return m_nodep; }
const AstVar* varp() const { return VN_CAST(nodep(), Var); }
virtual string name() const override {
string name() const override {
return ((isTristate() ? "tri\\n"
: feedsTri() ? "feed\\n"
: "-\\n")
+ (nodep()->prettyTypeName() + " " + cvtToHex(nodep())));
}
virtual string dotColor() const override {
string dotColor() const override {
return (varp() ? (isTristate() ? "darkblue"
: feedsTri() ? "blue"
: "lightblue")
@ -136,7 +136,7 @@ public:
: feedsTri() ? "green"
: "lightgreen"));
}
virtual FileLine* fileline() const override { return nodep()->fileline(); }
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; }
@ -312,7 +312,7 @@ class TristatePinVisitor final : public TristateBaseVisitor {
TristateGraph& m_tgraph;
const bool m_lvalue; // Flip to be an LVALUE
// VISITORS
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
UASSERT_OBJ(!nodep->access().isRW(), nodep, "Tristate unexpected on R/W access flip");
if (m_lvalue && !nodep->access().isWriteOrRW()) {
UINFO(9, " Flip-to-LValue " << nodep << endl);
@ -325,17 +325,17 @@ class TristatePinVisitor final : public TristateBaseVisitor {
m_tgraph.setTristate(nodep->varp());
}
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
// Doesn't work because we'd set lvalue on the array index's var
UASSERT_OBJ(!m_lvalue, nodep, "ArraySel conversion to output, under tristate node");
iterateChildren(nodep);
}
virtual void visit(AstSliceSel* nodep) override {
void visit(AstSliceSel* nodep) override {
// Doesn't work because we'd set lvalue on the array index's var
UASSERT_OBJ(!m_lvalue, nodep, "SliceSel conversion to output, under tristate node");
iterateChildren(nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -344,7 +344,7 @@ public:
, m_lvalue{lvalue} {
iterate(nodep);
}
virtual ~TristatePinVisitor() override = default;
~TristatePinVisitor() override = default;
};
//######################################################################
@ -778,7 +778,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
// VISITORS
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
if (!m_alhs && nodep->num().hasZ()) m_tgraph.setTristate(nodep);
@ -811,7 +811,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstCond* nodep) override {
void visit(AstCond* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -856,7 +856,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -895,7 +895,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstConcat* nodep) override {
void visit(AstConcat* nodep) override {
if (m_graphing) {
iterateChildren(nodep);
if (m_alhs) {
@ -941,7 +941,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstBufIf1* nodep) override {
void visit(AstBufIf1* nodep) override {
// For BufIf1, the enable is the LHS expression
iterateChildren(nodep);
UINFO(9, dbgState() << nodep << endl);
@ -1025,8 +1025,8 @@ class TristateVisitor final : public TristateBaseVisitor {
expr2p->user1p(nullptr);
}
}
virtual void visit(AstAnd* nodep) override { visitAndOr(nodep, true); }
virtual void visit(AstOr* nodep) override { visitAndOr(nodep, false); }
void visit(AstAnd* nodep) override { visitAndOr(nodep, true); }
void visit(AstOr* nodep) override { visitAndOr(nodep, false); }
void visitAssign(AstNodeAssign* nodep) {
if (m_graphing) {
@ -1065,8 +1065,8 @@ class TristateVisitor final : public TristateBaseVisitor {
m_alhs = false;
}
}
virtual void visit(AstAssignW* nodep) override { visitAssign(nodep); }
virtual void visit(AstAssign* nodep) override { visitAssign(nodep); }
void visit(AstAssignW* nodep) override { visitAssign(nodep); }
void visit(AstAssign* nodep) override { visitAssign(nodep); }
void visitCaseEq(AstNodeBiop* nodep, bool neq) {
if (m_graphing) {
@ -1136,12 +1136,12 @@ class TristateVisitor final : public TristateBaseVisitor {
return;
}
}
virtual void visit(AstEqCase* nodep) override { visitCaseEq(nodep, false); }
virtual void visit(AstNeqCase* nodep) override { visitCaseEq(nodep, true); }
virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
void visit(AstEqCase* nodep) override { visitCaseEq(nodep, false); }
void visit(AstNeqCase* nodep) override { visitCaseEq(nodep, true); }
void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstCountBits* nodep) override {
void visit(AstCountBits* nodep) override {
std::array<bool, 3> dropop;
dropop[0] = VN_IS(nodep->rhsp(), Const) && VN_AS(nodep->rhsp(), Const)->num().isAnyZ();
dropop[1] = VN_IS(nodep->thsp(), Const) && VN_AS(nodep->thsp(), Const)->num().isAnyZ();
@ -1201,7 +1201,7 @@ class TristateVisitor final : public TristateBaseVisitor {
iterateChildren(nodep);
}
}
virtual void visit(AstPull* nodep) override {
void visit(AstPull* nodep) override {
UINFO(9, dbgState() << nodep << endl);
AstVarRef* varrefp = nullptr;
if (VN_IS(nodep->lhsp(), VarRef)) {
@ -1276,7 +1276,7 @@ class TristateVisitor final : public TristateBaseVisitor {
// __out(to-resolver-only)
// const inout Spec says illegal
// const output Unsupported; Illegal?
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
if (m_graphing) {
if (nodep->user2() & U2_GRAPHING) return; // This pin is already expanded
nodep->user2(U2_GRAPHING);
@ -1445,7 +1445,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
if (nodep->access().isWriteOrRW()) associateLogic(nodep, nodep->varp());
@ -1477,7 +1477,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
iterateChildren(nodep);
UINFO(9, dbgState() << nodep << endl);
if (m_graphing) {
@ -1510,7 +1510,7 @@ class TristateVisitor final : public TristateBaseVisitor {
}
}
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UINFO(8, nodep << endl);
VL_RESTORER(m_modp);
VL_RESTORER(m_graphing);
@ -1546,29 +1546,29 @@ class TristateVisitor final : public TristateBaseVisitor {
m_tgraph.clear(); // Recursion not supported
}
virtual void visit(AstClass* nodep) override {
void visit(AstClass* nodep) override {
// don't deal with classes
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
// don't deal with functions
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
// don't deal with casez compare '???? values
iterateAndNextNull(nodep->bodysp());
}
virtual void visit(AstCell* nodep) override {
void visit(AstCell* nodep) override {
VL_RESTORER(m_cellp);
m_cellp = nodep;
m_alhs = false;
iterateChildren(nodep);
}
virtual void visit(AstNetlist* nodep) override { iterateChildrenBackwards(nodep); }
void visit(AstNetlist* nodep) override { iterateChildrenBackwards(nodep); }
// Default: Just iterate
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
checkUnhandled(nodep);
}
@ -1579,7 +1579,7 @@ public:
m_tgraph.clear();
iterate(nodep);
}
virtual ~TristateVisitor() override {
~TristateVisitor() override {
V3Stats::addStat("Tristate, Tristate resolved nets", m_statTriSigs);
}
};

42
src/V3Undriven.cpp
View File

@ -294,7 +294,7 @@ private:
}
// VISITORS
virtual void visit(AstVar* nodep) override {
void visit(AstVar* nodep) override {
for (int usr = 1; usr < (m_alwaysCombp ? 3 : 2); ++usr) {
// For assigns and non-combo always, do just usr==1, to look
// for module-wide undriven etc.
@ -315,15 +315,15 @@ private:
// Discover variables used in bit definitions, etc
iterateChildren(nodep);
}
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
// Arrays are rarely constant assigned, so for now we punt and do all entries
iterateChildren(nodep);
}
virtual void visit(AstSliceSel* nodep) override {
void visit(AstSliceSel* nodep) override {
// Arrays are rarely constant assigned, so for now we punt and do all entries
iterateChildren(nodep);
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
AstNodeVarRef* const varrefp = VN_CAST(nodep->fromp(), NodeVarRef);
AstConst* const constp = VN_CAST(nodep->lsbp(), Const);
if (varrefp && constp && !constp->num().isFourState()) {
@ -347,7 +347,7 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
// Any variable
if (nodep->access().isWriteOrRW()
&& !VN_IS(nodep, VarXRef)) { // Ignore interface variables and similar ugly items
@ -388,7 +388,7 @@ private:
}
// Don't know what black boxed calls do, assume in+out
virtual void visit(AstSysIgnore* nodep) override {
void visit(AstSysIgnore* nodep) override {
VL_RESTORER(m_inBBox);
{
m_inBBox = true;
@ -396,28 +396,28 @@ private:
}
}
virtual void visit(AstAssign* nodep) override {
void visit(AstAssign* nodep) override {
VL_RESTORER(m_inProcAssign);
{
m_inProcAssign = true;
iterateChildren(nodep);
}
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
VL_RESTORER(m_inProcAssign);
{
m_inProcAssign = true;
iterateChildren(nodep);
}
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
VL_RESTORER(m_inContAssign);
{
m_inContAssign = true;
iterateChildren(nodep);
}
}
virtual void visit(AstAlways* nodep) override {
void visit(AstAlways* nodep) override {
VL_RESTORER(m_alwaysCombp);
{
AstNode::user2ClearTree();
@ -432,37 +432,37 @@ private:
}
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
VL_RESTORER(m_taskp);
{
m_taskp = nodep;
iterateChildren(nodep);
}
}
virtual void visit(AstPin* nodep) override {
void visit(AstPin* nodep) override {
VL_RESTORER(m_inInoutPin);
m_inInoutPin = nodep->modVarp()->isInoutish();
iterateChildren(nodep);
}
// Until we support tables, primitives will have undriven and unused I/Os
virtual void visit(AstPrimitive*) override {}
void visit(AstPrimitive*) override {}
// Coverage artifacts etc shouldn't count as a sink
virtual void visit(AstCoverDecl*) override {}
virtual void visit(AstCoverInc*) override {}
virtual void visit(AstCoverToggle*) override {}
virtual void visit(AstTraceDecl*) override {}
virtual void visit(AstTraceInc*) override {}
void visit(AstCoverDecl*) override {}
void visit(AstCoverInc*) override {}
void visit(AstCoverToggle*) override {}
void visit(AstTraceDecl*) override {}
void visit(AstTraceInc*) override {}
// iterate
virtual void visit(AstConst* nodep) override {}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstConst* nodep) override {}
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
explicit UndrivenVisitor(AstNetlist* nodep) { iterate(nodep); }
virtual ~UndrivenVisitor() override {
~UndrivenVisitor() override {
for (UndrivenVarEntry* ip : m_entryps[1]) ip->reportViolations();
for (int usr = 1; usr < 3; ++usr) {
for (UndrivenVarEntry* ip : m_entryps[usr]) delete ip;

32
src/V3Unknown.cpp
View File

@ -138,7 +138,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
UINFO(4, " MOD " << nodep << endl);
VL_RESTORER(m_modp);
VL_RESTORER(m_constXCvt);
@ -153,21 +153,21 @@ private:
iterateChildren(nodep);
}
}
virtual void visit(AstAssignDly* nodep) override {
void visit(AstAssignDly* nodep) override {
VL_RESTORER(m_assigndlyp);
{
m_assigndlyp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
}
}
virtual void visit(AstAssignW* nodep) override {
void visit(AstAssignW* nodep) override {
VL_RESTORER(m_assignwp);
{
m_assignwp = nodep;
VL_DO_DANGLING(iterateChildren(nodep), nodep); // May delete nodep.
}
}
virtual void visit(AstCaseItem* nodep) override {
void visit(AstCaseItem* nodep) override {
VL_RESTORER(m_constXCvt);
{
m_constXCvt = false; // Avoid losing the X's in casex
@ -176,7 +176,7 @@ private:
iterateAndNextNull(nodep->bodysp());
}
}
virtual void visit(AstNodeDType* nodep) override {
void visit(AstNodeDType* nodep) override {
VL_RESTORER(m_constXCvt);
{
m_constXCvt = false; // Avoid losing the X's in casex
@ -255,11 +255,11 @@ private:
}
}
virtual void visit(AstEqCase* nodep) override { visitEqNeqCase(nodep); }
virtual void visit(AstNeqCase* nodep) override { visitEqNeqCase(nodep); }
virtual void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
virtual void visit(AstIsUnknown* nodep) override {
void visit(AstEqCase* nodep) override { visitEqNeqCase(nodep); }
void visit(AstNeqCase* nodep) override { visitEqNeqCase(nodep); }
void visit(AstEqWild* nodep) override { visitEqNeqWild(nodep); }
void visit(AstNeqWild* nodep) override { visitEqNeqWild(nodep); }
void visit(AstIsUnknown* nodep) override {
iterateChildren(nodep);
// Ahh, we're two state, so this is easy
UINFO(4, " ISUNKNOWN->0 " << nodep << endl);
@ -267,7 +267,7 @@ private:
nodep->replaceWith(newp);
VL_DO_DANGLING(nodep->deleteTree(), nodep);
}
virtual void visit(AstCountBits* nodep) override {
void visit(AstCountBits* nodep) override {
// Ahh, we're two state, so this is easy
std::array<bool, 3> dropop;
dropop[0] = VN_IS(nodep->rhsp(), Const) && VN_AS(nodep->rhsp(), Const)->num().isAnyX();
@ -303,7 +303,7 @@ private:
}
iterateChildren(nodep);
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
if (m_constXCvt && nodep->num().isFourState()) {
UINFO(4, " CONST4 " << nodep << endl);
if (debug() >= 9) nodep->dumpTree(cout, " Const_old: ");
@ -364,7 +364,7 @@ private:
}
}
virtual void visit(AstSel* nodep) override {
void visit(AstSel* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
// Guard against reading/writing past end of bit vector array
@ -411,7 +411,7 @@ private:
// visit(AstSliceSel) not needed as its bounds are constant and checked
// in V3Width.
virtual void visit(AstArraySel* nodep) override {
void visit(AstArraySel* nodep) override {
iterateChildren(nodep);
if (!nodep->user1SetOnce()) {
if (debug() == 9) nodep->dumpTree(cout, "-in: ");
@ -482,7 +482,7 @@ private:
}
}
//--------------------
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
@ -491,7 +491,7 @@ public:
, m_xrandNames{"__Vxrand"} {
iterate(nodep);
}
virtual ~UnknownVisitor() override { //
~UnknownVisitor() override { //
V3Stats::addStat("Unknowns, variables created", m_statUnkVars);
}
};

12
src/V3Unroll.cpp
View File

@ -371,7 +371,7 @@ private:
return true;
}
virtual void visit(AstWhile* nodep) override {
void visit(AstWhile* nodep) override {
iterateChildren(nodep);
if (m_varModeCheck || m_varModeReplace) {
} else {
@ -406,7 +406,7 @@ private:
}
}
}
virtual void visit(AstGenFor* nodep) override {
void visit(AstGenFor* nodep) override {
if (!m_generate || m_varModeReplace) {
iterateChildren(nodep);
} // else V3Param will recursively call each for loop to be unrolled for us
@ -433,7 +433,7 @@ private:
}
}
}
virtual void visit(AstNodeFor* nodep) override {
void visit(AstNodeFor* nodep) override {
if (m_generate) { // Ignore for's when expanding genfor's
iterateChildren(nodep);
} else {
@ -441,7 +441,7 @@ private:
}
}
virtual void visit(AstVarRef* nodep) override {
void visit(AstVarRef* nodep) override {
if (m_varModeCheck && nodep->varp() == m_forVarp && nodep->varScopep() == m_forVscp
&& nodep->access().isWriteOrRW()) {
UINFO(8, " Itervar assigned to: " << nodep << endl);
@ -458,7 +458,7 @@ private:
//--------------------
// Default: Just iterate
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
if (m_varModeCheck && nodep == m_ignoreIncp) {
// Ignore subtree that is the increment
} else {
@ -469,7 +469,7 @@ private:
public:
// CONSTRUCTORS
UnrollVisitor() { init(false, ""); }
virtual ~UnrollVisitor() override {
~UnrollVisitor() override {
V3Stats::addStatSum("Optimizations, Unrolled Loops", m_statLoops);
V3Stats::addStatSum("Optimizations, Unrolled Iterations", m_statIters);
}

4
src/V3VariableOrder.cpp
View File

@ -51,12 +51,12 @@ public:
}
~VarTspSorter() override = default;
// METHODS
virtual bool operator<(const TspStateBase& other) const override {
bool operator<(const TspStateBase& other) const override {
return operator<(static_cast<const VarTspSorter&>(other));
}
bool operator<(const VarTspSorter& other) const { return m_serial < other.m_serial; }
const MTaskIdSet& mtaskIds() const { return m_mtaskIds; }
virtual int cost(const TspStateBase* otherp) const override {
int cost(const TspStateBase* otherp) const override {
return cost(static_cast<const VarTspSorter*>(otherp));
}
int cost(const VarTspSorter* otherp) const {

472
src/V3Width.cpp
View File

File diff suppressed because it is too large Load Diff

32
src/V3WidthCommit.h
View File

@ -45,18 +45,18 @@ private:
}
// VISITORS
virtual void visit(AstSigned* nodep) override {
void visit(AstSigned* nodep) override {
VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
}
virtual void visit(AstUnsigned* nodep) override {
void visit(AstUnsigned* nodep) override {
VL_DO_DANGLING(replaceWithSignedVersion(nodep, nodep->lhsp()->unlinkFrBack()), nodep);
}
virtual void visit(AstNode* nodep) override { iterateChildren(nodep); }
void visit(AstNode* nodep) override { iterateChildren(nodep); }
public:
// CONSTRUCTORS
WidthRemoveVisitor() = default;
virtual ~WidthRemoveVisitor() override = default;
~WidthRemoveVisitor() override = default;
AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); }
};
@ -151,7 +151,7 @@ private:
}
// VISITORS
virtual void visit(AstNodeModule* nodep) override {
void visit(AstNodeModule* nodep) override {
VL_RESTORER(m_modp);
{
m_modp = nodep;
@ -159,7 +159,7 @@ private:
editDType(nodep);
}
}
virtual void visit(AstConst* nodep) override {
void visit(AstConst* nodep) override {
UASSERT_OBJ(nodep->dtypep(), nodep, "No dtype");
iterate(nodep->dtypep()); // Do datatype first
if (AstConst* const newp = newIfConstCommitSize(nodep)) {
@ -172,15 +172,15 @@ private:
}
editDType(nodep);
}
virtual void visit(AstNodeDType* nodep) override { //
void visit(AstNodeDType* nodep) override { //
visitIterateNodeDType(nodep);
}
virtual void visit(AstNodeUOrStructDType* nodep) override {
void visit(AstNodeUOrStructDType* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
visitIterateNodeDType(nodep);
nodep->clearCache();
}
virtual void visit(AstParamTypeDType* nodep) override {
void visit(AstParamTypeDType* nodep) override {
if (nodep->user1SetOnce()) return; // Process once
visitIterateNodeDType(nodep);
// Move to type table as all dtype pointers must resolve there
@ -199,7 +199,7 @@ private:
nodep->virtRefDTypep(editOneDType(nodep->virtRefDTypep()));
nodep->virtRefDType2p(editOneDType(nodep->virtRefDType2p()));
}
virtual void visit(AstNodeFTask* nodep) override {
void visit(AstNodeFTask* nodep) override {
iterateChildren(nodep);
editDType(nodep);
if (nodep->classMethod() && nodep->pureVirtual() && VN_IS(m_modp, Class)
@ -208,28 +208,28 @@ private:
"Illegal to have 'pure virtual' in non-virtual class (IEEE 1800-2017 8.21)");
}
}
virtual void visit(AstNodeVarRef* nodep) override {
void visit(AstNodeVarRef* nodep) override {
iterateChildren(nodep);
editDType(nodep);
classEncapCheck(nodep, nodep->varp(), VN_CAST(nodep->classOrPackagep(), Class));
}
virtual void visit(AstNodeFTaskRef* nodep) override {
void visit(AstNodeFTaskRef* nodep) override {
iterateChildren(nodep);
editDType(nodep);
classEncapCheck(nodep, nodep->taskp(), VN_CAST(nodep->classOrPackagep(), Class));
}
virtual void visit(AstMemberSel* nodep) override {
void visit(AstMemberSel* nodep) override {
iterateChildren(nodep);
editDType(nodep);
if (auto* const classrefp = VN_CAST(nodep->fromp()->dtypep(), ClassRefDType)) {
classEncapCheck(nodep, nodep->varp(), classrefp->classp());
} // else might be struct, etc
}
virtual void visit(AstNodePreSel* nodep) override { // LCOV_EXCL_LINE
void visit(AstNodePreSel* nodep) override { // LCOV_EXCL_LINE
// This check could go anywhere after V3Param
nodep->v3fatalSrc("Presels should have been removed before this point");
}
virtual void visit(AstNode* nodep) override {
void visit(AstNode* nodep) override {
iterateChildren(nodep);
editDType(nodep);
}
@ -243,7 +243,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() override = default;
~WidthCommitVisitor() override = default;
};
//######################################################################

12
src/V3WidthSel.cpp
View File

@ -202,7 +202,7 @@ private:
// VISITORS
// If adding new visitors, ensure V3Width's visit(TYPE) calls into here
virtual void visit(AstSelBit* nodep) override {
void visit(AstSelBit* nodep) override {
// Select of a non-width specified part of an array, i.e. "array[2]"
// This select style has a lsb and msb (no user specified width)
UINFO(6, "SELBIT " << nodep << endl);
@ -330,7 +330,7 @@ private:
}
if (!rhsp->backp()) VL_DO_DANGLING(pushDeletep(rhsp), rhsp);
}
virtual void visit(AstSelExtract* nodep) override {
void visit(AstSelExtract* nodep) override {
// Select of a range specified part of an array, i.e. "array[2:3]"
// SELEXTRACT(from,msb,lsb) -> SEL(from, lsb, 1+msb-lsb)
// This select style has a (msb or lsb) and width
@ -584,13 +584,13 @@ private:
if (!rhsp->backp()) VL_DO_DANGLING(pushDeletep(rhsp), rhsp);
if (!widthp->backp()) VL_DO_DANGLING(pushDeletep(widthp), widthp);
}
virtual void visit(AstSelPlus* nodep) override { replaceSelPlusMinus(nodep); }
virtual void visit(AstSelMinus* nodep) override { replaceSelPlusMinus(nodep); }
void visit(AstSelPlus* nodep) override { replaceSelPlusMinus(nodep); }
void visit(AstSelMinus* nodep) override { replaceSelPlusMinus(nodep); }
// If adding new visitors, ensure V3Width's visit(TYPE) calls into here
//--------------------
// Default
virtual void visit(AstNode* nodep) override { // LCOV_EXCL_LINE
void visit(AstNode* nodep) override { // LCOV_EXCL_LINE
// See notes above; we never iterate
nodep->v3fatalSrc("Shouldn't iterate in V3WidthSel");
}
@ -598,7 +598,7 @@ private:
public:
// CONSTRUCTORS
WidthSelVisitor() = default;
virtual ~WidthSelVisitor() override = default;
~WidthSelVisitor() override = default;
AstNode* mainAcceptEdit(AstNode* nodep) { return iterateSubtreeReturnEdits(nodep); }
};

12
src/astgen
View File

@ -468,7 +468,7 @@ class Cpt:
if len(out_for_type_sc) > 0: # Short-circuited types
self.print(
" // Generated by astgen with short-circuiting\n" +
" virtual void visit(Ast" + node.name +
" void visit(Ast" + node.name +
"* nodep) override {\n" +
" iterateAndNextNull(nodep->lhsp());\n" +
"".join(out_for_type_sc))
@ -481,10 +481,12 @@ class Cpt:
elif len(out_for_type) > 0: # Other types with something to print
skip = node.name in self.tree_skip_visit
gen = "Gen" if skip else ""
virtual = "virtual " if skip else ""
override = "" if skip else " override"
self.print(
" // Generated by astgen\n" + " virtual void visit" +
gen + "(Ast" + node.name + "* nodep)" + override + " {\n" +
" // Generated by astgen\n" + " " + virtual +
"void visit" + gen + "(Ast" + node.name + "* nodep)" +
override + " {\n" +
("" if skip else " iterateChildren(nodep);\n") +
''.join(out_for_type) + " }\n")
@ -751,8 +753,8 @@ def write_macros(filename):
if node.isLeaf:
emitBlock('''\
virtual void accept(VNVisitor& v) override {{ v.visit(this); }}
virtual AstNode* clone() override {{ return new Ast{t}(*this); }}
void accept(VNVisitor& v) override {{ v.visit(this); }}
AstNode* clone() override {{ return new Ast{t}(*this); }}
''',
t=node.name)

66
test_regress/t/t_dist_cppstyle.pl Executable file
View File

@ -0,0 +1,66 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Primitive C++ style checker
#
# Copyright 2022 by Geza Lore. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(dist => 1);
my $root = "..";
### Must trim output before and after our file list
my %files = %{get_source_files($root)};
foreach my $file (sort keys %files) {
my $filename = "$root/$file";
next if !-f $filename; # git file might be deleted but not yet staged
next unless $file =~ /\.(h|c|cpp)(\.in)?$/;
next if $file =~ /gtkwave/;
my $contents = file_contents($filename);
checkPattern($filename, $contents,
qr/virtual[^{};]+override/,
"'virtual' keyword is redundant on 'override' method");
}
ok(1);
1;
sub get_source_files {
my $root = shift;
my $git_files = `cd $root && git ls-files`;
print "MF $git_files\n" if $Self->{verbose};
my %files;
foreach my $file (split /\s+/, $git_files) {
next if $file eq '';
$files{$file} |= 1;
}
return \%files;
}
sub checkPattern {
my $filename = shift;
my $contents = shift;
my $pattern = shift;
my $message = shift;
my $offset = 0;
my $buffer = $contents;
while ($buffer =~ s/.*?^[^\/]*($pattern)//sm) {
my $lineno = offset_to_lineno($contents, $offset + $-[1]);
$offset += $+[1];
error("$filename:$lineno: $message");
}
}
sub offset_to_lineno {
my $contents = shift;
my $offset = shift;
my $count = (substr $contents, 0, $offset) =~ tr/\n//;
return $count + 1;
}