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

Internals: Fix constructor style.

This commit is contained in:
Wilson Snyder 2022-11-20 13:11:01 -05:00
parent a60e273c29
commit 352d0b4582
34 changed files with 230 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/verilated_profiler.cpp
View File

@ -173,7 +173,7 @@ void VlExecutionProfiler::dump(const char* filenamep, uint64_t tickEnd)
// Copy /proc/cpuinfo into this output so verilator_gantt can be run on
// a different machine
{
const std::unique_ptr<std::ifstream> ifp{new std::ifstream("/proc/cpuinfo")};
const std::unique_ptr<std::ifstream> ifp{new std::ifstream{"/proc/cpuinfo"}};
if (!ifp->fail()) {
std::string line;
while (std::getline(*ifp, line)) { fprintf(fp, "VLPROFPROC %s\n", line.c_str()); }

2
src/V3Config.cpp
View File

@ -291,7 +291,7 @@ public:
}
void addLineAttribute(int lineno, VPragmaType attr) { m_lineAttrs[lineno].set(attr); }
void addIgnore(V3ErrorCode code, int lineno, bool on) {
m_ignLines.insert(V3ConfigIgnoresLine(code, lineno, on));
m_ignLines.insert(V3ConfigIgnoresLine{code, lineno, on});
m_lastIgnore.it = m_ignLines.begin();
}
void addWaiver(V3ErrorCode code, const string& match) {

16
src/V3Descope.cpp
View File

@ -144,9 +144,9 @@ private:
for (AstNode* stmtp = newfuncp->argsp(); stmtp; stmtp = stmtp->nextp()) {
if (AstVar* const portp = VN_CAST(stmtp, Var)) {
if (portp->isIO() && !portp->isFuncReturn()) {
AstVarRef* const newp = new AstVarRef(
AstVarRef* const newp = new AstVarRef{
portp->fileline(), portp,
portp->isWritable() ? VAccess::WRITE : VAccess::READ);
portp->isWritable() ? VAccess::WRITE : VAccess::READ};
argsp = AstNode::addNext(argsp, newp);
}
}
@ -161,14 +161,14 @@ private:
AstNode* const returnp = new AstCReturn{funcp->fileline(), callp};
if (moreOfSame) {
AstIf* const ifp = new AstIf(
AstIf* const ifp = new AstIf{
funcp->fileline(),
new AstEq(
funcp->fileline(), new AstCExpr(funcp->fileline(), "this", 64),
new AstCExpr(funcp->fileline(),
new AstEq{
funcp->fileline(), new AstCExpr{funcp->fileline(), "this", 64},
new AstCExpr{funcp->fileline(),
string("&(") + funcp->scopep()->nameVlSym() + ")",
64)),
returnp);
64}},
returnp};
newfuncp->addStmtsp(ifp);
} else {
newfuncp->addStmtsp(returnp);

2
src/V3EmitCBase.cpp
View File

@ -58,7 +58,7 @@ string EmitCBaseVisitor::funcNameProtect(const AstCFunc* nodep, const AstNodeMod
}
AstCFile* EmitCBaseVisitor::newCFile(const string& filename, bool slow, bool source, bool add) {
AstCFile* const cfilep = new AstCFile(v3Global.rootp()->fileline(), filename);
AstCFile* const cfilep = new AstCFile{v3Global.rootp()->fileline(), filename};
cfilep->slow(slow);
cfilep->source(source);
if (add) v3Global.rootp()->addFilesp(cfilep);

2
src/V3EmitCConstPool.cpp
View File

@ -45,7 +45,7 @@ class EmitCConstPool final : public EmitCConstInit {
const string fileName = v3Global.opt.makeDir() + "/" + topClassName() + "__ConstPool_"
+ cvtToStr(m_outFileCount) + ".cpp";
newCFile(fileName, /* slow: */ true, /* source: */ true);
V3OutCFile* const ofp = new V3OutCFile(fileName);
V3OutCFile* const ofp = new V3OutCFile{fileName};
ofp->putsHeader();
ofp->puts("// DESCRIPTION: Verilator output: Constant pool\n");
ofp->puts("//\n");

4
src/V3EmitCHeaders.cpp
View File

@ -301,7 +301,7 @@ class EmitCHeader final : public EmitCConstInit {
// Open output file
const string filename = v3Global.opt.makeDir() + "/" + prefixNameProtect(modp) + ".h";
newCFile(filename, /* slow: */ false, /* source: */ false);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile(filename) : new V3OutCFile(filename);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile{filename} : new V3OutCFile{filename};
ofp()->putsHeader();
puts("// DESCRIPTION: Verilator output: Design internal header\n");
@ -333,7 +333,7 @@ class EmitCHeader final : public EmitCConstInit {
~EmitCHeader() override = default;
public:
static void main(const AstNodeModule* modp) { EmitCHeader emitCHeader(modp); }
static void main(const AstNodeModule* modp) { EmitCHeader emitCHeader{modp}; }
};
//######################################################################

12
src/V3EmitCImp.cpp
View File

@ -167,7 +167,7 @@ class EmitCImp final : EmitCFunc {
const string filename = VL_DEV_NULL;
m_cfilesr.push_back(
newCFile(filename, /* slow: */ m_slow, /* source: */ true, /* add */ false));
m_ofp = new V3OutCFile(filename);
m_ofp = new V3OutCFile{filename};
} else {
string filename = v3Global.opt.makeDir() + "/" + prefixNameProtect(m_fileModp);
if (!subFileName.empty()) {
@ -178,7 +178,7 @@ class EmitCImp final : EmitCFunc {
filename += ".cpp";
m_cfilesr.push_back(
newCFile(filename, /* slow: */ m_slow, /* source: */ true, /* add */ false));
m_ofp = v3Global.opt.systemC() ? new V3OutScFile(filename) : new V3OutCFile(filename);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile{filename} : new V3OutCFile{filename};
}
ofp()->putsHeader();
@ -593,9 +593,9 @@ class EmitCTrace final : EmitCFunc {
m_cfilesr.push_back(cfilep);
if (optSystemC()) {
m_ofp = new V3OutScFile(filename);
m_ofp = new V3OutScFile{filename};
} else {
m_ofp = new V3OutCFile(filename);
m_ofp = new V3OutCFile{filename};
}
m_ofp->putsHeader();
m_ofp->puts("// DESCR"
@ -937,10 +937,10 @@ void V3EmitC::emitcFiles() {
filep = VN_AS(filep->nextp(), NodeFile)) {
AstCFile* const cfilep = VN_CAST(filep, CFile);
if (cfilep && cfilep->tblockp()) {
V3OutCFile of(cfilep->name());
V3OutCFile of{cfilep->name()};
of.puts("// DESCR"
"IPTION: Verilator generated C++\n");
const EmitCFunc visitor(cfilep->tblockp(), &of, true);
const EmitCFunc visitor{cfilep->tblockp(), &of, true};
}
}
}

4
src/V3EmitCModel.cpp
View File

@ -59,7 +59,7 @@ class EmitCModel final : public EmitCFunc {
const string filename = v3Global.opt.makeDir() + "/" + topClassName() + ".h";
newCFile(filename, /* slow: */ false, /* source: */ false);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile(filename) : new V3OutCFile(filename);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile{filename} : new V3OutCFile{filename};
ofp()->putsHeader();
puts("// DESCRIPTION: Verilator output: Primary model header\n");
@ -598,7 +598,7 @@ class EmitCModel final : public EmitCFunc {
const string filename = v3Global.opt.makeDir() + "/" + topClassName() + ".cpp";
newCFile(filename, /* slow: */ false, /* source: */ true);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile(filename) : new V3OutCFile(filename);
m_ofp = v3Global.opt.systemC() ? new V3OutScFile{filename} : new V3OutCFile{filename};
ofp()->putsHeader();
puts("// DESCRIPTION: Verilator output: "

12
src/V3EmitCSyms.cpp
View File

@ -378,9 +378,9 @@ void EmitCSyms::emitSymHdr() {
newCFile(filename, true /*slow*/, false /*source*/);
if (v3Global.opt.systemC()) {
m_ofp = new V3OutScFile(filename);
m_ofp = new V3OutScFile{filename};
} else {
m_ofp = new V3OutCFile(filename);
m_ofp = new V3OutCFile{filename};
}
ofp()->putsHeader();
@ -569,9 +569,9 @@ void EmitCSyms::checkSplit(bool usesVfinal) {
closeSplit();
if (v3Global.opt.systemC()) {
m_ofp = new V3OutScFile(filename);
m_ofp = new V3OutScFile{filename};
} else {
m_ofp = new V3OutCFile(filename);
m_ofp = new V3OutCFile{filename};
}
m_ofpBase->puts(symClassName() + "_" + cvtToStr(m_funcNum) + "(");
@ -650,9 +650,9 @@ void EmitCSyms::emitSymImp() {
cfilep->support(true);
if (v3Global.opt.systemC()) {
m_ofp = new V3OutScFile(filename);
m_ofp = new V3OutScFile{filename};
} else {
m_ofp = new V3OutCFile(filename);
m_ofp = new V3OutCFile{filename};
}
m_ofpBase = m_ofp;

6
src/V3EmitMk.cpp
View File

@ -39,7 +39,7 @@ public:
void emitClassMake() {
// Generate the makefile
V3OutMkFile of(v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + "_classes.mk");
V3OutMkFile of{v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + "_classes.mk"};
of.putsHeader();
of.puts("# DESCR"
"IPTION: Verilator output: Make include file with class lists\n");
@ -135,7 +135,7 @@ public:
void emitOverallMake() {
// Generate the makefile
V3OutMkFile of(v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + ".mk");
V3OutMkFile of{v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + ".mk"};
of.putsHeader();
of.puts("# DESCR"
"IPTION: Verilator output: "
@ -398,7 +398,7 @@ public:
explicit EmitMkHierVerilation(const V3HierBlockPlan* planp)
: m_planp{planp}
, m_makefile{v3Global.opt.makeDir() + "/" + v3Global.opt.prefix() + "_hier.mk"} {
V3OutMkFile of(m_makefile);
V3OutMkFile of{m_makefile};
emit(of);
}
};

2
src/V3EmitV.cpp
View File

@ -880,7 +880,7 @@ void V3EmitV::emitvFiles() {
filep = VN_AS(filep->nextp(), NodeFile)) {
AstVFile* const vfilep = VN_CAST(filep, VFile);
if (vfilep && vfilep->tblockp()) {
V3OutVFile of(vfilep->name());
V3OutVFile of{vfilep->name()};
of.puts("// DESCR"
"IPTION: Verilator generated Verilog\n");
{ EmitVFileVisitor{vfilep->tblockp(), &of, true, false}; }

10
src/V3File.cpp
View File

@ -125,7 +125,7 @@ public:
if (m_filenameSet.find(filename) == m_filenameSet.end()) {
// cppcheck-suppress stlFindInsert // cppcheck 1.90 bug
m_filenameSet.insert(filename);
DependFile df(filename, false);
DependFile df{filename, false};
df.loadStats(); // Get size now, in case changes during the run
m_filenameList.insert(df);
}
@ -134,7 +134,7 @@ public:
if (m_filenameSet.find(filename) == m_filenameSet.end()) {
// cppcheck-suppress stlFindInsert // cppcheck 1.90 bug
m_filenameSet.insert(filename);
m_filenameList.insert(DependFile(filename, true));
m_filenameList.insert(DependFile{filename, true});
}
}
void writeDepend(const string& filename);
@ -603,7 +603,7 @@ protected:
// VInFilter
// Just dispatch to the implementation
VInFilter::VInFilter(const string& command) { m_impp = new VInFilterImp(command); }
VInFilter::VInFilter(const string& command) { m_impp = new VInFilterImp{command}; }
VInFilter::~VInFilter() {
if (m_impp) VL_DO_CLEAR(delete m_impp, m_impp = nullptr);
}
@ -1002,7 +1002,7 @@ public:
// missing a protect()
out = "PS" + old;
} else {
VHashSha256 digest(v3Global.opt.protectKeyDefaulted());
VHashSha256 digest{v3Global.opt.protectKeyDefaulted()};
digest.insert(old);
// Add "PS" prefix (Protect Symbols) as cannot start symbol with number
out = "PS" + digest.digestSymbol();
@ -1044,7 +1044,7 @@ public:
return out;
}
void writeMapFile(const string& filename) const {
V3OutXmlFile of(filename);
V3OutXmlFile of{filename};
of.putsHeader();
of.puts("<!-- DESCR"
"IPTION: Verilator output: XML representation of netlist -->\n");

4
src/V3FileLine.cpp
View File

@ -279,7 +279,7 @@ FileLine* FileLine::copyOrSameFileLine() {
if (lastNewp && *lastNewp == *this) { // Compares lineno, filename, etc
return lastNewp;
}
FileLine* const newp = new FileLine(this);
FileLine* const newp = new FileLine{this};
lastNewp = newp;
return newp;
}
@ -340,7 +340,7 @@ bool FileLine::warnOff(const string& msg, bool flag) {
warnOff(V3ErrorCode::UNUSEDSIGNAL, flag);
return true;
}
const V3ErrorCode code(cmsg);
const V3ErrorCode code{cmsg};
if (code < V3ErrorCode::EC_FIRST_WARN) {
return false;
} else {

4
src/V3Graph.cpp
View File

@ -80,9 +80,9 @@ void V3GraphVertex::rerouteEdges(V3Graph* graphp) {
// Make new edges for each from/to pair
for (V3GraphEdge* iedgep = inBeginp(); iedgep; iedgep = iedgep->inNextp()) {
for (V3GraphEdge* oedgep = outBeginp(); oedgep; oedgep = oedgep->outNextp()) {
new V3GraphEdge(graphp, iedgep->fromp(), oedgep->top(),
new V3GraphEdge{graphp, iedgep->fromp(), oedgep->top(),
std::min(iedgep->weight(), oedgep->weight()),
iedgep->cutable() && oedgep->cutable());
iedgep->cutable() && oedgep->cutable()};
}
}
// Remove old edges

10
src/V3GraphAcyc.cpp
View File

@ -126,8 +126,8 @@ private:
}
V3GraphEdge* edgeFromEdge(V3GraphEdge* oldedgep, V3GraphVertex* fromp, V3GraphVertex* top) {
// Make new breakGraph edge, with old edge as a template
GraphAcycEdge* const newEdgep = new GraphAcycEdge(&m_breakGraph, fromp, top,
oldedgep->weight(), oldedgep->cutable());
GraphAcycEdge* const newEdgep = new GraphAcycEdge{&m_breakGraph, fromp, top,
oldedgep->weight(), oldedgep->cutable()};
newEdgep->userp(oldedgep->userp()); // Keep pointer to OrigEdgeList
return newEdgep;
}
@ -203,7 +203,7 @@ void GraphAcyc::buildGraph(V3Graph* origGraphp) {
for (V3GraphVertex* overtexp = origGraphp->verticesBeginp(); overtexp;
overtexp = overtexp->verticesNextp()) {
if (overtexp->color()) {
GraphAcycVertex* const avertexp = new GraphAcycVertex(&m_breakGraph, overtexp);
GraphAcycVertex* const avertexp = new GraphAcycVertex{&m_breakGraph, overtexp};
overtexp->userp(avertexp); // Stash so can look up later
}
}
@ -228,8 +228,8 @@ void GraphAcyc::buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* aver
= static_cast<GraphAcycVertex*>(toVertexp->userp());
// Replicate the old edge into the new graph
// There may be multiple edges between same pairs of vertices
V3GraphEdge* breakEdgep = new GraphAcycEdge(&m_breakGraph, avertexp, toAVertexp,
edgep->weight(), edgep->cutable());
V3GraphEdge* breakEdgep = new GraphAcycEdge{&m_breakGraph, avertexp, toAVertexp,
edgep->weight(), edgep->cutable()};
addOrigEdgep(breakEdgep, edgep); // So can find original edge
}
}

12
src/V3GraphAlg.cpp
View File

@ -106,7 +106,7 @@ public:
explicit GraphAlgRemoveTransitiveEdges(V3Graph* graphp)
: GraphAlg<>(graphp, nullptr) {}
void go() {
GraphPathChecker checker(m_graphp);
GraphPathChecker checker{m_graphp};
for (V3GraphVertex* vxp = m_graphp->verticesBeginp(); vxp; vxp = vxp->verticesNextp()) {
V3GraphEdge* deletep = nullptr;
for (V3GraphEdge* edgep = vxp->outBeginp(); edgep; edgep = edgep->outNextp()) {
@ -125,7 +125,7 @@ private:
VL_UNCOPYABLE(GraphAlgRemoveTransitiveEdges);
};
void V3Graph::removeTransitiveEdges() { GraphAlgRemoveTransitiveEdges(this).go(); }
void V3Graph::removeTransitiveEdges() { GraphAlgRemoveTransitiveEdges{this}.go(); }
//######################################################################
//######################################################################
@ -166,7 +166,7 @@ public:
~GraphAlgWeakly() = default;
};
void V3Graph::weaklyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgWeakly(this, edgeFuncp); }
void V3Graph::weaklyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgWeakly{this, edgeFuncp}; }
//######################################################################
//######################################################################
@ -257,7 +257,7 @@ public:
~GraphAlgStrongly() = default;
};
void V3Graph::stronglyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgStrongly(this, edgeFuncp); }
void V3Graph::stronglyConnected(V3EdgeFuncP edgeFuncp) { GraphAlgStrongly{this, edgeFuncp}; }
//######################################################################
//######################################################################
@ -310,9 +310,9 @@ public:
~GraphAlgRank() = default;
};
void V3Graph::rank() { GraphAlgRank(this, &V3GraphEdge::followAlwaysTrue); }
void V3Graph::rank() { GraphAlgRank{this, &V3GraphEdge::followAlwaysTrue}; }
void V3Graph::rank(V3EdgeFuncP edgeFuncp) { GraphAlgRank(this, edgeFuncp); }
void V3Graph::rank(V3EdgeFuncP edgeFuncp) { GraphAlgRank{this, edgeFuncp}; }
//######################################################################
//######################################################################

174
src/V3GraphTest.cpp
View File

@ -83,24 +83,24 @@ public:
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
V3GraphTestVertex* i = new V3GraphTestVarVertex(gp, "*INPUTS*");
V3GraphTestVertex* a = new V3GraphTestVarVertex(gp, "a");
V3GraphTestVertex* b = new V3GraphTestVarVertex(gp, "b");
V3GraphTestVertex* g1 = new V3GraphTestVarVertex(gp, "g1");
V3GraphTestVertex* g2 = new V3GraphTestVarVertex(gp, "g2");
V3GraphTestVertex* g3 = new V3GraphTestVarVertex(gp, "g3");
V3GraphTestVertex* q = new V3GraphTestVarVertex(gp, "q");
new V3GraphEdge(gp, i, a, 2, true);
new V3GraphEdge(gp, a, b, 2, true);
new V3GraphEdge(gp, b, g1, 2, true);
new V3GraphEdge(gp, b, g2, 2, true);
new V3GraphEdge(gp, b, g3, 2, true);
new V3GraphEdge(gp, g1, a, 2, true);
new V3GraphEdge(gp, g3, g2, 2, true);
new V3GraphEdge(gp, g2, g3, 2, true);
new V3GraphEdge(gp, g1, q, 2, true);
new V3GraphEdge(gp, g2, q, 2, true);
new V3GraphEdge(gp, g3, q, 2, true);
V3GraphTestVertex* i = new V3GraphTestVarVertex{gp, "*INPUTS*"};
V3GraphTestVertex* a = new V3GraphTestVarVertex{gp, "a"};
V3GraphTestVertex* b = new V3GraphTestVarVertex{gp, "b"};
V3GraphTestVertex* g1 = new V3GraphTestVarVertex{gp, "g1"};
V3GraphTestVertex* g2 = new V3GraphTestVarVertex{gp, "g2"};
V3GraphTestVertex* g3 = new V3GraphTestVarVertex{gp, "g3"};
V3GraphTestVertex* q = new V3GraphTestVarVertex{gp, "q"};
new V3GraphEdge{gp, i, a, 2, true};
new V3GraphEdge{gp, a, b, 2, true};
new V3GraphEdge{gp, b, g1, 2, true};
new V3GraphEdge{gp, b, g2, 2, true};
new V3GraphEdge{gp, b, g3, 2, true};
new V3GraphEdge{gp, g1, a, 2, true};
new V3GraphEdge{gp, g3, g2, 2, true};
new V3GraphEdge{gp, g2, g3, 2, true};
new V3GraphEdge{gp, g1, q, 2, true};
new V3GraphEdge{gp, g2, q, 2, true};
new V3GraphEdge{gp, g3, q, 2, true};
gp->stronglyConnected(&V3GraphEdge::followAlwaysTrue);
dumpSelf();
@ -121,20 +121,20 @@ public:
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
V3GraphTestVertex* i = new V3GraphTestVarVertex(gp, "*INPUTS*");
V3GraphTestVertex* a = new V3GraphTestVarVertex(gp, "a");
V3GraphTestVertex* b = new V3GraphTestVarVertex(gp, "b");
V3GraphTestVertex* g1 = new V3GraphTestVarVertex(gp, "g1");
V3GraphTestVertex* g2 = new V3GraphTestVarVertex(gp, "g2");
V3GraphTestVertex* g3 = new V3GraphTestVarVertex(gp, "g3");
new V3GraphEdge(gp, i, a, 2, true);
new V3GraphEdge(gp, a, b, 2, true);
new V3GraphEdge(gp, b, g1, 2, true);
new V3GraphEdge(gp, b, g2, 2, true);
new V3GraphEdge(gp, b, g3, 2, true);
new V3GraphEdge(gp, g1, a, 2, true);
new V3GraphEdge(gp, g2, a, 2, true);
new V3GraphEdge(gp, g3, a, 2, true);
V3GraphTestVertex* i = new V3GraphTestVarVertex{gp, "*INPUTS*"};
V3GraphTestVertex* a = new V3GraphTestVarVertex{gp, "a"};
V3GraphTestVertex* b = new V3GraphTestVarVertex{gp, "b"};
V3GraphTestVertex* g1 = new V3GraphTestVarVertex{gp, "g1"};
V3GraphTestVertex* g2 = new V3GraphTestVarVertex{gp, "g2"};
V3GraphTestVertex* g3 = new V3GraphTestVarVertex{gp, "g3"};
new V3GraphEdge{gp, i, a, 2, true};
new V3GraphEdge{gp, a, b, 2, true};
new V3GraphEdge{gp, b, g1, 2, true};
new V3GraphEdge{gp, b, g2, 2, true};
new V3GraphEdge{gp, b, g3, 2, true};
new V3GraphEdge{gp, g1, a, 2, true};
new V3GraphEdge{gp, g2, a, 2, true};
new V3GraphEdge{gp, g3, a, 2, true};
gp->acyclic(&V3GraphEdge::followAlwaysTrue);
gp->order();
@ -148,20 +148,20 @@ public:
void runTest() override {
V3Graph* gp = &m_graph;
V3GraphTestVertex* clk = new V3GraphTestVarVertex(gp, "$clk");
V3GraphTestVertex* clk = new V3GraphTestVarVertex{gp, "$clk"};
V3GraphTestVertex* a = new V3GraphTestVarVertex(gp, "$a");
V3GraphTestVertex* a_dly = new V3GraphTestVarVertex(gp, "$a_dly");
V3GraphTestVertex* a_dlyblk = new V3GraphTestVarVertex(gp, "$a_dlyblk");
V3GraphTestVertex* b = new V3GraphTestVarVertex(gp, "$b");
V3GraphTestVertex* b_dly = new V3GraphTestVarVertex(gp, "$b_dly");
V3GraphTestVertex* b_dlyblk = new V3GraphTestVarVertex(gp, "$b_dlyblk");
V3GraphTestVertex* c = new V3GraphTestVarVertex(gp, "$c");
V3GraphTestVertex* i = new V3GraphTestVarVertex(gp, "$i");
V3GraphTestVertex* a = new V3GraphTestVarVertex{gp, "$a"};
V3GraphTestVertex* a_dly = new V3GraphTestVarVertex{gp, "$a_dly"};
V3GraphTestVertex* a_dlyblk = new V3GraphTestVarVertex{gp, "$a_dlyblk"};
V3GraphTestVertex* b = new V3GraphTestVarVertex{gp, "$b"};
V3GraphTestVertex* b_dly = new V3GraphTestVarVertex{gp, "$b_dly"};
V3GraphTestVertex* b_dlyblk = new V3GraphTestVarVertex{gp, "$b_dlyblk"};
V3GraphTestVertex* c = new V3GraphTestVarVertex{gp, "$c"};
V3GraphTestVertex* i = new V3GraphTestVarVertex{gp, "$i"};
V3GraphTestVertex* ap = new V3GraphTestVarVertex(gp, "$a_pre");
V3GraphTestVertex* bp = new V3GraphTestVarVertex(gp, "$b_pre");
V3GraphTestVertex* cp = new V3GraphTestVarVertex(gp, "$c_pre");
V3GraphTestVertex* ap = new V3GraphTestVarVertex{gp, "$a_pre"};
V3GraphTestVertex* bp = new V3GraphTestVarVertex{gp, "$b_pre"};
V3GraphTestVertex* cp = new V3GraphTestVarVertex{gp, "$c_pre"};
V3GraphTestVertex* n;
@ -176,68 +176,68 @@ public:
// Desired order between different _DLY blocks so we can elim temporaries
// implemented by cutable "pre" signal dependencies
n = new V3GraphTestVertex(gp, "*INPUTS*");
n = new V3GraphTestVertex{gp, "*INPUTS*"};
{
new V3GraphEdge(gp, n, clk, 2);
new V3GraphEdge(gp, n, i, 2);
new V3GraphEdge{gp, n, clk, 2};
new V3GraphEdge{gp, n, i, 2};
}
V3GraphTestVertex* posedge = n = new V3GraphTestVertex(gp, "*posedge clk*");
{ new V3GraphEdge(gp, clk, n, 2); }
V3GraphTestVertex* posedge = n = new V3GraphTestVertex{gp, "*posedge clk*"};
{ new V3GraphEdge{gp, clk, n, 2}; }
// AssignPre's VarRefs on LHS: generate special BLK
// normal: VarRefs on LHS: generate normal
// underSBlock: VarRefs on RHS: consume 'pre' (required to save cutable tests)
n = new V3GraphTestVertex(gp, "a_dly<PRE=a");
n = new V3GraphTestVertex{gp, "a_dly<PRE=a"};
{
new V3GraphEdge(gp, n, a_dlyblk, 2); // Block ordering
new V3GraphEdge(gp, n, a_dly, 2);
new V3GraphEdge(gp, ap, n, 2, true); // DESIRED delayed ordering (inp is required)
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, n, a_dlyblk, 2}; // Block ordering
new V3GraphEdge{gp, n, a_dly, 2};
new V3GraphEdge{gp, ap, n, 2, true}; // DESIRED delayed ordering (inp is required)
new V3GraphEdge{gp, posedge, n, 2};
}
n = new V3GraphTestVertex(gp, "b_dly<PRE=b");
n = new V3GraphTestVertex{gp, "b_dly<PRE=b"};
{
new V3GraphEdge(gp, n, b_dlyblk, 2); // Block ordering
new V3GraphEdge(gp, n, b_dly, 2);
new V3GraphEdge(gp, bp, n, 2, true); // DESIRED delayed ordering
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, n, b_dlyblk, 2}; // Block ordering
new V3GraphEdge{gp, n, b_dly, 2};
new V3GraphEdge{gp, bp, n, 2, true}; // DESIRED delayed ordering
new V3GraphEdge{gp, posedge, n, 2};
}
// AssignDly's VarRefs on LHS: consume special BLK
// normal: VarRefs on LHS: generate normal
// underSBlock: VarRefs on RHS: generate 'pre' signals (cutable)
// SenItems: consume CLOCK dependency
n = new V3GraphTestVertex(gp, "a_dly<=b|c");
n = new V3GraphTestVertex{gp, "a_dly<=b|c"};
{
new V3GraphEdge(gp, a_dlyblk, n, 2); // Block ordering in
new V3GraphEdge(gp, n, a_dly, 2);
new V3GraphEdge{gp, a_dlyblk, n, 2}; // Block ordering in
new V3GraphEdge{gp, n, a_dly, 2};
// Note we don't include ap as we're generating a_dly
new V3GraphEdge(gp, n, bp, 2); // DESIRED delayed usage
new V3GraphEdge(gp, n, cp, 2); // DESIRED delayed usage
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, n, bp, 2}; // DESIRED delayed usage
new V3GraphEdge{gp, n, cp, 2}; // DESIRED delayed usage
new V3GraphEdge{gp, posedge, n, 2};
}
n = new V3GraphTestVertex(gp, "b_dly<=a");
n = new V3GraphTestVertex{gp, "b_dly<=a"};
{
new V3GraphEdge(gp, b_dlyblk, n, 2); // Block ordering in
new V3GraphEdge(gp, n, b_dly, 2);
new V3GraphEdge(gp, n, ap, 2); // DESIRED delayed usage
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, b_dlyblk, n, 2}; // Block ordering in
new V3GraphEdge{gp, n, b_dly, 2};
new V3GraphEdge{gp, n, ap, 2}; // DESIRED delayed usage
new V3GraphEdge{gp, posedge, n, 2};
}
// AssignPost's
// normal: VarRefs on LHS: generate normal
// underSBlock: VarRefs on RHS: consume normal
n = new V3GraphTestVertex(gp, "a=POST=a_dly");
n = new V3GraphTestVertex{gp, "a=POST=a_dly"};
{
new V3GraphEdge(gp, n, a, 3);
new V3GraphEdge(gp, a_dly, n, 3);
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, n, a, 3};
new V3GraphEdge{gp, a_dly, n, 3};
new V3GraphEdge{gp, posedge, n, 2};
}
n = new V3GraphTestVertex(gp, "b=POST=b_dly");
n = new V3GraphTestVertex{gp, "b=POST=b_dly"};
{
new V3GraphEdge(gp, n, b, 3);
new V3GraphEdge(gp, b_dly, n, 3);
new V3GraphEdge(gp, posedge, n, 2);
new V3GraphEdge{gp, n, b, 3};
new V3GraphEdge{gp, b_dly, n, 3};
new V3GraphEdge{gp, posedge, n, 2};
}
// COMBO
@ -245,11 +245,11 @@ public:
// Outbound are cutable, as we may need to evaluate multiple times
{
n = new V3GraphTestVertex(gp, "c=a|b|i");
new V3GraphEdge(gp, n, c, 1, true);
new V3GraphEdge(gp, a, n, 1, false);
new V3GraphEdge(gp, b, n, 1, false);
new V3GraphEdge(gp, i, n, 1, false);
n = new V3GraphTestVertex{gp, "c=a|b|i"};
new V3GraphEdge{gp, n, c, 1, true};
new V3GraphEdge{gp, a, n, 1, false};
new V3GraphEdge{gp, b, n, 1, false};
new V3GraphEdge{gp, i, n, 1, false};
}
gp->acyclic(&V3GraphEdge::followAlwaysTrue);
@ -294,9 +294,9 @@ void V3Graph::selfTest() {
// Execute all of the tests
UINFO(2, __FUNCTION__ << ": " << endl);
// clang-format off
{ V3GraphTestStrong test; test.run(); }
{ V3GraphTestAcyc test; test.run(); }
{ V3GraphTestVars test; test.run(); }
{ V3GraphTestImport test; test.run(); }
{ V3GraphTestStrong{}.run(); }
{ V3GraphTestAcyc{}.run(); }
{ V3GraphTestVars{}.run(); }
{ V3GraphTestImport{}.run(); }
// clang-format on
}

2
src/V3Hash.h
View File

@ -59,7 +59,7 @@ public:
// '+' combines hashes
template <class T>
V3Hash operator+(T that) const {
return V3Hash(combine(m_value, V3Hash(that).m_value));
return V3Hash(combine(m_value, V3Hash{that}.m_value));
}
// '+=' combines in place

10
src/V3Hasher.cpp
View File

@ -42,11 +42,11 @@ private:
std::function<void()>&& f) {
// See comments in visit(AstCFunc) about this breaking recursion
if (m_cacheInUser4 && nodep->user4()) {
return V3Hash(nodep->user4());
return V3Hash{nodep->user4()};
} else {
VL_RESTORER(m_hash);
// Reset accumulator
m_hash = V3Hash(nodep->type()); // Node type
m_hash = V3Hash{nodep->type()}; // Node type
f(); // Node specific hash
if (hashDType && nodep != nodep->dtypep()) iterateNull(nodep->dtypep()); // Node dtype
if (hashChildren) iterateChildrenConst(nodep); // Children
@ -401,7 +401,7 @@ private:
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.
nodep->user4(V3Hash(1).value()); // Set this "first" call
nodep->user4(V3Hash{1}.value()); // Set this "first" call
// So that a second call will then exit hashNodeAndIterate
// Having a constant in the hash just means the recursion will
// end, it shouldn't change the CFunc having a unique hash itself.
@ -518,13 +518,13 @@ public:
V3Hash V3Hasher::operator()(AstNode* nodep) const {
if (!nodep->user4()) HasherVisitor{nodep};
return V3Hash(nodep->user4());
return V3Hash{nodep->user4()};
}
V3Hash V3Hasher::rehash(AstNode* nodep) const {
nodep->user4(0);
{ HasherVisitor{nodep}; }
return V3Hash(nodep->user4());
return V3Hash{nodep->user4()};
}
V3Hash V3Hasher::uncachedHash(const AstNode* nodep) {

2
src/V3HierBlock.cpp
View File

@ -311,7 +311,7 @@ public:
void V3HierBlockPlan::add(const AstNodeModule* modp, const std::vector<AstVar*>& gparams) {
const iterator it = m_blocks.find(modp);
if (it == m_blocks.end()) {
V3HierBlock* hblockp = new V3HierBlock(modp, gparams);
V3HierBlock* hblockp = new V3HierBlock{modp, gparams};
UINFO(3, "Add " << modp->prettyNameQ() << " with " << gparams.size() << " parameters"
<< std::endl);
m_blocks.emplace(modp, hblockp);

24
src/V3Inline.cpp
View File

@ -292,8 +292,8 @@ private:
UASSERT_OBJ(exprconstp || exprvarrefp, nodep,
"Unknown interconnect type; pinReconnectSimple should have cleared up");
if (exprconstp) {
m_modp->addStmtsp(new AstAssignW(flp, new AstVarRef(flp, nodep, VAccess::WRITE),
exprconstp->cloneTree(false)));
m_modp->addStmtsp(new AstAssignW{flp, new AstVarRef{flp, nodep, VAccess::WRITE},
exprconstp->cloneTree(false)});
} else if (nodep->user3()) {
// Public variable at the lower module end - we need to make sure we propagate
// the logic changes up and down; if we aliased, we might
@ -301,8 +301,8 @@ private:
UINFO(9, "public pin assign: " << exprvarrefp << endl);
UASSERT_OBJ(!nodep->isNonOutput(), nodep, "Outputs only - inputs use AssignAlias");
m_modp->addStmtsp(
new AstAssignW(flp, new AstVarRef(flp, exprvarrefp->varp(), VAccess::WRITE),
new AstVarRef(flp, nodep, VAccess::READ)));
new AstAssignW{flp, new AstVarRef{flp, exprvarrefp->varp(), VAccess::WRITE},
new AstVarRef{flp, nodep, VAccess::READ}});
} else if (nodep->isSigPublic() && VN_IS(nodep->dtypep(), UnpackArrayDType)) {
// Public variable at this end and it is an unpacked array. We need to assign
// instead of aliased, because otherwise it will pass V3Slice and invalid
@ -313,8 +313,8 @@ private:
new AstVarRef{flp, exprvarrefp->varp(), VAccess::READ}});
} else if (nodep->isIfaceRef()) {
m_modp->addStmtsp(
new AstAssignVarScope(flp, new AstVarRef(flp, nodep, VAccess::WRITE),
new AstVarRef(flp, exprvarrefp->varp(), VAccess::READ)));
new AstAssignVarScope{flp, new AstVarRef{flp, nodep, VAccess::WRITE},
new AstVarRef{flp, exprvarrefp->varp(), VAccess::READ}});
FileLine* const flbp = exprvarrefp->varp()->fileline();
flp->modifyStateInherit(flbp);
flbp->modifyStateInherit(flp);
@ -322,8 +322,8 @@ private:
// Do to inlining child's variable now within the same
// module, so a AstVarRef not AstVarXRef below
m_modp->addStmtsp(
new AstAssignAlias(flp, new AstVarRef(flp, nodep, VAccess::WRITE),
new AstVarRef(flp, exprvarrefp->varp(), VAccess::READ)));
new AstAssignAlias{flp, new AstVarRef{flp, nodep, VAccess::WRITE},
new AstVarRef{flp, exprvarrefp->varp(), VAccess::READ}});
FileLine* const flbp = exprvarrefp->varp()->fileline();
flp->modifyStateInherit(flbp);
flbp->modifyStateInherit(flp);
@ -519,8 +519,8 @@ private:
});
// Create data for dotted variable resolution
AstCellInline* const inlinep
= new AstCellInline(nodep->fileline(), nodep->name(), nodep->modp()->origName(),
nodep->modp()->timeunit());
= new AstCellInline{nodep->fileline(), nodep->name(), nodep->modp()->origName(),
nodep->modp()->timeunit()};
m_modp->addInlinesp(inlinep); // Must be parsed before any AstCells
// Create assignments to the pins
for (AstPin* pinp = nodep->pinsp(); pinp; pinp = VN_AS(pinp->nextp(), Pin)) {
@ -659,7 +659,7 @@ private:
if ((cellp = VN_CAST(fromVarp->user1p(), Cell)) || (cellp = irdtp->cellp())) {
varp->user1p(cellp);
const string alias = m_scope + "__DOT__" + pinp->name();
cellp->addIntfRefsp(new AstIntfRef(pinp->fileline(), alias));
cellp->addIntfRefsp(new AstIntfRef{pinp->fileline(), alias});
}
}
@ -688,7 +688,7 @@ private:
string alias;
if (!m_scope.empty()) alias = m_scope + "__DOT__";
alias += varlp->name();
cellp->addIntfRefsp(new AstIntfRef(varlp->fileline(), alias));
cellp->addIntfRefsp(new AstIntfRef{varlp->fileline(), alias});
}
//--------------------
void visit(AstNodeExpr*) override {} // Accelerate

12
src/V3Life.cpp
View File

@ -350,8 +350,8 @@ private:
// Condition is part of PREVIOUS block
iterateAndNextNull(nodep->condp());
LifeBlock* const prevLifep = m_lifep;
LifeBlock* const ifLifep = new LifeBlock(prevLifep, m_statep);
LifeBlock* const elseLifep = new LifeBlock(prevLifep, m_statep);
LifeBlock* const ifLifep = new LifeBlock{prevLifep, m_statep};
LifeBlock* const elseLifep = new LifeBlock{prevLifep, m_statep};
{
m_lifep = ifLifep;
iterateAndNextNull(nodep->thensp());
@ -380,8 +380,8 @@ private:
// it as a IF statement, and just don't allow elimination of
// variables across the body.
LifeBlock* const prevLifep = m_lifep;
LifeBlock* const condLifep = new LifeBlock(prevLifep, m_statep);
LifeBlock* const bodyLifep = new LifeBlock(prevLifep, m_statep);
LifeBlock* const condLifep = new LifeBlock{prevLifep, m_statep};
LifeBlock* const bodyLifep = new LifeBlock{prevLifep, m_statep};
{
m_lifep = condLifep;
iterateAndNextNull(nodep->precondsp());
@ -405,7 +405,7 @@ private:
// 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.
LifeBlock* const prevLifep = m_lifep;
LifeBlock* const bodyLifep = new LifeBlock(prevLifep, m_statep);
LifeBlock* const bodyLifep = new LifeBlock{prevLifep, m_statep};
{
VL_RESTORER(m_noopt);
m_lifep = bodyLifep;
@ -461,7 +461,7 @@ public:
: m_statep{statep} {
UINFO(4, " LifeVisitor on " << nodep << endl);
{
m_lifep = new LifeBlock(nullptr, m_statep);
m_lifep = new LifeBlock{nullptr, m_statep};
iterate(nodep);
if (m_lifep) VL_DO_CLEAR(delete m_lifep, m_lifep = nullptr);
}

2
src/V3LifePost.cpp
View File

@ -263,7 +263,7 @@ private:
if (v3Global.opt.mtasks()) {
UASSERT_OBJ(m_mtasksGraphp, nodep, "Should have initted m_mtasksGraphp by now");
m_checker.reset(new GraphPathChecker(m_mtasksGraphp));
m_checker.reset(new GraphPathChecker{m_mtasksGraphp});
} else {
UASSERT_OBJ(!m_mtasksGraphp, nodep,
"Did not expect any m_mtasksGraphp in serial mode");

22
src/V3LinkLevel.cpp
View File

@ -147,7 +147,7 @@ void V3LinkLevel::wrapTop(AstNetlist* rootp) {
return;
}
AstNodeModule* const newmodp = new AstModule(oldmodp->fileline(), "$root");
AstNodeModule* const newmodp = new AstModule{oldmodp->fileline(), "$root"};
newmodp->name(AstNode::encodeName(newmodp->name())); // so origName is nice
// Make the new module first in the list
oldmodp->unlinkFrBackWithNext();
@ -167,10 +167,10 @@ void V3LinkLevel::wrapTop(AstNetlist* rootp) {
for (AstNodeModule* modp = rootp->modulesp(); modp; modp = VN_AS(modp->nextp(), NodeModule)) {
if (VN_IS(modp, Package)) {
AstCell* const cellp
= new AstCell(modp->fileline(), modp->fileline(),
= new AstCell{modp->fileline(), modp->fileline(),
// Could add __03a__03a="::" to prevent conflict
// with module names/"v"
modp->name(), modp->name(), nullptr, nullptr, nullptr);
modp->name(), modp->name(), nullptr, nullptr, nullptr};
cellp->modp(modp);
newmodp->addStmtsp(cellp);
}
@ -240,10 +240,14 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) {
if (VN_IS(oldmodp, Package)) continue;
// Add instance
UINFO(5, "LOOP " << oldmodp << endl);
AstCell* const cellp = new AstCell(
newmodp->fileline(), newmodp->fileline(),
AstCell* const cellp = new AstCell{
newmodp->fileline(),
newmodp->fileline(),
(!v3Global.opt.l2Name().empty() ? v3Global.opt.l2Name() : oldmodp->name()),
oldmodp->name(), nullptr, nullptr, nullptr);
oldmodp->name(),
nullptr,
nullptr,
nullptr};
cellp->modp(oldmodp);
newmodp->addStmtsp(cellp);
@ -279,10 +283,10 @@ void V3LinkLevel::wrapTopCell(AstNetlist* rootp) {
varp->trace(false);
}
AstPin* const pinp = new AstPin(
AstPin* const pinp = new AstPin{
oldvarp->fileline(), 0, varp->name(),
new AstVarRef(varp->fileline(), varp,
oldvarp->isWritable() ? VAccess::WRITE : VAccess::READ));
new AstVarRef{varp->fileline(), varp,
oldvarp->isWritable() ? VAccess::WRITE : VAccess::READ}};
// Skip length and width comp; we know it's a direct assignment
pinp->modVarp(oldvarp);
cellp->addPinsp(pinp);

26
src/V3LinkResolve.cpp
View File

@ -152,21 +152,21 @@ private:
AstNode* const basefromp = AstArraySel::baseFromp(nodep, false);
if (AstNodeVarRef* const varrefp
= VN_CAST(basefromp, NodeVarRef)) { // Maybe varxref - so need to clone
nodep->attrp(new AstAttrOf(nodep->fileline(), VAttrType::VAR_BASE,
varrefp->cloneTree(false)));
nodep->attrp(new AstAttrOf{nodep->fileline(), VAttrType::VAR_BASE,
varrefp->cloneTree(false)});
} else if (AstUnlinkedRef* const uvxrp
= VN_CAST(basefromp, UnlinkedRef)) { // Maybe unlinked - so need to clone
nodep->attrp(new AstAttrOf(nodep->fileline(), VAttrType::VAR_BASE,
uvxrp->cloneTree(false)));
nodep->attrp(new AstAttrOf{nodep->fileline(), VAttrType::VAR_BASE,
uvxrp->cloneTree(false)});
} else if (auto* const fromp = VN_CAST(basefromp, LambdaArgRef)) {
nodep->attrp(new AstAttrOf(nodep->fileline(), VAttrType::VAR_BASE,
fromp->cloneTree(false)));
nodep->attrp(new AstAttrOf{nodep->fileline(), VAttrType::VAR_BASE,
fromp->cloneTree(false)});
} else if (AstMemberSel* const fromp = VN_CAST(basefromp, MemberSel)) {
nodep->attrp(new AstAttrOf(nodep->fileline(), VAttrType::MEMBER_BASE,
fromp->cloneTree(false)));
nodep->attrp(new AstAttrOf{nodep->fileline(), VAttrType::MEMBER_BASE,
fromp->cloneTree(false)});
} else if (AstEnumItemRef* const fromp = VN_CAST(basefromp, EnumItemRef)) {
nodep->attrp(new AstAttrOf(nodep->fileline(), VAttrType::ENUM_BASE,
fromp->cloneTree(false)));
nodep->attrp(new AstAttrOf{nodep->fileline(), VAttrType::ENUM_BASE,
fromp->cloneTree(false)});
} else if (VN_IS(basefromp, Replicate)) {
// From {...}[...] syntax in IEEE 2017
if (basefromp) UINFO(1, " Related node: " << basefromp << endl);
@ -412,9 +412,9 @@ private:
varoutp = varp;
// Tie off
m_modp->addStmtsp(
new AstAssignW(varp->fileline(),
new AstVarRef(varp->fileline(), varp, VAccess::WRITE),
new AstConst(varp->fileline(), AstConst::BitFalse())));
new AstAssignW{varp->fileline(),
new AstVarRef{varp->fileline(), varp, VAccess::WRITE},
new AstConst{varp->fileline(), AstConst::BitFalse{}}});
} else {
varp->v3error("Only inputs and outputs are allowed in udp modules");
}

10
src/V3Options.cpp
View File

@ -133,7 +133,7 @@ VTimescale::VTimescale(const string& value, bool& badr)
badr = true;
const string spaceless = VString::removeWhitespace(value);
for (int i = TS_100S; i < _ENUM_END; ++i) {
const VTimescale ts(i);
const VTimescale ts{i};
if (spaceless == ts.ascii()) {
badr = false;
m_e = ts.m_e;
@ -258,7 +258,7 @@ void VTimescale::parseSlashed(FileLine* fl, const char* textp, VTimescale& unitr
}
bool unitbad;
const VTimescale unit(unitStr, unitbad /*ref*/);
const VTimescale unit{unitStr, unitbad /*ref*/};
if (unitbad && !(unitStr.empty() && allowEmpty)) {
fl->v3error("`timescale timeunit syntax error: '" << unitStr << "'");
return;
@ -863,7 +863,7 @@ string V3Options::protectKeyDefaulted() {
if (m_protectKey.empty()) {
// Create a key with a human-readable symbol-like name.
// This conversion drops ~2 bits of entropy out of 256, shouldn't matter.
VHashSha256 digest(V3Os::trueRandom(32));
VHashSha256 digest{V3Os::trueRandom(32)};
m_protectKey = "VL-KEY-" + digest.digestSymbol();
}
return m_protectKey;
@ -1198,7 +1198,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char
DECL_OPTION("-hierarchical", OnOff, &m_hierarchical);
DECL_OPTION("-hierarchical-block", CbVal, [this](const char* valp) {
const V3HierarchicalBlockOption opt(valp);
const V3HierarchicalBlockOption opt{valp};
m_hierBlocks.emplace(opt.mangledName(), opt);
});
DECL_OPTION("-hierarchical-child", Set, &m_hierChild);
@ -1502,7 +1502,7 @@ void V3Options::parseOptsList(FileLine* fl, const string& optdir, int argc, char
V3Error::pretendError(V3ErrorCode::UNUSEDSIGNAL, true);
});
DECL_OPTION("-Werror-", CbPartialMatch, [this, fl](const char* optp) {
const V3ErrorCode code(optp);
const V3ErrorCode code{optp};
if (code == V3ErrorCode::EC_ERROR) {
if (!isFuture(optp)) fl->v3fatal("Unknown warning specified: -Werror-" << optp);
} else {

10
src/V3Order.cpp
View File

@ -498,7 +498,7 @@ public:
if (iter != s_dsMap.end()) {
return iter->second;
} else {
OrderMoveDomScope* domScopep = new OrderMoveDomScope(domainp, scopep);
OrderMoveDomScope* domScopep = new OrderMoveDomScope{domainp, scopep};
s_dsMap.emplace(key, domScopep);
return domScopep;
}
@ -736,7 +736,7 @@ public:
// METHODS
OrderMoveVertex* makeVertexp(OrderLogicVertex* lvertexp, const OrderEitherVertex*,
const AstSenTree* domainp) override {
OrderMoveVertex* const resultp = new OrderMoveVertex(m_pomGraphp, lvertexp);
OrderMoveVertex* const resultp = new OrderMoveVertex{m_pomGraphp, lvertexp};
AstScope* const scopep = lvertexp ? lvertexp->scopep() : nullptr;
resultp->domScopep(OrderMoveDomScope::findCreate(domainp, scopep));
resultp->m_pomWaitingE.pushBack(*m_pomWaitingp, resultp);
@ -1358,7 +1358,7 @@ void OrderProcess::processMTasks() {
const AbstractLogicMTask* const mtaskp = static_cast<const AbstractLogicMTask*>(mtaskVxp);
// Create a body for this mtask
AstMTaskBody* const bodyp = new AstMTaskBody(rootFlp);
AstMTaskBody* const bodyp = new AstMTaskBody{rootFlp};
MTaskState& state = mtaskStates[mtaskp->id()];
state.m_mtaskBodyp = bodyp;
@ -1388,7 +1388,7 @@ void OrderProcess::processMTasks() {
// - The ExecMTask graph and the AstMTaskBody's produced here
// persist until code generation time.
V3Graph* const depGraphp = execGraphp->depGraphp();
state.m_execMTaskp = new ExecMTask(depGraphp, bodyp, mtaskp->id());
state.m_execMTaskp = new ExecMTask{depGraphp, bodyp, mtaskp->id()};
// Cross-link each ExecMTask and MTaskBody
// Q: Why even have two objects?
// A: One is an AstNode, the other is a GraphVertex,
@ -1399,7 +1399,7 @@ void OrderProcess::processMTasks() {
const AbstractLogicMTask* const fromp
= static_cast<const AbstractLogicMTask*>(fromVxp);
const MTaskState& fromState = mtaskStates[fromp->id()];
new V3GraphEdge(depGraphp, fromState.m_execMTaskp, state.m_execMTaskp, 1);
new V3GraphEdge{depGraphp, fromState.m_execMTaskp, state.m_execMTaskp, 1};
}
execGraphp->addMTaskBodiesp(bodyp);
}

10
src/V3Param.cpp
View File

@ -211,7 +211,7 @@ public:
} else {
varNum.opAssign(pinValuep->num());
}
V3Number isEq(pinValuep, 1);
V3Number isEq{pinValuep, 1};
isEq.opEq(varNum, hierOptParamp->num());
return isEq.isNeqZero();
}
@ -344,7 +344,7 @@ class ParamProcessor final {
const string key = paramValueKey(nodep);
V3Hash hash = V3Hasher::uncachedHash(nodep);
// Force hash collisions -- for testing only
if (VL_UNLIKELY(v3Global.opt.debugCollision())) hash = V3Hash();
if (VL_UNLIKELY(v3Global.opt.debugCollision())) hash = V3Hash{};
int num;
const auto it = m_valueMap.find(hash);
if (it != m_valueMap.end() && it->second.second == key) {
@ -656,8 +656,8 @@ class ParamProcessor final {
if (debug()) pinp->dumpTree(cout, "-nodes: ");
pinp->v3error("Can't convert defparam value to constant: Param "
<< pinp->prettyNameQ() << " of " << nodep->prettyNameQ());
pinp->exprp()->replaceWith(new AstConst(
pinp->fileline(), AstConst::WidthedValue(), modvarp->width(), 0));
pinp->exprp()->replaceWith(new AstConst{
pinp->fileline(), AstConst::WidthedValue{}, modvarp->width(), 0});
} else if (origp && exprp->sameTree(origp)) {
// Setting parameter to its default value. Just ignore it.
// This prevents making additional modules, and makes coverage more
@ -1220,7 +1220,7 @@ class ParamVisitor final : public VNVisitor {
if (!itemp->isDefault()) {
for (AstNode* ep = itemp->condsp(); ep; ep = ep->nextp()) {
if (const AstConst* const ccondp = VN_CAST(ep, Const)) {
V3Number match(nodep, 1);
V3Number match{nodep, 1};
match.opEq(ccondp->num(), exprp->num());
if (!keepp && match.isNeqZero()) keepp = itemp->stmtsp();
} else {

12
src/V3PreProc.cpp
View File

@ -344,7 +344,7 @@ void V3PreProcImp::define(FileLine* fl, const string& name, const string& value,
}
undef(name);
}
m_defines.emplace(name, VDefine(fl, value, params, cmdline));
m_defines.emplace(name, VDefine{fl, value, params, cmdline});
}
}
@ -1050,7 +1050,7 @@ int V3PreProcImp::getStateToken() {
bool enable = defExists(m_lastSym);
UINFO(4, "Ifdef " << m_lastSym << (enable ? " ON" : " OFF") << endl);
if (state() == ps_DEFNAME_IFNDEF) enable = !enable;
m_ifdefStack.push(VPreIfEntry(enable, false));
m_ifdefStack.push(VPreIfEntry{enable, false});
if (!enable) parsingOff();
statePop();
goto next_tok;
@ -1065,7 +1065,7 @@ int V3PreProcImp::getStateToken() {
// Handle `if portion
const bool enable = !lastIf.everOn() && defExists(m_lastSym);
UINFO(4, "Elsif " << m_lastSym << (enable ? " ON" : " OFF") << endl);
m_ifdefStack.push(VPreIfEntry(enable, lastIf.everOn()));
m_ifdefStack.push(VPreIfEntry{enable, lastIf.everOn()});
if (!enable) parsingOff();
}
statePop();
@ -1380,7 +1380,7 @@ int V3PreProcImp::getStateToken() {
m_ifdefStack.pop();
const bool enable = !lastIf.everOn();
UINFO(4, "Else " << (enable ? " ON" : " OFF") << endl);
m_ifdefStack.push(VPreIfEntry(enable, lastIf.everOn()));
m_ifdefStack.push(VPreIfEntry{enable, lastIf.everOn()});
if (!lastIf.on()) parsingOn();
if (!enable) parsingOff();
}
@ -1428,7 +1428,7 @@ int V3PreProcImp::getStateToken() {
if (params == "0" || params == "") { // Found, as simple substitution
string out;
if (!m_off) {
VDefineRef tempref(name, "");
VDefineRef tempref{name, ""};
out = defineSubst(&tempref);
}
// Similar code in parenthesized define (Search for END_OF_DEFARG)
@ -1467,7 +1467,7 @@ int V3PreProcImp::getStateToken() {
// The CURRENT macro needs the paren saved, it's not a
// property of the child macro
if (!m_defRefs.empty()) m_defRefs.top().parenLevel(m_lexp->m_parenLevel);
m_defRefs.push(VDefineRef(name, params));
m_defRefs.push(VDefineRef{name, params});
statePush(ps_DEFPAREN);
m_lexp->pushStateDefArg(0);
goto next_tok;

10
src/V3Scope.cpp
View File

@ -107,10 +107,10 @@ private:
UINFO(4, " MOD AT " << scopename << " " << nodep << endl);
AstNode::user1ClearTree();
m_scopep = new AstScope(
m_scopep = new AstScope{
(m_aboveCellp ? static_cast<AstNode*>(m_aboveCellp) : static_cast<AstNode*>(nodep))
->fileline(),
nodep, scopename, m_aboveScopep, m_aboveCellp);
nodep, scopename, m_aboveScopep, m_aboveCellp};
if (VN_IS(nodep, Package)) m_packageScopes.emplace(nodep, m_scopep);
// Now for each child cell, iterate the module this cell points to
@ -173,7 +173,7 @@ private:
const AstNode* const abovep = (m_aboveCellp ? static_cast<AstNode*>(m_aboveCellp)
: static_cast<AstNode*>(nodep));
m_scopep
= new AstScope(abovep->fileline(), m_modp, scopename, m_aboveScopep, m_aboveCellp);
= new AstScope{abovep->fileline(), m_modp, scopename, m_aboveScopep, m_aboveCellp};
m_packageScopes.emplace(nodep, m_scopep);
// Create scope for the current usage of this cell
@ -304,11 +304,11 @@ private:
// To keep correct visual order, must add before other Text's
AstText* afterp = nodep->scopeAttrp();
if (afterp) afterp->unlinkFrBackWithNext();
nodep->addScopeAttrp(new AstText(nodep->fileline(), prefix));
nodep->addScopeAttrp(new AstText{nodep->fileline(), prefix});
if (afterp) nodep->addScopeAttrp(afterp);
afterp = nodep->scopeEntrp();
if (afterp) afterp->unlinkFrBackWithNext();
nodep->addScopeEntrp(new AstText(nodep->fileline(), prefix));
nodep->addScopeEntrp(new AstText{nodep->fileline(), prefix});
if (afterp) nodep->addScopeEntrp(afterp);
iterateChildren(nodep);
}

8
src/V3Stats.h
View File

@ -103,16 +103,16 @@ class V3Stats final {
public:
static void addStat(const V3Statistic&);
static void addStat(const string& stage, const string& name, double count) {
addStat(V3Statistic(stage, name, count));
addStat(V3Statistic{stage, name, count});
}
static void addStat(const string& name, double count) {
addStat(V3Statistic("*", name, count));
addStat(V3Statistic{"*", name, count});
}
static void addStatSum(const string& name, double count) {
addStat(V3Statistic("*", name, count, true));
addStat(V3Statistic{"*", name, count, true});
}
static void addStatPerf(const string& name, double count) {
addStat(V3Statistic("*", name, count, true, true));
addStat(V3Statistic{"*", name, count, true, true});
}
/// Called each stage
static void statsStage(const string& name);

4
src/V3String.cpp
View File

@ -386,7 +386,7 @@ string VHashSha256::digestSymbol() {
void VHashSha256::selfTestOne(const string& data, const string& data2, const string& exp,
const string& exp64) {
VHashSha256 digest(data);
VHashSha256 digest{data};
if (data2 != "") digest.insert(data2);
if (VL_UNCOVERABLE(digest.digestHex() != exp)) {
std::cerr << "%Error: When hashing '" << data + data2 << "'\n" // LCOV_EXCL_LINE
@ -476,7 +476,7 @@ string VName::hashedName() {
m_hashed = m_name;
return m_hashed;
} else {
VHashSha256 hash(m_name);
VHashSha256 hash{m_name};
const string suffix = "__Vhsh" + hash.digestSymbol();
if (s_minLength < s_maxLength) {
s_dehashMap[suffix] = m_name.substr(s_minLength);

10
src/V3Unroll.cpp
View File

@ -198,9 +198,9 @@ private:
AstNode* clonep = nodep->cloneTree(true);
UASSERT_OBJ(clonep, nodep, "Failed to clone tree");
if (loopValue) {
m_varValuep = new AstConst(nodep->fileline(), *loopValue);
m_varValuep = new AstConst{nodep->fileline(), *loopValue};
// Iteration requires a back, so put under temporary node
AstBegin* tempp = new AstBegin(nodep->fileline(), "[EditWrapper]", clonep);
AstBegin* tempp = new AstBegin{nodep->fileline(), "[EditWrapper]", clonep};
m_varModeReplace = true;
iterateAndNextNull(tempp->stmtsp());
m_varModeReplace = false;
@ -310,12 +310,12 @@ private:
// Replace iterator values with constant.
AstNode* oneloopp = stmtsp->cloneTree(true);
m_varValuep = new AstConst(nodep->fileline(), loopValue);
m_varValuep = new AstConst{nodep->fileline(), loopValue};
// Iteration requires a back, so put under temporary node
if (oneloopp) {
AstBegin* const tempp
= new AstBegin(oneloopp->fileline(), "[EditWrapper]", oneloopp);
= new AstBegin{oneloopp->fileline(), "[EditWrapper]", oneloopp};
m_varModeReplace = true;
iterateAndNextNull(tempp->stmtsp());
m_varModeReplace = false;
@ -325,7 +325,7 @@ private:
if (m_generate) {
const string index = AstNode::encodeNumber(m_varValuep->toSInt());
const string nname = m_beginName + "__BRA__" + index + "__KET__";
oneloopp = new AstBegin(oneloopp->fileline(), nname, oneloopp, true);
oneloopp = new AstBegin{oneloopp->fileline(), nname, oneloopp, true};
}
VL_DO_CLEAR(pushDeletep(m_varValuep), m_varValuep = nullptr);
if (newbodysp) {

4
src/VlcSource.h
View File

@ -89,7 +89,7 @@ public:
ColumnMap& cmap = lit->second;
ColumnMap::iterator cit = cmap.find(column);
if (cit == cmap.end()) {
cit = cmap.insert(std::make_pair(column, VlcSourceCount(lineno, column))).first;
cit = cmap.insert(std::make_pair(column, VlcSourceCount{lineno, column})).first;
}
VlcSourceCount& sc = cit->second;
sc.incCount(count, ok);
@ -124,7 +124,7 @@ public:
if (iter != m_sources.end()) {
return iter->second;
} else {
iter = m_sources.insert(std::make_pair(name, VlcSource(name))).first;
iter = m_sources.insert(std::make_pair(name, VlcSource{name})).first;
return iter->second;
}
}