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

Internal cleanup: no functional change. 

Add cloneTree to each node type so cast not required after use.
Standardize declaring common AstNode functions via a macro.
This commit is contained in:
Wilson Snyder 2008-11-19 20:15:05 -05:00
parent a4bcb3de4a
commit ab668b066f
15 changed files with 209 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/V3Active.cpp
View File

@ -129,7 +129,7 @@ public:
found:
// Not found, form a new one
if (!activep) {
AstSenTree* newsenp = sensesp->cloneTree(false)->castSenTree();
AstSenTree* newsenp = sensesp->cloneTree(false);
activep = new AstActive(fl, "sequent", newsenp);
activep->sensesStorep(activep->sensesp());
UINFO(8," New ACTIVE "<<activep<<endl);

42
src/V3Ast.h
View File

@ -703,11 +703,15 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
//######################################################################
//=== AstNode* : Derived generic node types
#define ASTNODE_BASE_FUNCS(name) \
virtual ~Ast ##name() {} \
Ast ##name * cloneTree(bool cloneNext) { return AstNode::cloneTree(cloneNext)->cast ##name(); }
struct AstNodeMath : public AstNode {
// Math -- anything that's part of an expression tree
AstNodeMath(FileLine* fl)
: AstNode(fl) {}
virtual ~AstNodeMath() {}
ASTNODE_BASE_FUNCS(NodeMath)
// METHODS
virtual string emitVerilog() = 0; /// Format string for verilog writing; see V3EmitV
virtual string emitC() = 0;
@ -719,7 +723,7 @@ struct AstNodeTermop : public AstNodeMath {
// Terminal operator -- a operator with no "inputs"
AstNodeTermop(FileLine* fl)
: AstNodeMath(fl) {}
virtual ~AstNodeTermop() {}
ASTNODE_BASE_FUNCS(NodeTermop)
};
struct AstNodeUniop : public AstNodeMath {
@ -728,7 +732,7 @@ struct AstNodeUniop : public AstNodeMath {
: AstNodeMath(fl) {
if (lhsp) widthSignedFrom(lhsp);
setOp1p(lhsp); }
virtual ~AstNodeUniop() {}
ASTNODE_BASE_FUNCS(NodeUniop)
AstNode* lhsp() const { return op1p()->castNode(); }
// METHODS
virtual void numberOperate(V3Number& out, const V3Number& lhs) = 0; // Set out to evaluation of a AstConst'ed lhs
@ -744,7 +748,7 @@ struct AstNodeBiop : public AstNodeMath {
AstNodeBiop(FileLine* fl, AstNode* lhs, AstNode* rhs)
: AstNodeMath(fl) {
setOp1p(lhs); setOp2p(rhs); }
virtual ~AstNodeBiop() {}
ASTNODE_BASE_FUNCS(NodeBiop)
AstNode* lhsp() const { return op1p()->castNode(); }
AstNode* rhsp() const { return op2p()->castNode(); }
void lhsp(AstNode* nodep) { return setOp1p(nodep); }
@ -766,7 +770,7 @@ struct AstNodeTriop : public AstNodeMath {
AstNodeTriop(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
: AstNodeMath(fl) {
setOp1p(lhs); setOp2p(rhs); setOp3p(ths); }
virtual ~AstNodeTriop() {}
ASTNODE_BASE_FUNCS(NodeTriop)
AstNode* lhsp() const { return op1p()->castNode(); }
AstNode* rhsp() const { return op2p()->castNode(); }
AstNode* thsp() const { return op3p()->castNode(); }
@ -790,14 +794,14 @@ struct AstNodeBiCom : public AstNodeBiop {
// Binary math with commutative properties
AstNodeBiCom(FileLine* fl, AstNode* lhs, AstNode* rhs)
: AstNodeBiop(fl, lhs, rhs) {}
virtual ~AstNodeBiCom() {}
ASTNODE_BASE_FUNCS(NodeBiCom)
};
struct AstNodeBiComAsv : public AstNodeBiCom {
// Binary math with commutative & associative properties
AstNodeBiComAsv(FileLine* fl, AstNode* lhs, AstNode* rhs)
: AstNodeBiCom(fl, lhs, rhs) {}
virtual ~AstNodeBiComAsv() {}
ASTNODE_BASE_FUNCS(NodeBiComAsv)
};
struct AstNodeCond : public AstNodeTriop {
AstNodeCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
@ -805,7 +809,7 @@ struct AstNodeCond : public AstNodeTriop {
if (expr1p) widthSignedFrom(expr1p);
else if (expr2p) widthSignedFrom(expr2p);
}
virtual ~AstNodeCond() {}
ASTNODE_BASE_FUNCS(NodeCond)
virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) {
if (lhs.isNeqZero()) out.opAssign(rhs); else out.opAssign(ths); }
AstNode* condp() const { return op1p()->castNode(); } // op1 = Condition
@ -826,7 +830,7 @@ struct AstNodePreSel : public AstNode {
AstNodePreSel(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
: AstNode(fl) {
setOp1p(lhs); setOp2p(rhs); setNOp3p(ths); }
virtual ~AstNodePreSel() {}
ASTNODE_BASE_FUNCS(NodePreSel)
AstNode* lhsp() const { return op1p()->castNode(); }
AstNode* rhsp() const { return op2p()->castNode(); }
AstNode* thsp() const { return op3p()->castNode(); }
@ -842,7 +846,7 @@ struct AstNodeStmt : public AstNode {
// Statement -- anything that's directly under a function
AstNodeStmt(FileLine* fl)
: AstNode(fl) {}
virtual ~AstNodeStmt() {}
ASTNODE_BASE_FUNCS(NodeStmt)
// METHODS
};
@ -852,7 +856,7 @@ struct AstNodeAssign : public AstNodeStmt {
setOp1p(rhsp); setOp2p(lhsp);
if (lhsp) widthSignedFrom(lhsp);
}
virtual ~AstNodeAssign() {}
ASTNODE_BASE_FUNCS(NodeAssign)
virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp)=0; // Clone single node, just get same type back.
// So iteration hits the RHS which is "earlier" in execution order, it's op1, not op2
AstNode* rhsp() const { return op1p()->castNode(); } // op1 = Assign from
@ -871,7 +875,7 @@ struct AstNodeFor : public AstNodeStmt {
: AstNodeStmt(fileline) {
addNOp1p(initsp); setOp2p(condp); addNOp3p(incsp); addNOp4p(bodysp);
}
virtual ~AstNodeFor() {}
ASTNODE_BASE_FUNCS(NodeFor)
AstNode* initsp() const { return op1p()->castNode(); } // op1= initial statements
AstNode* condp() const { return op2p()->castNode(); } // op2= condition to continue
AstNode* incsp() const { return op3p()->castNode(); } // op3= increment statements
@ -891,7 +895,7 @@ public:
: AstNodeStmt(fl) {
setOp1p(condp); addNOp2p(ifsp); addNOp3p(elsesp);
}
virtual ~AstNodeIf() {}
ASTNODE_BASE_FUNCS(NodeIf)
AstNode* condp() const { return op1p(); } // op1 = condition
AstNode* ifsp() const { return op2p(); } // op2 = list of true statements
AstNode* elsesp() const { return op3p(); } // op3 = list of false statements
@ -911,7 +915,7 @@ struct AstNodeCase : public AstNodeStmt {
: AstNodeStmt(fl) {
setOp1p(exprp); addNOp2p(casesp);
}
virtual ~AstNodeCase() {}
ASTNODE_BASE_FUNCS(NodeCase)
virtual int instrCount() const { return instrCountBranch(); }
AstNode* exprp() const { return op1p()->castNode(); } // op1 = case condition <expression>
AstCaseItem* itemsp() const { return op2p()->castCaseItem(); } // op2 = list of case expressions
@ -940,7 +944,7 @@ public:
// May have varp==NULL
if (m_varp) widthSignedFrom((AstNode*)m_varp);
}
virtual ~AstNodeVarRef() {}
ASTNODE_BASE_FUNCS(NodeVarRef)
virtual bool broken() const;
virtual int instrCount() const { return widthInstrs(); }
virtual void cloneRelink();
@ -964,7 +968,7 @@ public:
AstNodePli(FileLine* fl, const string& text, AstNode* exprsp)
: AstNodeStmt(fl), m_text(text) {
addNOp1p(exprsp); }
virtual ~AstNodePli() {}
ASTNODE_BASE_FUNCS(NodePli)
virtual string name() const { return m_text; }
virtual int instrCount() const { return instrCountPli(); }
void exprsp(AstNode* nodep) { addOp1p(nodep); } // op1 = Expressions to output
@ -983,7 +987,7 @@ public:
: AstNode(fileline) {
m_text = textp; // Copy it
}
virtual ~AstNodeText() {}
ASTNODE_BASE_FUNCS(NodeText)
const string& text() const { return m_text; }
virtual V3Hash sameHash() const { return V3Hash(text()); }
virtual bool same(AstNode* samep) const {
@ -1013,7 +1017,7 @@ public:
, m_name(name), m_taskPublic(false) {
addNOp3p(stmtsp);
}
virtual ~AstNodeFTask() {}
ASTNODE_BASE_FUNCS(NodeFTask)
virtual void dump(ostream& str=cout);
virtual string name() const { return m_name; } // * = Var name
virtual bool maybePointedTo() const { return true; }
@ -1039,7 +1043,7 @@ public:
, m_taskp(NULL) {
setOp1p(namep); addNOp2p(pinsp);
}
virtual ~AstNodeFTaskRef() {}
ASTNODE_BASE_FUNCS(NodeFTaskRef)
virtual bool broken() const { return m_taskp && !m_taskp->brokeExists(); }
virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
m_taskp = m_taskp->clonep()->castNodeFTask();

792
src/V3AstNodes.h
View File

File diff suppressed because it is too large Load Diff

2
src/V3Const.cpp
View File

@ -535,7 +535,7 @@ private:
AstNode* ap = lhsp->lhsp()->unlinkFrBack();
AstNode* bp = lhsp->rhsp()->unlinkFrBack();
AstNodeBiop* shift1p = nodep;
AstNodeBiop* shift2p = nodep->cloneTree(true)->castNodeBiop();
AstNodeBiop* shift2p = nodep->cloneTree(true);
shift1p->lhsp(ap); shift1p->rhsp(shiftp->cloneTree(true));
shift2p->lhsp(bp); shift2p->rhsp(shiftp);
AstNodeBiop* newp = lhsp;

4
src/V3Delayed.cpp
View File

@ -370,8 +370,8 @@ private:
UINFO(4," Act: "<<m_activep<<endl);
UINFO(4," Act: "<<oldactivep<<endl);
// Make a new sensitivity list, which is the combination of both blocks
AstSenItem* sena = m_activep->sensesp()->sensesp()->cloneTree(true)->castSenItem();
AstSenItem* senb = oldactivep->sensesp()->sensesp()->cloneTree(true)->castSenItem();
AstSenItem* sena = m_activep->sensesp()->sensesp()->cloneTree(true);
AstSenItem* senb = oldactivep->sensesp()->sensesp()->cloneTree(true);
AstSenTree* treep = new AstSenTree(m_activep->fileline(), sena);
if (senb) treep->addSensesp(senb);
if (AstSenTree* storep = oldactivep->sensesStorep()) {

2
src/V3Descope.cpp
View File

@ -106,7 +106,7 @@ private:
if (moreOfSame1) {
// Multiple functions under this name, need a wrapper function
UINFO(6," Wrapping "<<name<<" multifuncs\n");
AstCFunc* newfuncp = topFuncp->cloneTree(false)->castCFunc();
AstCFunc* newfuncp = topFuncp->cloneTree(false);
if (newfuncp->initsp()) newfuncp->initsp()->unlinkFrBackWithNext()->deleteTree();
if (newfuncp->stmtsp()) newfuncp->stmtsp()->unlinkFrBackWithNext()->deleteTree();
if (newfuncp->finalsp()) newfuncp->finalsp()->unlinkFrBackWithNext()->deleteTree();

2
src/V3Inline.cpp
View File

@ -102,7 +102,7 @@ private:
m_statCells++;
if (debug()>=9) { nodep->dumpTree(cout,"inlcell:"); }
//if (debug()>=9) { nodep->modp()->dumpTree(cout,"oldmod:"); }
AstModule* newmodp = nodep->modp()->cloneTree(false)->castModule();
AstModule* newmodp = nodep->modp()->cloneTree(false);
if (debug()>=9) { newmodp->dumpTree(cout,"newmod:"); }
// Clear var markings
AstNode::user2ClearTree();

2
src/V3Inst.cpp
View File

@ -156,7 +156,7 @@ private:
// Make all of the required clones
m_instLsb = m_cellRangep->lsbConst();
for (m_instNum = m_instLsb; m_instNum<=m_cellRangep->msbConst(); m_instNum++) {
AstCell* newp = nodep->cloneTree(false)->castCell();
AstCell* newp = nodep->cloneTree(false);
nodep->addNextHere(newp);
// Remove ranging and fix name
newp->rangep()->unlinkFrBack()->deleteTree();

2
src/V3LinkLevel.cpp
View File

@ -156,7 +156,7 @@ void V3LinkLevel::wrapTop(AstNetlist* netlistp) {
if (AstVar* oldvarp=subnodep->castVar()) {
UINFO(8,"VARWRAP "<<oldvarp<<endl);
if (oldvarp->isIO()) {
AstVar* varp = oldvarp->cloneTree(false)->castVar();
AstVar* varp = oldvarp->cloneTree(false);
newmodp->addStmtp(varp);
varp->sigPublic(true); // User needs to be able to get to it...
if (oldvarp->isIO()) {

4
src/V3Order.cpp
View File

@ -1085,8 +1085,8 @@ void OrderVisitor::processDomainsIterate(OrderEitherVertex* vertexp) {
UINFO(0," d2 ="<<fromVertexp->domainp()<<endl);
fromVertexp->domainp()->dumpTree(cout);
}
AstSenTree* newtreep = domainp->cloneTree(false)->castSenTree();
AstSenItem* newtree2p = fromVertexp->domainp()->sensesp()->cloneTree(true)->castSenItem();
AstSenTree* newtreep = domainp->cloneTree(false);
AstSenItem* newtree2p = fromVertexp->domainp()->sensesp()->cloneTree(true);
if (!newtree2p) fromVertexp->domainp()->v3fatalSrc("No senitem found under clocked domain");
newtreep->addSensesp(newtree2p);
newtreep->sortSenses(); // Remove duplicates

2
src/V3Param.cpp
View File

@ -285,7 +285,7 @@ void ParamVisitor::visit(AstCell* nodep, AstNUser*) {
// Deep clone of new module
// Note all module internal variables will be re-linked to the new modules by clone
// However links outside the module (like on the upper cells) will not.
modp = nodep->modp()->cloneTree(false)->castModule();
modp = nodep->modp()->cloneTree(false);
modp->name(newname);
nodep->modp()->addNextHere(modp); // Keep tree sorted by cell occurrences

10
src/V3Scope.cpp
View File

@ -120,14 +120,14 @@ private:
virtual void visit(AstInitial* nodep, AstNUser*) {
// Add to list of blocks under this scope
UINFO(4," Move "<<nodep<<endl);
AstInitial* clonep = nodep->cloneTree(false)->castInitial();
AstInitial* clonep = nodep->cloneTree(false);
m_scopep->addActivep(clonep);
clonep->iterateChildren(*this); // We iterate under the *clone*
}
virtual void visit(AstFinal* nodep, AstNUser*) {
// Add to list of blocks under this scope
UINFO(4," Move "<<nodep<<endl);
AstFinal* clonep = nodep->cloneTree(false)->castFinal();
AstFinal* clonep = nodep->cloneTree(false);
m_scopep->addActivep(clonep);
clonep->iterateChildren(*this); // We iterate under the *clone*
}
@ -148,14 +148,14 @@ private:
virtual void visit(AstAlways* nodep, AstNUser*) {
// Add to list of blocks under this scope
UINFO(4," Move "<<nodep<<endl);
AstAlways* clonep = nodep->cloneTree(false)->castAlways();
AstAlways* clonep = nodep->cloneTree(false);
m_scopep->addActivep(clonep);
clonep->iterateChildren(*this); // We iterate under the *clone*
}
virtual void visit(AstCFunc* nodep, AstNUser*) {
// Add to list of blocks under this scope
UINFO(4," CFUNC "<<nodep<<endl);
AstCFunc* clonep = nodep->cloneTree(false)->castCFunc();
AstCFunc* clonep = nodep->cloneTree(false);
clonep->scopep(m_scopep);
m_scopep->addActivep(clonep);
// We iterate under the *clone*
@ -164,7 +164,7 @@ private:
virtual void visit(AstNodeFTask* nodep, AstNUser*) {
// Add to list of blocks under this scope
UINFO(4," FTASK "<<nodep<<endl);
AstNodeFTask* clonep = nodep->cloneTree(false)->castNodeFTask();
AstNodeFTask* clonep = nodep->cloneTree(false);
m_scopep->addActivep(clonep);
// We iterate under the *clone*
clonep->iterateChildren(*this);

2
src/V3SenTree.h
View File

@ -109,7 +109,7 @@ public:
// Not found, form a new one
if (!treep) {
UASSERT(m_topscopep,"Never called main()");
treep = sensesp->cloneTree(false)->castSenTree();
treep = sensesp->cloneTree(false);
m_topscopep->addStmtsp(treep);
UINFO(8," New SENTREE "<<treep<<endl);
m_treesp.push_back(treep);

2
src/V3SplitAs.cpp
View File

@ -149,7 +149,7 @@ private:
UINFO(3," For "<<m_splitVscp<<endl);
if (debug()>=9) nodep->dumpTree(cout,"-in : ");
// Duplicate it and link in
AstAlways* newp = nodep->cloneTree(false)->castAlways();
AstAlways* newp = nodep->cloneTree(false);
newp->user(true); // So we don't clone it again
nodep->addNextHere(newp);
{ // Delete stuff we don't want in old

4
src/V3Task.cpp
View File

@ -677,14 +677,14 @@ private:
if (nodep->taskPublic()) {
// Clone it first, because we may have later FTaskRef's that still need
// the original version.
AstNodeFTask* clonedFuncp = nodep->cloneTree(false)->castNodeFTask();
AstNodeFTask* clonedFuncp = nodep->cloneTree(false);
AstCFunc* cfuncp = makeUserFunc(clonedFuncp, true);
nodep->addNextHere(cfuncp);
iterateIntoFTask(clonedFuncp); // Do the clone too
}
if (m_statep->ftaskNoInline(nodep)) {
m_statep->checkPurity(nodep);
AstNodeFTask* clonedFuncp = nodep->cloneTree(false)->castNodeFTask();
AstNodeFTask* clonedFuncp = nodep->cloneTree(false);
AstCFunc* cfuncp = makeUserFunc(clonedFuncp, false);
nodep->user5p(cfuncp);
nodep->addNextHere(cfuncp);