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

Internals: make dump const. No functional change intended.

This commit is contained in:
Wilson Snyder 2019-10-20 11:49:41 -04:00
parent 6d58d32a0f
commit 94f7133c6f
4 changed files with 119 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/V3Ast.cpp
View File

@ -1034,7 +1034,7 @@ void AstNode::dumpPtrs(std::ostream& os) const {
os<<endl;
}
void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) {
void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) const {
static int s_debugFileline = v3Global.opt.debugSrcLevel("fileline"); // --debugi-fileline 9
os<<indent<<" "<<this<<endl;
if (debug()>8) { os<<indent<<" "; dumpPtrs(os); }
@ -1044,25 +1044,26 @@ void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) {
if (maxDepth==1) {
if (op1p()||op2p()||op3p()||op4p()) { os<<indent<<"1: ...(maxDepth)"<<endl; }
} else {
for (AstNode* nodep=op1p(); nodep; nodep=nodep->nextp()) {
for (const AstNode* nodep=op1p(); nodep; nodep=nodep->nextp()) {
nodep->dumpTree(os, indent+"1:", maxDepth-1); }
for (AstNode* nodep=op2p(); nodep; nodep=nodep->nextp()) {
for (const AstNode* nodep=op2p(); nodep; nodep=nodep->nextp()) {
nodep->dumpTree(os, indent+"2:", maxDepth-1); }
for (AstNode* nodep=op3p(); nodep; nodep=nodep->nextp()) {
for (const AstNode* nodep=op3p(); nodep; nodep=nodep->nextp()) {
nodep->dumpTree(os, indent+"3:", maxDepth-1); }
for (AstNode* nodep=op4p(); nodep; nodep=nodep->nextp()) {
for (const AstNode* nodep=op4p(); nodep; nodep=nodep->nextp()) {
nodep->dumpTree(os, indent+"4:", maxDepth-1); }
}
}
void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDepth) {
void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDepth) const {
// Audited to make sure this is never NULL
for (AstNode* nodep=this; nodep; nodep=nodep->nextp()) {
for (const AstNode* nodep = this; nodep; nodep = nodep->nextp()) {
nodep->dumpTree(os, indent, maxDepth);
}
}
void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
// Not const function as calls checkTree
if (doDump) {
{ // Write log & close
UINFO(2,"Dumping "<<filename<<endl);

28
src/V3Ast.h
View File

@ -1439,7 +1439,7 @@ public:
string warnMore() const { return fileline()->warnMore(); }
string warnOther() const { return fileline()->warnOther(); }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
void dumpGdb(); // For GDB only
void dumpGdbHeader() const;
@ -1474,10 +1474,10 @@ public:
void checkIter() const;
void clearIter() { m_iterpp = NULL; }
void dumpPtrs(std::ostream& os=std::cout) const;
void dumpTree(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout, indent, maxDepth); }
void dumpTree(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0) const;
void dumpTree(const string& indent, int maxDepth=0) const { dumpTree(cout, indent, maxDepth); }
void dumpTreeGdb(); // For GDB only
void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0);
void dumpTreeAndNext(std::ostream& os=std::cout, const string& indent=" ", int maxDepth=0) const;
void dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
static void dumpTreeFileGdb(const char* filenamep=NULL);
@ -1524,7 +1524,7 @@ public:
// AstAlways* castAlways();
};
inline std::ostream& operator<<(std::ostream& os, AstNode* rhs) {
inline std::ostream& operator<<(std::ostream& os, const AstNode* rhs) {
if (!rhs) os<<"NULL"; else rhs->dump(os); return os;
}
inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
@ -1871,7 +1871,7 @@ public:
m_text = textp; // Copy it
}
ASTNODE_BASE_FUNCS(NodeText)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual V3Hash sameHash() const { return V3Hash(text()); }
virtual bool same(const AstNode* samep) const {
const AstNodeText* asamep = static_cast<const AstNodeText*>(samep);
@ -1897,8 +1897,8 @@ public:
}
ASTNODE_BASE_FUNCS(NodeDType)
// ACCESSORS
virtual void dump(std::ostream& str);
virtual void dumpSmall(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual void dumpSmall(std::ostream& str) const;
virtual bool hasDType() const { return true; }
virtual AstBasicDType* basicp() const = 0; // (Slow) recurse down to find basic data type
virtual AstNodeDType* skipRefp() const = 0; // recurses over typedefs/const/enum to next non-typeref type
@ -1958,7 +1958,7 @@ public:
}
ASTNODE_BASE_FUNCS(NodeClassDType)
virtual const char* broken() const;
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
// For basicp() we reuse the size to indicate a "fake" basic type of same size
virtual AstBasicDType* basicp() const {
return (isFourstate()
@ -2004,8 +2004,8 @@ public:
m_refDTypep = NULL;
}
ASTNODE_BASE_FUNCS(NodeArrayDType)
virtual void dump(std::ostream& str);
virtual void dumpSmall(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual void dumpSmall(std::ostream& str) const;
virtual const char* broken() const {
BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
|| (!m_refDTypep && childDTypep()))); return NULL; }
@ -2102,7 +2102,7 @@ public:
cname(name); // Might be overridden by dpi import/export
}
ASTNODE_BASE_FUNCS(NodeFTask)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual string name() const { return m_name; } // * = Var name
virtual bool maybePointedTo() const { return true; }
virtual bool isGateOptimizable() const { return !((m_dpiExport || m_dpiImport) && !m_pure); }
@ -2169,7 +2169,7 @@ public:
virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
m_taskp = m_taskp->clonep();
}}
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual string name() const { return m_name; } // * = Var name
virtual bool isGateOptimizable() const { return m_taskp && m_taskp->isGateOptimizable(); }
string dotted() const { return m_dotted; } // * = Scope name or ""
@ -2218,7 +2218,7 @@ public:
, m_internal(false), m_recursive(false), m_recursiveClone(false)
, m_level(0), m_varNum(0), m_typeNum(0) { }
ASTNODE_BASE_FUNCS(NodeModule)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual bool maybePointedTo() const { return true; }
virtual string name() const { return m_name; }
AstNode* stmtsp() const { return op2p(); } // op2 = List of statements

106
src/V3AstNodes.cpp
View File

@ -823,7 +823,7 @@ void AstWhile::addNextStmt(AstNode* newp, AstNode* belowp) {
//======================================================================
// Per-type Debugging
void AstNode::dump(std::ostream& str) {
void AstNode::dump(std::ostream& str) const {
str<<typeName()<<" "<<cvtToHex(this)
//<<" "<<cvtToHex(this)->m_backp
<<" <e"<<std::dec<<editCount()
@ -850,45 +850,45 @@ void AstNode::dump(std::ostream& str) {
}
}
void AstAlways::dump(std::ostream& str) {
void AstAlways::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (keyword() != VAlwaysKwd::ALWAYS) str<<" ["<<keyword().ascii()<<"]";
}
void AstAttrOf::dump(std::ostream& str) {
void AstAttrOf::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" ["<<attrType().ascii()<<"]";
}
void AstBasicDType::dump(std::ostream& str) {
void AstBasicDType::dump(std::ostream& str) const {
this->AstNodeDType::dump(str);
str<<" kwd="<<keyword().ascii();
if (isRanged() && !rangep()) str<<" range=["<<left()<<":"<<right()<<"]";
}
void AstCCast::dump(std::ostream& str) {
void AstCCast::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" sz"<<size();
}
void AstCell::dump(std::ostream& str) {
void AstCell::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (recursive()) str<<" [RECURSIVE]";
if (modp()) { str<<" -> "; modp()->dump(str); }
else { str<<" ->UNLINKED:"<<modName(); }
}
void AstCellInline::dump(std::ostream& str) {
void AstCellInline::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> "<<origModName();
}
void AstDisplay::dump(std::ostream& str) {
void AstDisplay::dump(std::ostream& str) const {
this->AstNode::dump(str);
//str<<" "<<displayType().ascii();
}
void AstEnumItemRef::dump(std::ostream& str) {
void AstEnumItemRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> ";
if (itemp()) { itemp()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstIfaceRefDType::dump(std::ostream& str) {
void AstIfaceRefDType::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (cellName()!="") { str<<" cell="<<cellName(); }
if (ifaceName()!="") { str<<" if="<<ifaceName(); }
@ -897,44 +897,44 @@ void AstIfaceRefDType::dump(std::ostream& str) {
else if (ifacep()) { str<<" -> "; ifacep()->dump(str); }
else { str<<" -> UNLINKED"; }
}
void AstIfaceRefDType::dumpSmall(std::ostream& str) {
void AstIfaceRefDType::dumpSmall(std::ostream& str) const {
this->AstNodeDType::dumpSmall(str);
str<<"iface";
}
void AstJumpGo::dump(std::ostream& str) {
void AstJumpGo::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> ";
if (labelp()) { labelp()->dump(str); }
else { str<<"%Error:UNLINKED"; }
}
void AstModportFTaskRef::dump(std::ostream& str) {
void AstModportFTaskRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (isExport()) str<<" EXPORT";
if (isImport()) str<<" IMPORT";
if (ftaskp()) { str<<" -> "; ftaskp()->dump(str); }
else { str<<" -> UNLINKED"; }
}
void AstModportVarRef::dump(std::ostream& str) {
void AstModportVarRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (direction().isAny()) str<<" "<<direction();
if (varp()) { str<<" -> "; varp()->dump(str); }
else { str<<" -> UNLINKED"; }
}
void AstPin::dump(std::ostream& str) {
void AstPin::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (modVarp()) { str<<" -> "; modVarp()->dump(str); }
else { str<<" ->UNLINKED"; }
if (svImplicit()) str<<" [.SV]";
}
void AstTypedef::dump(std::ostream& str) {
void AstTypedef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (attrPublic()) str<<" [PUBLIC]";
}
void AstRange::dump(std::ostream& str) {
void AstRange::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (littleEndian()) str<<" [LITTLE]";
}
void AstRefDType::dump(std::ostream& str) {
void AstRefDType::dump(std::ostream& str) const {
this->AstNodeDType::dump(str);
if (defp()) {
static bool s_recursing = false;
@ -946,12 +946,12 @@ void AstRefDType::dump(std::ostream& str) {
}
else { str<<" -> UNLINKED"; }
}
void AstNodeClassDType::dump(std::ostream& str) {
void AstNodeClassDType::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (packed()) str<<" [PACKED]";
if (isFourstate()) str<<" [4STATE]";
}
void AstNodeDType::dump(std::ostream& str) {
void AstNodeDType::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (generic()) str<<" [GENERIC]";
if (AstNodeDType* dtp = virtRefDTypep()) {
@ -959,7 +959,7 @@ void AstNodeDType::dump(std::ostream& str) {
dtp->dumpSmall(str);
}
}
void AstNodeDType::dumpSmall(std::ostream& str) {
void AstNodeDType::dumpSmall(std::ostream& str) const {
str<<"("
<<(generic()?"G/":"")
<<((isSigned()&&!isDouble())?"s":"")
@ -972,16 +972,16 @@ void AstNodeDType::dumpSmall(std::ostream& str) {
if (!widthSized()) str<<"/"<<widthMin();
str<<")";
}
void AstNodeArrayDType::dumpSmall(std::ostream& str) {
void AstNodeArrayDType::dumpSmall(std::ostream& str) const {
this->AstNodeDType::dumpSmall(str);
if (VN_IS(this, PackArrayDType)) str<<"p"; else str<<"u";
str<<declRange();
}
void AstNodeArrayDType::dump(std::ostream& str) {
void AstNodeArrayDType::dump(std::ostream& str) const {
this->AstNodeDType::dump(str);
str<<" "<<declRange();
}
void AstNodeModule::dump(std::ostream& str) {
void AstNodeModule::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" L"<<level();
if (modPublic()) str<<" [P]";
@ -990,33 +990,33 @@ void AstNodeModule::dump(std::ostream& str) {
if (recursiveClone()) str<<" [RECURSIVE-CLONE]";
else if (recursive()) str<<" [RECURSIVE]";
}
void AstPackageExport::dump(std::ostream& str) {
void AstPackageExport::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> "<<packagep();
}
void AstPackageImport::dump(std::ostream& str) {
void AstPackageImport::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> "<<packagep();
}
void AstSel::dump(std::ostream& str) {
void AstSel::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (declRange().ranged()) {
str<<" decl"<<declRange()<<"]";
if (declElWidth()!=1) str<<"/"<<declElWidth();
}
}
void AstSliceSel::dump(std::ostream& str) {
void AstSliceSel::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (declRange().ranged()) {
str<<" decl"<<declRange();
}
}
void AstMTaskBody::dump(std::ostream& str) {
void AstMTaskBody::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" ";
m_execMTaskp->dump(str);
}
void AstTypeTable::dump(std::ostream& str) {
void AstTypeTable::dump(std::ostream& str) const {
this->AstNode::dump(str);
for (int i=0; i < static_cast<int>(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
if (AstBasicDType* subnodep = m_basicps[i]) {
@ -1027,7 +1027,7 @@ void AstTypeTable::dump(std::ostream& str) {
}
}
{
DetailedMap& mapr = m_detailedMap;
const DetailedMap& mapr = m_detailedMap;
for (DetailedMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
AstBasicDType* dtypep = it->second;
str<<endl; // Newline from caller, so newline first
@ -1037,17 +1037,17 @@ void AstTypeTable::dump(std::ostream& str) {
}
// Note get newline from caller too.
}
void AstUnsizedArrayDType::dumpSmall(std::ostream& str) {
void AstUnsizedArrayDType::dumpSmall(std::ostream& str) const {
this->AstNodeDType::dumpSmall(str);
str<<"[]";
}
void AstVarScope::dump(std::ostream& str) {
void AstVarScope::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (isCircular()) str<<" [CIRC]";
if (varp()) { str<<" -> "; varp()->dump(str); }
else { str<<" ->UNLINKED"; }
}
void AstVarXRef::dump(std::ostream& str) {
void AstVarXRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
if (lvalue()) str<<" [LV] => ";
@ -1058,7 +1058,7 @@ void AstVarXRef::dump(std::ostream& str) {
else if (varp()) { varp()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstVarRef::dump(std::ostream& str) {
void AstVarRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
if (lvalue()) str<<" [LV] => ";
@ -1067,7 +1067,7 @@ void AstVarRef::dump(std::ostream& str) {
else if (varp()) { varp()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstVar::dump(std::ostream& str) {
void AstVar::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (isSc()) str<<" [SC]";
if (isPrimaryIO()) str<<(isInoutish()?" [PIO]":(isWritable()?" [PO]":" [PI]"));
@ -1087,35 +1087,35 @@ void AstVar::dump(std::ostream& str) {
if (!attrClocker().unknown()) str<<" ["<<attrClocker().ascii()<<"] ";
str<<" "<<varType();
}
void AstSenTree::dump(std::ostream& str) {
void AstSenTree::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (isMulti()) str<<" [MULTI]";
}
void AstSenItem::dump(std::ostream& str) {
void AstSenItem::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" ["<<edgeType().ascii()<<"]";
}
void AstParseRef::dump(std::ostream& str) {
void AstParseRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" ["<<expect().ascii()<<"]";
}
void AstPackageRef::dump(std::ostream& str) {
void AstPackageRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
str<<" -> ";
if (packagep()) { packagep()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstDot::dump(std::ostream& str) {
void AstDot::dump(std::ostream& str) const {
this->AstNode::dump(str);
}
void AstActive::dump(std::ostream& str) {
void AstActive::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" => ";
if (sensesp()) { sensesp()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstNodeFTaskRef::dump(std::ostream& str) {
void AstNodeFTaskRef::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (packagep()) { str<<" pkg="<<cvtToHex(packagep()); }
str<<" -> ";
@ -1123,7 +1123,7 @@ void AstNodeFTaskRef::dump(std::ostream& str) {
if (taskp()) { taskp()->dump(str); }
else { str<<"UNLINKED"; }
}
void AstNodeFTask::dump(std::ostream& str) {
void AstNodeFTask::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (taskPublic()) str<<" [PUBLIC]";
if (prototype()) str<<" [PROTOTYPE]";
@ -1133,13 +1133,13 @@ void AstNodeFTask::dump(std::ostream& str) {
if (dpiOpenParent()) str<<" [DPIOPENPARENT]";
if ((dpiImport() || dpiExport()) && cname()!=name()) str<<" [c="<<cname()<<"]";
}
void AstBegin::dump(std::ostream& str) {
void AstBegin::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (unnamed()) str<<" [UNNAMED]";
if (generate()) str<<" [GEN]";
if (genforp()) str<<" [GENFOR]";
}
void AstCoverDecl::dump(std::ostream& str) {
void AstCoverDecl::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (this->dataDeclNullp()) {
str<<" -> ";
@ -1148,19 +1148,19 @@ void AstCoverDecl::dump(std::ostream& str) {
if (binNum()) { str<<" bin"<<std::dec<<binNum(); }
}
}
void AstCoverInc::dump(std::ostream& str) {
void AstCoverInc::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> ";
if (declp()) { declp()->dump(str); }
else { str<<"%Error:UNLINKED"; }
}
void AstTraceInc::dump(std::ostream& str) {
void AstTraceInc::dump(std::ostream& str) const {
this->AstNode::dump(str);
str<<" -> ";
if (declp()) { declp()->dump(str); }
else { str<<"%Error:UNLINKED"; }
}
void AstNodeText::dump(std::ostream& str) {
void AstNodeText::dump(std::ostream& str) const {
this->AstNode::dump(str);
string out = text();
string::size_type pos;
@ -1171,23 +1171,23 @@ void AstNodeText::dump(std::ostream& str) {
str<<" \""<<out<<"\"";
}
void AstVFile::dump(std::ostream& str) {
void AstVFile::dump(std::ostream& str) const {
this->AstNode::dump(str);
}
void AstCFile::dump(std::ostream& str) {
void AstCFile::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (source()) str<<" [SRC]";
if (slow()) str<<" [SLOW]";
}
void AstCCall::dump(std::ostream& str) {
void AstCCall::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (funcp()) {
str<<" "<<funcp()->name()<<" => ";
funcp()->dump(str);
}
}
void AstCFunc::dump(std::ostream& str) {
void AstCFunc::dump(std::ostream& str) const {
this->AstNode::dump(str);
if (slow()) str<<" [SLOW]";
if (pure()) str<<" [PURE]";

86
src/V3AstNodes.h
View File

@ -178,7 +178,7 @@ public:
int leftToRightInc() const { return littleEndian()?1:-1; }
bool littleEndian() const { return m_littleEndian; }
void littleEndian(bool flag) { m_littleEndian = flag; }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string emitC() { V3ERROR_NA; return ""; }
virtual V3Hash sameHash() const { return V3Hash(); }
virtual bool same(const AstNode* samep) const { return true; }
@ -263,7 +263,7 @@ public:
m_attrPublic = false;
}
ASTNODE_NODE_FUNCS(Typedef)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
AstNodeDType* getChildDTypep() const { return childDTypep(); }
AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } // op1 = Type assigning to
void childDTypep(AstNodeDType* nodep) { setOp1p(nodep); }
@ -410,7 +410,7 @@ public:
const AstNodeArrayDType* asamep = static_cast<const AstNodeArrayDType*>(samep);
return (subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp()));
}
virtual void dumpSmall(std::ostream& str);
virtual void dumpSmall(std::ostream& str) const;
virtual V3Hash sameHash() const { return V3Hash(m_refDTypep); }
AstNodeDType* getChildDTypep() const { return childDTypep(); }
AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); } // op1 = Range of variable
@ -498,7 +498,7 @@ private:
}
public:
ASTNODE_NODE_FUNCS(BasicDType)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual V3Hash sameHash() const { return V3Hash(V3Hash(m.m_keyword), V3Hash(m.m_nrange.hi())); }
virtual bool same(const AstNode* samep) const { // width/widthMin/numeric compared elsewhere
const AstBasicDType* sp = static_cast<const AstBasicDType*>(samep);
@ -614,8 +614,8 @@ public:
ASTNODE_NODE_FUNCS(IfaceRefDType)
// METHODS
virtual const char* broken() const;
virtual void dump(std::ostream& str=std::cout);
virtual void dumpSmall(std::ostream& str);
virtual void dump(std::ostream& str=std::cout) const;
virtual void dumpSmall(std::ostream& str) const;
virtual void cloneRelink();
virtual AstBasicDType* basicp() const { return NULL; }
virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; }
@ -669,7 +669,7 @@ public:
virtual bool similarDType(AstNodeDType* samep) const {
return skipRefp()->similarDType(samep->skipRefp()); }
virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_refDTypep), V3Hash(m_packagep)); }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual string name() const { return m_name; }
virtual AstBasicDType* basicp() const { return subDTypep() ? subDTypep()->basicp() : NULL; }
virtual AstNodeDType* skipRefp() const {
@ -803,7 +803,7 @@ public:
dtypeFrom(m_itemp);
}
ASTNODE_NODE_FUNCS(EnumItemRef)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return itemp()->name(); }
virtual const char* broken() const { BROKEN_RTN(!itemp()); return NULL; }
virtual int instrCount() const { return 0; }
@ -1017,7 +1017,7 @@ public:
dtypeSetLogicSized(bitwidth, AstNumeric::UNSIGNED);
}
ASTNODE_NODE_FUNCS(Sel)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& bit, const V3Number& width) {
out.opSel(from, bit.toUInt()+width.toUInt()-1, bit.toUInt()); }
virtual string emitVerilog() { V3ERROR_NA; return ""; } // Implemented specially
@ -1042,6 +1042,7 @@ public:
int lsbConst() const { return VN_CAST(lsbp(), Const)->toSInt(); }
int msbConst() const { return lsbConst()+widthConst()-1; }
VNumRange& declRange() { return m_declRange; }
const VNumRange& declRange() const { return m_declRange; }
void declRange(const VNumRange& flag) { m_declRange = flag; }
int declElWidth() const { return m_declElWidth; }
void declElWidth(int flag) { m_declElWidth = flag; }
@ -1060,7 +1061,7 @@ public:
new AstConst(fl, declRange.elements()))
, m_declRange(declRange) { }
ASTNODE_NODE_FUNCS(SliceSel)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual void numberOperate(V3Number& out, const V3Number& from, const V3Number& lo, const V3Number& width) {
V3ERROR_NA; }
virtual string emitVerilog() { V3ERROR_NA; return ""; } // Implemented specially
@ -1078,6 +1079,7 @@ public:
AstNode* fromp() const { return op1p(); } // op1 = Extracting what (NULL=TBD during parsing)
// For widthConst()/loConst etc, see declRange().elements() and other VNumRange methods
VNumRange& declRange() { return m_declRange; }
const VNumRange& declRange() const { return m_declRange; }
void declRange(const VNumRange& flag) { m_declRange = flag; }
};
@ -1247,7 +1249,7 @@ public:
m_declKwd = examplep->declKwd();
}
ASTNODE_NODE_FUNCS(Var)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; } // * = Var name
virtual bool hasDType() const { return true; }
virtual bool maybePointedTo() const { return true; }
@ -1526,7 +1528,7 @@ public:
BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return NULL; }
virtual bool maybePointedTo() const { return true; }
virtual string name() const {return scopep()->name()+"->"+varp()->name();} // * = Var name
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual bool hasDType() const { return true; }
AstVar* varp() const { return m_varp; } // [After Link] Pointer to variable
AstScope* scopep() const { return m_scopep; } // Pointer to scope it's under
@ -1553,7 +1555,7 @@ public:
varScopep(varscp);
}
ASTNODE_NODE_FUNCS(VarRef)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual V3Hash sameHash() const { return V3Hash(V3Hash(varp()->name()), V3Hash(hiername())); }
virtual bool same(const AstNode* samep) const {
return same(static_cast<const AstVarRef*>(samep)); }
@ -1589,7 +1591,7 @@ public:
dtypeFrom(varp);
}
ASTNODE_NODE_FUNCS(VarXRef)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
string dotted() const { return m_dotted; }
void dotted(const string& dotted) { m_dotted = dotted; }
string prettyDotted() const { return prettyName(dotted()); }
@ -1635,7 +1637,7 @@ public:
setNOp1p(exprp);
}
ASTNODE_NODE_FUNCS(Pin)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual const char* broken() const {
BROKEN_RTN(m_modVarp && !m_modVarp->brokeExists());
BROKEN_RTN(m_modPTypep && !m_modPTypep->brokeExists());
@ -1739,7 +1741,7 @@ public:
ASTNODE_NODE_FUNCS(PackageExport)
virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; }
AstPackage* packagep() const { return m_packagep; }
void packagep(AstPackage* nodep) { m_packagep = nodep; }
@ -1756,7 +1758,7 @@ public:
ASTNODE_NODE_FUNCS(PackageImport)
virtual const char* broken() const { BROKEN_RTN(!m_packagep || !m_packagep->brokeExists()); return NULL; }
virtual void cloneRelink() { if (m_packagep && m_packagep->clonep()) m_packagep = m_packagep->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; }
AstPackage* packagep() const { return m_packagep; }
void packagep(AstPackage* nodep) { m_packagep = nodep; }
@ -1784,7 +1786,7 @@ public:
: AstNode(fl), m_name(name), m_export(isExport), m_ftaskp(NULL) { }
ASTNODE_NODE_FUNCS(ModportFTaskRef)
virtual const char* broken() const { BROKEN_RTN(m_ftaskp && !m_ftaskp->brokeExists()); return NULL; }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; }
virtual void cloneRelink() { if (m_ftaskp && m_ftaskp->clonep()) m_ftaskp = m_ftaskp->clonep(); }
bool isImport() const { return !m_export; }
@ -1806,7 +1808,7 @@ public:
: AstNode(fl), m_name(name), m_direction(direction), m_varp(NULL) { }
ASTNODE_NODE_FUNCS(ModportVarRef)
virtual const char* broken() const { BROKEN_RTN(m_varp && !m_varp->brokeExists()); return NULL; }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual void cloneRelink() { if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep(); }
virtual string name() const { return m_name; }
void direction(const VDirection& flag) { m_direction = flag; }
@ -1851,7 +1853,7 @@ public:
addNOp1p(pinsp); addNOp2p(paramsp); setNOp3p(rangep); }
ASTNODE_NODE_FUNCS(Cell)
// No cloneRelink, we presume cloneee's want the same module linkages
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual const char* broken() const { BROKEN_RTN(m_modp && !m_modp->brokeExists()); return NULL; }
virtual bool maybePointedTo() const { return true; }
// ACCESSORS
@ -1892,7 +1894,7 @@ public:
: AstNode(fl)
, m_name(name), m_origModName(origModName), m_scopep(NULL) {}
ASTNODE_NODE_FUNCS(CellInline)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual const char* broken() const { BROKEN_RTN(m_scopep && !m_scopep->brokeExists()); return NULL; }
// ACCESSORS
virtual string name() const { return m_name; } // * = Cell name
@ -2017,7 +2019,7 @@ public:
AstNode* lhsp, AstNodeFTaskRef* ftaskrefp)
: AstNode(fl), m_expect(expect), m_name(name) { setNOp1p(lhsp); setNOp2p(ftaskrefp); }
ASTNODE_NODE_FUNCS(ParseRef)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; } // * = Var name
virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_expect), V3Hash(m_name)); }
virtual bool same(const AstNode* samep) const {
@ -2050,7 +2052,7 @@ public:
virtual bool same(const AstNode* samep) const {
return (m_packagep==static_cast<const AstPackageRef*>(samep)->m_packagep); }
virtual V3Hash sameHash() const { return V3Hash(m_packagep); }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
AstPackage* packagep() const { return m_packagep; }
void packagep(AstPackage* nodep) { m_packagep = nodep; }
};
@ -2066,7 +2068,7 @@ public:
if (!packagep) return rhsp;
return new AstDot(fl, new AstPackageRef(fl, packagep), rhsp);
}
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string emitVerilog() { V3ERROR_NA; return ""; }
virtual string emitC() { V3ERROR_NA; return ""; }
AstNode* lhsp() const { return op1p(); }
@ -2172,7 +2174,7 @@ public:
m_edgeType = VEdgeType::ET_NEVER;
}
ASTNODE_NODE_FUNCS(SenItem)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual V3Hash sameHash() const { return V3Hash(edgeType()); }
virtual bool same(const AstNode* samep) const {
return edgeType()==static_cast<const AstSenItem*>(samep)->edgeType(); }
@ -2225,7 +2227,7 @@ public:
addNOp1p(sensesp);
}
ASTNODE_NODE_FUNCS(SenTree)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual bool maybePointedTo() const { return true; }
virtual V3Hash sameHash() const { return V3Hash(); }
bool isMulti() const { return m_multi; }
@ -2248,7 +2250,7 @@ public:
}
ASTNODE_NODE_FUNCS(Always)
//
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
AstSenTree* sensesp() const { return VN_CAST(op1p(), SenTree); } // op1 = Sensitivity list
AstNode* bodysp() const { return op2p(); } // op2 = Statements to evaluate
void addStmtp(AstNode* nodep) { addOp2p(nodep); }
@ -2457,7 +2459,7 @@ public:
}
return NULL; }
virtual void cloneRelink() { if (m_dataDeclp && m_dataDeclp->clonep()) m_dataDeclp = m_dataDeclp->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual int instrCount() const { return 1+2*instrCountLd(); }
virtual bool maybePointedTo() const { return true; }
int column() const { return m_column; }
@ -2497,7 +2499,7 @@ public:
ASTNODE_NODE_FUNCS(CoverInc)
virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual int instrCount() const { return 1+2*instrCountLd(); }
virtual V3Hash sameHash() const { return V3Hash(declp()); }
virtual bool same(const AstNode* samep) const {
@ -2667,7 +2669,7 @@ public:
m_displayType = dispType;
}
ASTNODE_NODE_FUNCS(Display)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual const char* broken() const { BROKEN_RTN(!fmtp()); return NULL; }
virtual string verilogKwd() const { return (filep() ? string("$f")+string(displayType().ascii())
: string("$")+string(displayType().ascii())); }
@ -3338,7 +3340,7 @@ public:
ASTNODE_NODE_FUNCS(JumpGo)
virtual const char* broken() const { BROKEN_RTN(!labelp()->brokeExistsAbove()); return NULL; }
virtual void cloneRelink() { if (m_labelp->clonep()) m_labelp = m_labelp->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual int instrCount() const { return instrCountBranch(); }
virtual V3Hash sameHash() const { return V3Hash(labelp()); }
virtual bool same(const AstNode* samep) const { // Also same if identical tree structure all the way down, but hard to detect
@ -3411,7 +3413,7 @@ public:
m_generate = generate;
}
ASTNODE_NODE_FUNCS(Begin)
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual string name() const { return m_name; } // * = Block name
virtual void name(const string& name) { m_name = name; }
// op1 = Statements
@ -3627,7 +3629,7 @@ public:
ASTNODE_NODE_FUNCS(TraceInc)
virtual const char* broken() const { BROKEN_RTN(!declp()->brokeExists()); return NULL; }
virtual void cloneRelink() { if (m_declp->clonep()) m_declp = m_declp->clonep(); }
virtual void dump(std::ostream& str);
virtual void dump(std::ostream& str) const;
virtual int instrCount() const { return 10+2*instrCountLd(); }
virtual bool hasDType() const { return true; }
virtual V3Hash sameHash() const { return V3Hash(declp()); }
@ -3660,7 +3662,7 @@ public:
m_sensesp = sensesp;
}
ASTNODE_NODE_FUNCS(Active)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual string name() const { return m_name; }
virtual const char* broken() const { BROKEN_RTN(m_sensesp && !m_sensesp->brokeExists()); return NULL; }
virtual void cloneRelink() {
@ -3699,7 +3701,7 @@ public:
AstNode* dimp() const { return op2p(); }
AstAttrType attrType() const { return m_attrType; }
virtual V3Hash sameHash() const { return V3Hash(m_attrType); }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
};
class AstScopeName : public AstNodeMath {
@ -4232,7 +4234,7 @@ public:
virtual V3Hash sameHash() const { return V3Hash(size()); }
virtual bool same(const AstNode* samep) const {
return size() == static_cast<const AstCCast*>(samep)->size(); }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
//
int size() const { return m_size; }
};
@ -5899,7 +5901,7 @@ public:
AstVFile(FileLine* fl, const string& name)
: AstFile(fl, name) { }
ASTNODE_NODE_FUNCS(VFile)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
};
//======================================================================
@ -5920,7 +5922,7 @@ public:
m_support = false;
}
ASTNODE_NODE_FUNCS(CFile)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
bool slow() const { return m_slow; }
void slow(bool flag) { m_slow = flag; }
bool source() const { return m_source; }
@ -5983,7 +5985,7 @@ public:
virtual string name() const { return m_name; }
virtual const char* broken() const { BROKEN_RTN((m_scopep && !m_scopep->brokeExists())); return NULL; }
virtual bool maybePointedTo() const { return true; }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual V3Hash sameHash() const { return V3Hash(); }
virtual bool same(const AstNode* samep) const {
const AstCFunc* asamep = static_cast<const AstCFunc*>(samep);
@ -6075,7 +6077,7 @@ public:
if (oldp->argsp()) addNOp1p(oldp->argsp()->unlinkFrBackWithNext());
}
ASTNODE_NODE_FUNCS(CCall)
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
virtual void cloneRelink() { if (m_funcp && m_funcp->clonep()) {
m_funcp = m_funcp->clonep();
}}
@ -6196,7 +6198,7 @@ public:
void addStmtsp(AstNode* nodep) { addOp1p(nodep); }
ExecMTask* execMTaskp() const { return m_execMTaskp; }
void execMTaskp(ExecMTask* execMTaskp) { m_execMTaskp = execMTaskp; }
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
};
class AstExecGraph : public AstNode {
@ -6253,7 +6255,7 @@ public:
AstBasicDType* findInsertSameDType(AstBasicDType* nodep);
void clearCache();
void repairCache();
virtual void dump(std::ostream& str=std::cout);
virtual void dump(std::ostream& str=std::cout) const;
};
//######################################################################