Mario1159/verilator
1
0
Fork 0
forked from github/verilator
Code Pull Requests Releases 1 Activity

Emit model implementation as loose methods. (#3006)

Browse Source 
This patch introduces the concept of 'loose' methods, which semantically
are methods, but are declared as global functions, and are passed an
explicit 'self' pointer. This enables these methods to be declared
outside the class, only when they are needed, therefore removing the
header dependency. The bulk of the emitted model implementation now uses
loose methods.
This commit is contained in:
Geza Lore 2021-06-13 14:33:11 +01:00 committed by GitHub
parent 18cabc369b
commit 60d5f0e86b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
48 changed files with 916 additions and 571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Changes
View File

@ -11,6 +11,11 @@ contributors that suggested a given feature are shown in []. Thanks!
Verilator 4.205 devel
==========================
**Major:**
* Generated code is now emitted as global functions rather than methods. '$c'
contents might need to be updated, see the docs (#3006). [Geza Lore]
**Minor:**

7
docs/guide/extensions.rst
View File

@ -33,7 +33,12 @@ or "`ifdef`"'s may break other tools.
that returns up to a 32-bit number (without a trailing ;). This can be
used to call C++ functions from your Verilog code.
String arguments will be put directly into the output C++ code.
String arguments will be put directly into the output C++ code, except
the word 'this' (i.e.: the object pointer) might be replaced with a
different pointer as Verilator might implement logic with non-member
functions. For this reason, any references to class members must be made
via an explicit 'this->' pointer dereference.
Expression arguments will have the code to evaluate the expression
inserted. Thus to call a C++ function, :code:`$c("func(",a,")")` will
result in :code:`func(a)` in the output C++ code. For input arguments,

2
include/verilated_threads.cpp
View File

@ -74,7 +74,7 @@ void VlWorkerThread::workerLoop() {
if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire))) break;
if (VL_LIKELY(work.m_fnp)) {
work.m_fnp(work.m_evenCycle, work.m_sym);
work.m_fnp(work.m_selfp, work.m_evenCycle);
work.m_fnp = nullptr;
}
}

20
include/verilated_threads.h
View File

@ -48,12 +48,12 @@
#endif
// clang-format on
// VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
// VlMTaskVertex and VlThreadpool will work with multiple model class types.
// Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
// as a void* here.
using VlThrSymTab = void*;
using VlSelfP = void*;
using VlExecFnp = void (*)(bool, VlThrSymTab);
using VlExecFnp = void (*)(VlSelfP, bool);
// Track dependencies for a single MTask.
class VlMTaskVertex final {
@ -177,15 +177,15 @@ private:
// TYPES
struct ExecRec {
VlExecFnp m_fnp; // Function to execute
VlThrSymTab m_sym; // Symbol table to execute
VlSelfP m_selfp; // Symbol table to execute
bool m_evenCycle; // Even/odd for flag alternation
ExecRec()
: m_fnp{nullptr}
, m_sym{nullptr}
, m_selfp{nullptr}
, m_evenCycle{false} {}
ExecRec(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
ExecRec(VlExecFnp fnp, VlSelfP selfp, bool evenCycle)
: m_fnp{fnp}
, m_sym{sym}
, m_selfp{selfp}
, m_evenCycle{evenCycle} {}
};
@ -237,13 +237,13 @@ public:
m_ready.erase(m_ready.begin());
m_ready_size.fetch_sub(1, std::memory_order_relaxed);
}
inline void wakeUp() { addTask(nullptr, false, nullptr); }
inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
inline void wakeUp() { addTask(nullptr, nullptr, false); }
inline void addTask(VlExecFnp fnp, VlSelfP selfp, bool evenCycle)
VL_MT_SAFE_EXCLUDES(m_mutex) {
bool notify;
{
const VerilatedLockGuard lk(m_mutex);
m_ready.emplace_back(fnp, evenCycle, sym);
m_ready.emplace_back(fnp, selfp, evenCycle);
m_ready_size.fetch_add(1, std::memory_order_relaxed);
notify = m_waiting;
}

5
src/V3Active.cpp
View File

@ -474,11 +474,10 @@ private:
if (!m_scopeFinalp) {
m_scopeFinalp = new AstCFunc(
nodep->fileline(), "_final_" + m_namer.scopep()->nameDotless(), m_namer.scopep());
m_scopeFinalp->argTypes(EmitCBaseVisitor::symClassVar());
m_scopeFinalp->addInitsp(
new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
m_scopeFinalp->dontCombine(true);
m_scopeFinalp->formCallTree(true);
m_scopeFinalp->isStatic(false);
m_scopeFinalp->isLoose(true);
m_scopeFinalp->slow(true);
m_namer.scopep()->addActivep(m_scopeFinalp);
}

33
src/V3Ast.h
View File

@ -1687,6 +1687,7 @@ public:
AstNodeDType* findSigned32DType() { return findBasicDType(AstBasicDTypeKwd::INTEGER); }
AstNodeDType* findUInt32DType() { return findBasicDType(AstBasicDTypeKwd::UINT32); }
AstNodeDType* findUInt64DType() { return findBasicDType(AstBasicDTypeKwd::UINT64); }
AstNodeDType* findCHandleDType() { return findBasicDType(AstBasicDTypeKwd::CHANDLE); }
AstNodeDType* findVoidDType() const;
AstNodeDType* findQueueIndexDType() const;
AstNodeDType* findBitDType(int width, int widthMin, VSigning numeric) const;
@ -2272,9 +2273,9 @@ private:
AstVarScope* m_varScopep = nullptr; // Varscope for hierarchy
AstNodeModule* m_classOrPackagep = nullptr; // Package hierarchy
string m_name; // Name of variable
string m_hiernameToProt; // Scope converted into name-> for emitting
string m_hiernameToUnprot; // Scope converted into name-> for emitting
bool m_hierThis = false; // Hiername points to "this" function
string m_selfPointer; // Output code object pointer (e.g.: 'this')
string m_classPrefix; // Output class prefix (i.e.: the part before ::)
bool m_hierThis = false; // m_selfPointer points to "this" function
protected:
AstNodeVarRef(AstType t, FileLine* fl, const string& name, const VAccess& access)
@ -2306,13 +2307,14 @@ public:
void varp(AstVar* varp);
AstVarScope* varScopep() const { return m_varScopep; }
void varScopep(AstVarScope* varscp) { m_varScopep = varscp; }
string hiernameToProt() const { return m_hiernameToProt; }
void hiernameToProt(const string& hn) { m_hiernameToProt = hn; }
string hiernameToUnprot() const { return m_hiernameToUnprot; }
void hiernameToUnprot(const string& hn) { m_hiernameToUnprot = hn; }
string hiernameProtect() const;
bool hierThis() const { return m_hierThis; }
void hierThis(bool flag) { m_hierThis = flag; }
string selfPointer() const { return m_selfPointer; }
void selfPointer(const string& value) { m_selfPointer = value; }
string selfPointerProtect(bool useSelfForThis) const;
string classPrefix() const { return m_classPrefix; }
void classPrefix(const string& value) { m_classPrefix = value; }
string classPrefixProtect() const;
AstNodeModule* classOrPackagep() const { return m_classOrPackagep; }
void classOrPackagep(AstNodeModule* nodep) { m_classOrPackagep = nodep; }
// Know no children, and hot function, so skip iterator for speed
@ -2615,8 +2617,8 @@ class AstNodeCCall VL_NOT_FINAL : public AstNodeStmt {
// A call of a C++ function, perhaps a AstCFunc or perhaps globally named
// Functions are not statements, while tasks are. AstNodeStmt needs isStatement() to deal.
AstCFunc* m_funcp;
string m_hiernameToProt;
string m_hiernameToUnprot;
string m_selfPointer; // Output code object pointer (e.g.: 'this')
string m_classPrefix; // Output class prefix (i.e.: the part before ::)
string m_argTypes;
protected:
@ -2642,11 +2644,12 @@ public:
virtual bool isPure() const override;
virtual bool isOutputter() const override { return !isPure(); }
AstCFunc* funcp() const { return m_funcp; }
string hiernameToProt() const { return m_hiernameToProt; }
void hiernameToProt(const string& hn) { m_hiernameToProt = hn; }
string hiernameToUnprot() const { return m_hiernameToUnprot; }
void hiernameToUnprot(const string& hn) { m_hiernameToUnprot = hn; }
string hiernameProtect() const;
string selfPointer() const { return m_selfPointer; }
void selfPointer(const string& value) { m_selfPointer = value; }
string selfPointerProtect(bool useSelfForThis) const;
string classPrefix() const { return m_classPrefix; }
void classPrefix(const string& value) { m_classPrefix = value; }
string classPrefixProtect() const;
void argTypes(const string& str) { m_argTypes = str; }
string argTypes() const { return m_argTypes; }
// op1p reserved for AstCMethodCall

43
src/V3AstNodes.cpp
View File

@ -55,8 +55,23 @@ void AstNodeVarRef::cloneRelink() {
if (m_varp && m_varp->clonep()) m_varp = m_varp->clonep();
}
string AstNodeVarRef::hiernameProtect() const {
return hiernameToUnprot() + VIdProtect::protectWordsIf(hiernameToProt(), protect());
string AstNodeVarRef::selfPointerProtect(bool useSelfForThis) const {
const string& sp
= useSelfForThis ? VString::replaceWord(selfPointer(), "this", "vlSelf") : selfPointer();
return VIdProtect::protectWordsIf(sp, protect());
}
string AstNodeVarRef::classPrefixProtect() const {
return v3Global.opt.modPrefix() + "_" + VIdProtect::protectWordsIf(classPrefix(), protect());
}
void AstAddrOfCFunc::cloneRelink() {
if (m_funcp && m_funcp->clonep()) m_funcp = m_funcp->clonep();
}
const char* AstAddrOfCFunc::broken() const {
BROKEN_RTN(m_funcp && !m_funcp->brokeExists());
return nullptr;
}
int AstNodeSel::bitConst() const {
@ -108,8 +123,13 @@ const char* AstNodeCCall::broken() const {
return nullptr;
}
bool AstNodeCCall::isPure() const { return funcp()->pure(); }
string AstNodeCCall::hiernameProtect() const {
return hiernameToUnprot() + VIdProtect::protectWordsIf(hiernameToProt(), protect());
string AstNodeCCall::selfPointerProtect(bool useSelfForThis) const {
const string& sp
= useSelfForThis ? VString::replaceWord(selfPointer(), "this", "vlSelf") : selfPointer();
return VIdProtect::protectWordsIf(sp, protect());
}
string AstNodeCCall::classPrefixProtect() const {
return v3Global.opt.modPrefix() + "_" + VIdProtect::protectWordsIf(classPrefix(), protect());
}
void AstNodeCond::numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs,
@ -221,6 +241,21 @@ AstExecGraph::AstExecGraph(FileLine* fileline)
}
AstExecGraph::~AstExecGraph() { VL_DO_DANGLING(delete m_depGraphp, m_depGraphp); }
std::vector<const ExecMTask*> AstExecGraph::rootMTasks() {
// Build the list of initial mtasks to start
std::vector<const ExecMTask*> execMTasks;
for (const V3GraphVertex* vxp = depGraphp()->verticesBeginp(); vxp;
vxp = vxp->verticesNextp()) {
const ExecMTask* etp = dynamic_cast<const ExecMTask*>(vxp);
if (etp->threadRoot()) execMTasks.push_back(etp);
}
UASSERT_OBJ(execMTasks.size() <= static_cast<unsigned>(v3Global.opt.threads()), this,
"More root mtasks than available threads");
return execMTasks;
}
AstNode* AstInsideRange::newAndFromInside(AstNode* exprp, AstNode* lhsp, AstNode* rhsp) {
AstNode* ap = new AstGte(fileline(), exprp->cloneTree(true), lhsp);
AstNode* bp = new AstLte(fileline(), exprp->cloneTree(true), rhsp);

51
src/V3AstNodes.h
View File

@ -2388,8 +2388,7 @@ public:
if (varScopep()) {
return (varScopep() == samep->varScopep() && access() == samep->access());
} else {
return (hiernameToProt() == samep->hiernameToProt()
&& hiernameToUnprot() == samep->hiernameToUnprot()
return (selfPointer() == samep->selfPointer()
&& varp()->name() == samep->varp()->name() && access() == samep->access());
}
}
@ -2397,9 +2396,8 @@ public:
if (varScopep()) {
return (varScopep() == samep->varScopep());
} else {
return (hiernameToProt() == samep->hiernameToProt()
&& hiernameToUnprot() == samep->hiernameToUnprot()
&& (!hiernameToProt().empty() || !samep->hiernameToProt().empty())
return (selfPointer() == samep->selfPointer()
&& (!selfPointer().empty() || !samep->selfPointer().empty())
&& varp()->name() == samep->varp()->name());
}
}
@ -2439,12 +2437,33 @@ public:
virtual int instrCount() const override { return widthInstrs(); }
virtual bool same(const AstNode* samep) const override {
const AstVarXRef* asamep = static_cast<const AstVarXRef*>(samep);
return (hiernameToProt() == asamep->hiernameToProt()
&& hiernameToUnprot() == asamep->hiernameToUnprot() && varp() == asamep->varp()
return (selfPointer() == asamep->selfPointer() && varp() == asamep->varp()
&& name() == asamep->name() && dotted() == asamep->dotted());
}
};
class AstAddrOfCFunc final : public AstNodeMath {
// Get address of CFunc
private:
AstCFunc* m_funcp; // Pointer to function itself
public:
AstAddrOfCFunc(FileLine* fl, AstCFunc* funcp)
: ASTGEN_SUPER_AddrOfCFunc(fl)
, m_funcp{funcp} {
dtypep(findCHandleDType());
}
public:
ASTNODE_NODE_FUNCS(AddrOfCFunc)
virtual void cloneRelink() override;
virtual const char* broken() const override;
virtual string emitVerilog() override { V3ERROR_NA_RETURN(""); }
virtual string emitC() override { V3ERROR_NA_RETURN(""); }
virtual bool cleanOut() const override { return true; }
AstCFunc* funcp() const { return m_funcp; }
};
class AstPin final : public AstNode {
// A pin on a cell
private:
@ -8717,7 +8736,6 @@ private:
VBoolOrUnknown m_isConst; // Function is declared const (*this not changed)
VBoolOrUnknown m_isStatic; // Function is declared static (no this)
bool m_dontCombine : 1; // V3Combine shouldn't compare this func tree, it's special
bool m_skipDecl : 1; // Don't declare it
bool m_declPrivate : 1; // Declare it private
bool m_formCallTree : 1; // Make a global function to call entire tree of functions
bool m_slow : 1; // Slow routine, called once or just at init time
@ -8725,9 +8743,10 @@ private:
bool m_isConstructor : 1; // Is C class constructor
bool m_isDestructor : 1; // Is C class destructor
bool m_isMethod : 1; // Is inside a class definition
bool m_isLoose : 1; // Semantically this is a method, but is implemented as a function
// with an explicitly passed 'self' pointer as the first argument
bool m_isInline : 1; // Inline function
bool m_isVirtual : 1; // Virtual function
bool m_symProlog : 1; // Setup symbol table for later instructions
bool m_entryPoint : 1; // User may call into this top level function
bool m_pure : 1; // Pure function
bool m_dpiExport : 1; // From dpi export
@ -8744,7 +8763,6 @@ public:
m_name = name;
m_rtnType = rtnType;
m_dontCombine = false;
m_skipDecl = false;
m_declPrivate = false;
m_formCallTree = false;
m_slow = false;
@ -8752,9 +8770,9 @@ public:
m_isConstructor = false;
m_isDestructor = false;
m_isMethod = true;
m_isLoose = false;
m_isInline = false;
m_isVirtual = false;
m_symProlog = false;
m_entryPoint = false;
m_pure = false;
m_dpiExport = false;
@ -8774,6 +8792,7 @@ public:
const AstCFunc* asamep = static_cast<const AstCFunc*>(samep);
return ((funcType() == asamep->funcType()) && (rtnTypeVoid() == asamep->rtnTypeVoid())
&& (argTypes() == asamep->argTypes()) && (ctorInits() == asamep->ctorInits())
&& isLoose() == asamep->isLoose()
&& (!(dpiImport() || dpiExport()) || name() == asamep->name()));
}
//
@ -8792,9 +8811,7 @@ public:
string rtnTypeVoid() const { return ((m_rtnType == "") ? "void" : m_rtnType); }
bool dontCombine() const { return m_dontCombine || funcType() != AstCFuncType::FT_NORMAL; }
void dontCombine(bool flag) { m_dontCombine = flag; }
bool dontInline() const { return dontCombine() || slow() || skipDecl() || funcPublic(); }
bool skipDecl() const { return m_skipDecl; }
void skipDecl(bool flag) { m_skipDecl = flag; }
bool dontInline() const { return dontCombine() || slow() || funcPublic(); }
bool declPrivate() const { return m_declPrivate; }
void declPrivate(bool flag) { m_declPrivate = flag; }
bool formCallTree() const { return m_formCallTree; }
@ -8817,12 +8834,13 @@ public:
void isDestructor(bool flag) { m_isDestructor = flag; }
bool isMethod() const { return m_isMethod; }
void isMethod(bool flag) { m_isMethod = flag; }
bool isLoose() const { return m_isLoose; }
void isLoose(bool flag) { m_isLoose = flag; }
bool isProperMethod() const { return isMethod() && !isLoose(); }
bool isInline() const { return m_isInline; }
void isInline(bool flag) { m_isInline = flag; }
bool isVirtual() const { return m_isVirtual; }
void isVirtual(bool flag) { m_isVirtual = flag; }
bool symProlog() const { return m_symProlog; }
void symProlog(bool flag) { m_symProlog = flag; }
bool entryPoint() const { return m_entryPoint; }
void entryPoint(bool flag) { m_entryPoint = flag; }
bool pure() const { return m_pure; }
@ -9039,6 +9057,7 @@ public:
const V3Graph* depGraphp() const { return m_depGraphp; }
V3Graph* mutableDepGraphp() { return m_depGraphp; }
void addMTaskBody(AstMTaskBody* bodyp) { addOp1p(bodyp); }
std::vector<const ExecMTask*> rootMTasks();
};
class AstSplitPlaceholder final : public AstNode {

32
src/V3CCtors.cpp
View File

@ -61,23 +61,21 @@ private:
const int funcNum = m_newFunctions.size();
const string funcName = m_basename + "_" + cvtToStr(funcNum);
AstCFunc* const funcp = new AstCFunc(m_modp->fileline(), funcName, nullptr, "void");
funcp->isStatic(!m_type.isClass()); // Class constructors are non static
funcp->isStatic(false);
funcp->isLoose(!m_type.isClass());
funcp->declPrivate(true);
funcp->slow(!m_type.isClass()); // Only classes construct on fast path
string preventUnusedStmt;
if (m_type.isClass()) {
funcp->argTypes(EmitCBaseVisitor::symClassVar());
preventUnusedStmt = "if (false && vlSymsp) {}";
preventUnusedStmt = "if (false && vlSymsp) {} // Prevent unused\n";
} else if (m_type.isCoverage()) {
funcp->argTypes(EmitCBaseVisitor::prefixNameProtect(m_modp) + "* self, "
+ EmitCBaseVisitor::symClassVar() + ", bool first");
preventUnusedStmt = "if (false && self && vlSymsp && first) {}";
} else { // Module
funcp->argTypes(EmitCBaseVisitor::prefixNameProtect(m_modp) + "* self");
preventUnusedStmt = "if (false && self) {}";
funcp->argTypes("bool first");
preventUnusedStmt = "if (false && first) {} // Prevent unused\n";
}
if (!preventUnusedStmt.empty()) {
funcp->addStmtsp(new AstCStmt(m_modp->fileline(), preventUnusedStmt));
}
preventUnusedStmt += " // Prevent unused\n";
funcp->addStmtsp(new AstCStmt(m_modp->fileline(), preventUnusedStmt));
m_modp->addStmtp(funcp);
m_numStmts = 0;
return funcp;
@ -113,10 +111,9 @@ public:
AstCCall* const callp = new AstCCall(m_modp->fileline(), funcp);
if (m_type.isClass()) {
callp->argTypes("vlSymsp");
} else if (m_type.isCoverage()) {
callp->argTypes("self, vlSymsp, first");
} else { // Module
callp->argTypes("self");
} else {
if (m_type.isCoverage()) callp->argTypes("first");
callp->selfPointer("this");
}
rootFuncp->addStmtsp(callp);
}
@ -134,6 +131,7 @@ void V3CCtors::evalAsserts() {
AstCFunc* funcp = new AstCFunc(modp->fileline(), "_eval_debug_assertions", nullptr, "void");
funcp->declPrivate(true);
funcp->isStatic(false);
funcp->isLoose(true);
funcp->slow(false);
funcp->ifdef("VL_DEBUG");
modp->addStmtp(funcp);
@ -145,7 +143,11 @@ void V3CCtors::evalAsserts() {
int lastWordWidth = varp->width() % storedWidth;
if (lastWordWidth != 0) {
// if (signal & CONST(upper_non_clean_mask)) { fail; }
AstNode* newp = new AstVarRef(varp->fileline(), varp, VAccess::READ);
AstVarRef* const vrefp
= new AstVarRef(varp->fileline(), varp, VAccess::READ);
vrefp->selfPointer(v3Global.opt.relativeCFuncs() ? "this"
: "vlSymsp->TOPp");
AstNode* newp = vrefp;
if (varp->isWide()) {
newp = new AstWordSel(
varp->fileline(), newp,

9
src/V3Changed.cpp
View File

@ -61,14 +61,13 @@ public:
m_chgFuncp
= new AstCFunc(m_scopetopp->fileline(), "_change_request_" + cvtToStr(++m_funcNum),
m_scopetopp, "QData");
m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
m_chgFuncp->symProlog(true);
m_chgFuncp->isStatic(false);
m_chgFuncp->isLoose(true);
m_chgFuncp->declPrivate(true);
m_scopetopp->addActivep(m_chgFuncp);
// Add a top call to it
AstCCall* callp = new AstCCall(m_scopetopp->fileline(), m_chgFuncp);
callp->argTypes("vlSymsp");
if (!m_tlChgFuncp->stmtsp()) {
m_tlChgFuncp->addStmtsp(new AstCReturn(m_scopetopp->fileline(), callp));
@ -251,8 +250,8 @@ private:
// Create a wrapper change detection function that calls each change detection function
m_statep->m_tlChgFuncp
= new AstCFunc(nodep->fileline(), "_change_request", scopep, "QData");
m_statep->m_tlChgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
m_statep->m_tlChgFuncp->symProlog(true);
m_statep->m_tlChgFuncp->isStatic(false);
m_statep->m_tlChgFuncp->isLoose(true);
m_statep->m_tlChgFuncp->declPrivate(true);
m_statep->m_scopetopp->addActivep(m_statep->m_tlChgFuncp);
// Each change detection function needs at least one AstChangeDet

72
src/V3Clock.cpp
View File

@ -164,6 +164,18 @@ private:
m_lastSenp = nullptr;
m_lastIfp = nullptr;
}
AstCFunc* makeTopFunction(const string& name, bool slow = false) {
AstCFunc* const funcp = new AstCFunc{m_topScopep->fileline(), name, m_topScopep->scopep()};
funcp->dontCombine(true);
funcp->isStatic(false);
funcp->isLoose(true);
funcp->entryPoint(true);
funcp->slow(slow);
funcp->isConst(false);
funcp->declPrivate(true);
m_topScopep->scopep()->addActivep(funcp);
return funcp;
}
void splitCheck(AstCFunc* ofuncp) {
if (!v3Global.opt.outputSplitCFuncs() || !ofuncp->stmtsp()) return;
if (EmitCBaseCounterVisitor(ofuncp->stmtsp()).count() < v3Global.opt.outputSplitCFuncs())
@ -184,15 +196,13 @@ private:
// Make a new function
funcp = new AstCFunc{ofuncp->fileline(), ofuncp->name() + cvtToStr(++funcnum),
m_topScopep->scopep()};
funcp->argTypes(EmitCBaseVisitor::symClassVar());
funcp->dontCombine(true);
funcp->symProlog(true);
funcp->isStatic(true);
funcp->isStatic(false);
funcp->isLoose(true);
funcp->slow(ofuncp->slow());
m_topScopep->scopep()->addActivep(funcp);
//
AstCCall* callp = new AstCCall{funcp->fileline(), funcp};
callp->argTypes("vlSymsp");
ofuncp->addStmtsp(callp);
func_stmts = 0;
}
@ -212,55 +222,10 @@ private:
// VV***** We reset all user1p()
AstNode::user1ClearTree();
// Make top functions
{
AstCFunc* funcp = new AstCFunc{nodep->fileline(), "_eval", m_topScopep->scopep()};
funcp->argTypes(EmitCBaseVisitor::symClassVar());
funcp->dontCombine(true);
funcp->symProlog(true);
funcp->isStatic(true);
funcp->entryPoint(true);
m_topScopep->scopep()->addActivep(funcp);
m_evalFuncp = funcp;
}
{
AstCFunc* funcp
= new AstCFunc{nodep->fileline(), "_eval_initial", m_topScopep->scopep()};
funcp->argTypes(EmitCBaseVisitor::symClassVar());
funcp->dontCombine(true);
funcp->slow(true);
funcp->symProlog(true);
funcp->isStatic(true);
funcp->entryPoint(true);
m_topScopep->scopep()->addActivep(funcp);
m_initFuncp = funcp;
}
{
AstCFunc* funcp = new AstCFunc{nodep->fileline(), "final", m_topScopep->scopep()};
funcp->skipDecl(true);
funcp->dontCombine(true);
funcp->slow(true);
funcp->isStatic(false);
funcp->entryPoint(true);
funcp->protect(false);
funcp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symClassVar()
+ " = this->__VlSymsp;\n"));
funcp->addInitsp(
new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
m_topScopep->scopep()->addActivep(funcp);
m_finalFuncp = funcp;
}
{
AstCFunc* funcp
= new AstCFunc{nodep->fileline(), "_eval_settle", m_topScopep->scopep()};
funcp->argTypes(EmitCBaseVisitor::symClassVar());
funcp->dontCombine(true);
funcp->slow(true);
funcp->isStatic(true);
funcp->symProlog(true);
funcp->entryPoint(true);
m_topScopep->scopep()->addActivep(funcp);
m_settleFuncp = funcp;
}
m_evalFuncp = makeTopFunction("_eval");
m_initFuncp = makeTopFunction("_eval_initial", /* slow: */ true);
m_settleFuncp = makeTopFunction("_eval_settle", /* slow: */ true);
m_finalFuncp = makeTopFunction("_final", /* slow: */ true);
// Process the activates
iterateChildren(nodep);
UINFO(4, " TOPSCOPE iter done " << nodep << endl);
@ -324,7 +289,6 @@ private:
if (nodep->formCallTree()) {
UINFO(4, " formCallTree " << nodep << endl);
AstCCall* callp = new AstCCall(nodep->fileline(), nodep);
callp->argTypes("vlSymsp");
m_finalFuncp->addStmtsp(callp);
}
}

23
src/V3Combine.cpp
View File

@ -72,8 +72,8 @@ public:
AstNode* const argsp
= oldp->argsp() ? oldp->argsp()->unlinkFrBackWithNext() : nullptr;
AstCCall* const newp = new AstCCall(oldp->fileline(), newfuncp, argsp);
newp->hiernameToProt(oldp->hiernameToProt());
newp->hiernameToUnprot(oldp->hiernameToUnprot());
newp->selfPointer(oldp->selfPointer());
newp->classPrefix(oldp->classPrefix());
newp->argTypes(oldp->argTypes());
addCall(newp); // Fix the table, in case the newfuncp itself gets replaced
oldp->replaceWith(newp);
@ -86,14 +86,23 @@ public:
}
}
// METHODS
void addCall(AstCCall* nodep) {
if (nodep->funcp()->dontCombine()) return;
m_callMmap.emplace(nodep->funcp(), nodep);
}
void addCall(AstCCall* nodep) { m_callMmap.emplace(nodep->funcp(), nodep); }
private:
// VISITORS
virtual void visit(AstCCall* nodep) override { addCall(nodep); }
virtual void visit(AstCCall* nodep) override {
if (nodep->funcp()->dontCombine()) return;
addCall(nodep);
}
// LCOV_EXCL_START
virtual void visit(AstAddrOfCFunc* nodep) override {
// We cannot yet handle references via AstAddrOfCFunc, but currently those are
// only used in tracing functions, which are not combined. Blow up in case this changes.
if (nodep->funcp()->dontCombine()) return;
nodep->v3fatalSrc(
"Don't know how to combine functions that are referenced via AstAddrOfCFunc");
}
// LCOV_EXCL_END
// Speed things up
virtual void visit(AstNodeAssign*) override {}
virtual void visit(AstNodeMath*) override {}

11
src/V3DepthBlock.cpp
View File

@ -51,14 +51,19 @@ private:
// Create function
string name = m_cfuncp->name() + "__deep" + cvtToStr(++m_deepNum);
AstCFunc* funcp = new AstCFunc(nodep->fileline(), name, nullptr);
funcp->argTypes(EmitCBaseVisitor::symClassVar());
funcp->symProlog(true);
funcp->slow(m_cfuncp->slow());
funcp->isStatic(m_cfuncp->isStatic());
funcp->isLoose(m_cfuncp->isLoose());
funcp->addStmtsp(nodep);
m_modp->addStmtp(funcp);
// Call it at the point where the body was removed from
AstCCall* callp = new AstCCall(nodep->fileline(), funcp);
callp->argTypes("vlSymsp");
if (VN_IS(m_modp, Class)) {
funcp->argTypes(EmitCBaseVisitor::symClassVar());
callp->argTypes("vlSymsp");
} else if (funcp->isStatic().falseUnknown()) {
callp->selfPointer("this");
}
UINFO(6, " New " << callp << endl);
//
relinkHandle.relink(callp);

122
src/V3Descope.cpp
View File

@ -56,7 +56,8 @@ private:
VL_DEBUG_FUNC; // Declare debug()
static bool modIsSingleton(AstNodeModule* modp) {
// True iff there's exactly one instance of this module in the design.
// True iff there's exactly one instance of this module in the design (including top).
if (modp->isTop()) return true;
int instances = 0;
for (AstNode* stmtp = modp->stmtsp(); stmtp; stmtp = stmtp->nextp()) {
if (VN_IS(stmtp, Scope)) {
@ -66,85 +67,68 @@ private:
return (instances == 1);
}
// Construct the best prefix to reference an object in 'scopep'
// from a CFunc in 'm_scopep'. Result may be relative
// ("this->[...]") or absolute ("vlTOPp->[...]").
// Construct the best self pointer to reference an object in 'scopep' from a CFunc in
// 'm_scopep'. Result may be relative ("this->[...]") or absolute ("vlSyms->[...]").
//
// Using relative references allows V3Combine'ing
// code across multiple instances of the same module.
//
// Sets 'hierThisr' true if the object is local to this scope
// (and could be made into a function-local later in V3Localize),
// false if the object is in another scope.
string descopedName(bool& hierThisr, string& hierUnprot, const AstScope* scopep,
const AstVar* varp) {
// Using relative references allows V3Combine'ing code across multiple instances of the same
// module.
string descopedSelfPointer(const AstScope* scopep) {
UASSERT(scopep, "Var/Func not scoped");
hierThisr = (scopep == m_scopep);
// It's possible to disable relative references. This is a concession
// to older compilers (gcc < 4.5.x) that don't understand __restrict__
// well and emit extra ld/st to guard against pointer aliasing
// when this-> and vlTOPp-> are mixed in the same function.
//
// "vlTOPp" is declared "restrict" so better compilers understand
// that it won't alias with "this".
// when this-> and vlSyms-> are mixed in the same function.
bool relativeRefOk = v3Global.opt.relativeCFuncs();
//
// Static functions can't use this
if (!m_allowThis) relativeRefOk = false;
//
// Use absolute refs in top-scoped routines, keep them static.
// The DPI callback registration depends on representing top-level
// static routines as plain function pointers. That breaks if those
// become true OO routines.
//
// V3Combine wouldn't likely be able to combine top-level
// routines anyway, so there's no harm in keeping these static.
UASSERT_OBJ(m_modp, scopep, "Scope not under module");
if (m_modp->isTop()) relativeRefOk = false;
//
// Use absolute refs if this scope is the only instance of the module.
// Saves a bit of overhead on passing the 'this' pointer, and there's no
// need to be nice to V3Combine when we have only a single instance.
// The risk that this prevents combining identical logic from differently-
// named but identical modules seems low.
if (m_modSingleton) relativeRefOk = false;
//
// Class methods need relative
if (m_modp && VN_IS(m_modp, Class)) relativeRefOk = true;
if (varp && varp->isFuncLocal()) {
hierThisr = true;
return ""; // Relative to function, not in this
} else if (relativeRefOk && scopep == m_scopep) {
UINFO(8, " Descope ref under " << m_scopep << endl);
UINFO(8, " ref to " << scopep << endl);
UINFO(8, " aboveScope " << scopep->aboveScopep() << endl);
if (relativeRefOk && scopep == m_scopep) {
m_needThis = true;
return "this->";
return "this";
} else if (VN_IS(scopep->modp(), Class)) {
hierUnprot = v3Global.opt.modPrefix() + "_"; // Prefix before protected part
return scopep->modp()->name() + "::";
} else if (relativeRefOk && scopep->aboveScopep() && scopep->aboveScopep() == m_scopep) {
// Reference to scope of instance directly under this module, can just "cell->"
return "";
} else if (!m_modSingleton && relativeRefOk && scopep->aboveScopep() == m_scopep
&& VN_IS(scopep->modp(), Module)) {
// Reference to scope of instance directly under this module, can just "this->cell",
// which can potentially be V3Combined, but note this requires one extra pointer
// dereference which is slower, so we only use it if the source scope is not a
// singleton.
string name = scopep->name();
string::size_type pos;
if ((pos = name.rfind('.')) != string::npos) name.erase(0, pos + 1);
m_needThis = true;
return name + "->";
return "this->" + name;
} else {
// Reference to something elsewhere, or relative references
// are disabled. Use global variable
UINFO(8, " Descope " << scopep << endl);
UINFO(8, " to " << scopep->name() << endl);
UINFO(8, " under " << m_scopep->name() << endl);
if (!scopep->aboveScopep()) { // Top
// We could also return "vlSymsp->TOPp->" here, but GCC would
// suspect aliases.
return "vlTOPp->";
// Reference to something elsewhere, or relative references are disabled. Use global
// variable
if (scopep->isTop()) { // Top
return "vlSymsp->TOPp";
} else {
return scopep->nameVlSym() + ".";
return "(&" + scopep->nameVlSym() + ")";
}
}
}
// Construct the class prefix (as in, the part before the :: scope resolution operator) when
// referencing an object in 'scopep' from a CFunc in 'm_scopep'.
string descopedClassPrefix(const AstScope* scopep) {
UASSERT(scopep, "Var/Func not scoped");
if (VN_IS(scopep->modp(), Class) && scopep != m_scopep) {
return scopep->modp()->name();
} else {
return "";
}
}
void makePublicFuncWrappers() {
// We recorded all public functions in m_modFuncs.
// If for any given name only one function exists, we can use that function directly.
@ -164,11 +148,6 @@ private:
if (newfuncp->finalsp()) newfuncp->finalsp()->unlinkFrBackWithNext()->deleteTree();
newfuncp->name(name);
newfuncp->isStatic(false);
newfuncp->addInitsp(
new AstCStmt(newfuncp->fileline(),
EmitCBaseVisitor::symClassVar() + " = this->__VlSymsp;\n"));
newfuncp->addInitsp(
new AstCStmt(newfuncp->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
topFuncp->addNextHere(newfuncp);
// In the body, call each function if it matches the given scope
for (FuncMmap::iterator eachIt = it;
@ -255,13 +234,15 @@ private:
// Convert the hierch name
UINFO(9, " ref-in " << nodep << endl);
UASSERT_OBJ(m_scopep, nodep, "Node not under scope");
bool hierThis;
string hierUnprot;
nodep->hiernameToProt(descopedName(hierThis /*ref*/, hierUnprot /*ref*/,
nodep->varScopep()->scopep(),
nodep->varScopep()->varp()));
nodep->hiernameToUnprot(hierUnprot);
nodep->hierThis(hierThis);
const AstVar* const varp = nodep->varScopep()->varp();
const AstScope* const scopep = nodep->varScopep()->scopep();
if (varp->isFuncLocal()) {
nodep->hierThis(true);
} else {
nodep->hierThis(scopep == m_scopep);
nodep->selfPointer(descopedSelfPointer(scopep));
nodep->classPrefix(descopedClassPrefix(scopep));
}
nodep->varScopep(nullptr);
UINFO(9, " refout " << nodep << endl);
}
@ -270,12 +251,9 @@ private:
iterateChildren(nodep);
// Convert the hierch name
UASSERT_OBJ(m_scopep, nodep, "Node not under scope");
UASSERT_OBJ(nodep->funcp()->scopep(), nodep, "CFunc not under scope");
bool hierThis;
string hierUnprot;
nodep->hiernameToProt(
descopedName(hierThis /*ref*/, hierUnprot /*ref*/, nodep->funcp()->scopep(), nullptr));
nodep->hiernameToUnprot(hierUnprot);
const AstScope* const scopep = nodep->funcp()->scopep();
nodep->selfPointer(descopedSelfPointer(scopep));
nodep->classPrefix(descopedClassPrefix(scopep));
// Can't do this, as we may have more calls later
// nodep->funcp()->scopep(nullptr);
}

638
src/V3EmitC.cpp
View File

File diff suppressed because it is too large Load Diff

60
src/V3EmitCBase.h
View File

@ -43,6 +43,7 @@ public:
if (v3Global.opt.decoration()) puts(str);
}
void putsQuoted(const string& str) { ofp()->putsQuoted(str); }
void ensureNewLine() { ofp()->ensureNewLine(); }
bool optSystemC() { return v3Global.opt.systemC(); }
static string protect(const string& name) { return VIdProtect::protectIf(name, true); }
static string protectIf(const string& name, bool doIt) {
@ -54,22 +55,30 @@ public:
static string ifNoProtect(const string& in) { return v3Global.opt.protectIds() ? "" : in; }
static string symClassName() { return v3Global.opt.prefix() + "_" + protect("_Syms"); }
static string symClassVar() { return symClassName() + "* __restrict vlSymsp"; }
static string symTopAssign() {
return v3Global.opt.prefix() + "* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;";
static string symClassAssign() {
return symClassName() + "* const __restrict vlSymsp VL_ATTR_UNUSED = vlSelf->vlSymsp;\n";
}
static string funcNameProtect(const AstCFunc* nodep, const AstNodeModule* modp) {
static string funcNameProtect(const AstCFunc* nodep) {
AstNodeModule* modp = VN_CAST(nodep->user4p(), NodeModule);
string name;
if (nodep->isConstructor()) {
return prefixNameProtect(modp);
name += prefixNameProtect(modp);
} else if (nodep->isDestructor()) {
return string("~") + prefixNameProtect(modp);
name += "~";
name += prefixNameProtect(modp);
} else {
return nodep->nameProtect();
if (nodep->isLoose()) {
name += prefixNameProtect(modp);
name += "__";
}
name += nodep->nameProtect();
}
return name;
}
static string prefixNameProtect(const AstNode* nodep) { // C++ name with prefix
const AstNodeModule* modp = VN_CAST_CONST(nodep, NodeModule);
if (modp && modp->isTop()) {
return v3Global.opt.prefix();
return topClassName();
} else {
return v3Global.opt.modPrefix() + "_" + protect(nodep->name());
}
@ -86,7 +95,17 @@ public:
}
string cFuncArgs(const AstCFunc* nodep) {
// Return argument list for given C function
string args = nodep->argTypes();
string args;
if (nodep->isLoose() && nodep->isStatic().falseUnknown()) {
if (nodep->isConst().trueKnown()) args += "const ";
AstNodeModule* modp = VN_CAST(nodep->user4p(), NodeModule);
args += prefixNameProtect(modp);
args += "* vlSelf";
}
if (!nodep->argTypes().empty()) {
if (!args.empty()) args += ", ";
args += nodep->argTypes();
}
// Might be a user function with argument list.
for (const AstNode* stmtp = nodep->argsp(); stmtp; stmtp = stmtp->nextp()) {
if (const AstVar* portp = VN_CAST_CONST(stmtp, Var)) {
@ -105,6 +124,31 @@ public:
return args;
}
void emitCFuncHeader(const AstCFunc* funcp, const AstNodeModule* modp, bool withScope) {
if (!funcp->isConstructor() && !funcp->isDestructor()) {
puts(funcp->rtnTypeVoid());
puts(" ");
}
if (withScope && funcp->isProperMethod()) puts(prefixNameProtect(modp) + "::");
puts(funcNameProtect(funcp));
puts("(" + cFuncArgs(funcp) + ")");
if (funcp->isConst().trueKnown() && funcp->isProperMethod()) puts(" const");
}
void emitCFuncDecl(const AstCFunc* funcp, const AstNodeModule* modp) {
ensureNewLine();
if (!funcp->ifdef().empty()) puts("#ifdef " + funcp->ifdef() + "\n");
if (funcp->isStatic().trueUnknown() && funcp->isProperMethod()) puts("static ");
if (funcp->isVirtual()) {
UASSERT_OBJ(funcp->isProperMethod(), funcp, "Virtual function is not a proper method");
puts("virtual ");
}
emitCFuncHeader(funcp, modp, /* withScope: */ false);
if (funcp->slow()) puts(" VL_ATTR_COLD");
puts(";\n");
if (!funcp->ifdef().empty()) puts("#endif // " + funcp->ifdef() + "\n");
}
// CONSTRUCTORS
EmitCBaseVisitor() = default;
virtual ~EmitCBaseVisitor() override = default;

9
src/V3EmitV.cpp
View File

@ -624,9 +624,12 @@ class EmitVBaseVisitor VL_NOT_FINAL : public EmitCBaseVisitor {
if (nodep->varScopep()) {
putfs(nodep, nodep->varScopep()->prettyName());
} else {
putfs(nodep, nodep->hiernameToUnprot());
puts(nodep->hiernameToProt());
puts(nodep->varp()->prettyName());
if (nodep->selfPointer().empty()) {
putfs(nodep, nodep->varp()->prettyName());
} else {
putfs(nodep, nodep->selfPointer() + "->");
puts(nodep->varp()->prettyName());
}
}
}
virtual void visit(AstVarXRef* nodep) override {

9
src/V3File.cpp
View File

@ -966,7 +966,7 @@ public:
VIdProtectImp() {
passthru("this");
passthru("TOPp");
passthru("vlTOPp");
passthru("vlSelf");
passthru("vlSymsp");
}
~VIdProtectImp() = default;
@ -1016,8 +1016,7 @@ public:
}
}
string protectWordsIf(const string& old, bool doIt) {
// Split at " " (for traces), "." (for scopes), "->" (for scopes), "::" (for superclass
// reference)
// Split at " " (for traces), "." (for scopes), "->", "(", "&", ")" (for self pointers)
if (!(doIt && v3Global.opt.protectIds())) return old;
string out;
string::size_type start = 0;
@ -1029,7 +1028,9 @@ public:
trySep(old, start, " ", pos /*ref*/, separator /*ref*/);
trySep(old, start, ".", pos /*ref*/, separator /*ref*/);
trySep(old, start, "->", pos /*ref*/, separator /*ref*/);
trySep(old, start, "::", pos /*ref*/, separator /*ref*/);
trySep(old, start, "(", pos /*ref*/, separator /*ref*/);
trySep(old, start, "&", pos /*ref*/, separator /*ref*/);
trySep(old, start, ")", pos /*ref*/, separator /*ref*/);
if (pos == string::npos) break;
out += protectIf(old.substr(start, pos - start), true) + separator;
start = pos + separator.length();

3
src/V3File.h
View File

@ -165,6 +165,9 @@ public:
void blockDec() {
if (!m_parenVec.empty()) m_parenVec.pop();
}
void ensureNewLine() {
if (!m_nobreak) puts("\n");
}
// STATIC METHODS
static string indentSpaces(int num);
// Add escaped characters to strings

11
src/V3Hasher.cpp
View File

@ -199,7 +199,7 @@ private:
iterateNull(nodep->varScopep());
} else {
iterateNull(nodep->varp());
m_hash += nodep->hiernameToProt();
m_hash += nodep->selfPointer();
}
});
}
@ -229,6 +229,11 @@ private:
m_hash += nodep->text();
});
}
virtual void visit(AstAddrOfCFunc* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
iterateNull(nodep->funcp());
});
}
//------------------------------------------------------------
// AstNodeStmt
@ -364,7 +369,9 @@ private:
});
}
virtual void visit(AstCFunc* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {});
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() { //
m_hash += nodep->isLoose();
});
}
virtual void visit(AstVar* nodep) override {
m_hash += hashNodeAndIterate(nodep, HASH_DTYPE, HASH_CHILDREN, [=]() {

3
src/V3Localize.cpp
View File

@ -76,8 +76,7 @@ private:
// cppcheck-suppress unreadVariable // cppcheck 1.90 bug
VarFlags flags(nodep->varp());
if (flags.m_done) {
nodep->hiernameToProt(""); // Remove this->
nodep->hiernameToUnprot(""); // Remove this->
nodep->selfPointer(""); // Remove 'this'
nodep->hierThis(true);
}
}

5
src/V3Order.cpp
View File

@ -1754,14 +1754,13 @@ AstActive* OrderVisitor::processMoveOneLogic(const OrderLogicVertex* lvertexp,
if (!newFuncpr && domainp != m_deleteDomainp) {
const string name = cfuncName(modp, domainp, scopep, nodep);
newFuncpr = new AstCFunc(nodep->fileline(), name, scopep);
newFuncpr->argTypes(EmitCBaseVisitor::symClassVar());
newFuncpr->symProlog(true);
newFuncpr->isStatic(false);
newFuncpr->isLoose(true);
newStmtsr = 0;
if (domainp->hasInitial() || domainp->hasSettle()) newFuncpr->slow(true);
scopep->addActivep(newFuncpr);
// Create top call to it
AstCCall* const callp = new AstCCall(nodep->fileline(), newFuncpr);
callp->argTypes("vlSymsp");
// Where will we be adding the call?
AstActive* const newActivep = new AstActive(nodep->fileline(), name, domainp);
newActivep->addStmtsp(callp);

17
src/V3String.cpp
View File

@ -157,6 +157,23 @@ double VString::parseDouble(const string& str, bool* successp) {
return d;
}
static bool isWordChar(char c) { return isalnum(c) || c == '_'; }
string VString::replaceWord(const string& str, const string& from, const string& to) {
string result = str;
const size_t len = from.size();
UASSERT_STATIC(len > 0, "Cannot replace empty string");
for (size_t pos = 0; (pos = result.find(from, pos)) != string::npos; pos += len) {
// Only replace whole words
if (((pos > 0) && isWordChar(result[pos - 1])) || //
((pos + len < result.size()) && isWordChar(result[pos + len]))) {
continue;
}
result.replace(pos, len, to);
}
return result;
}
//######################################################################
// VHashSha256

4
src/V3String.h
View File

@ -100,6 +100,10 @@ public:
static bool isWhitespace(const string& str);
// Return double by parsing string
static double parseDouble(const string& str, bool* successp);
// Replace all occurrences of the word 'from' in 'str' with 'to'. A word is considered
// to be a consecutive sequence of the characters [a-zA-Z0-9_]. Sub-words are not replaced.
// e.g.: replaceWords("one apple bad_apple", "apple", "banana") -> "one banana bad_apple"
static string replaceWord(const string& str, const string& from, const string& to);
};
//######################################################################

32
src/V3Task.cpp
View File

@ -854,10 +854,8 @@ private:
{ // Call the user function
// Add the variables referenced as VarRef's so that lifetime analysis
// doesn't rip up the variables on us
string stmt;
stmt += "(*__Vcb)(";
args += ");\n";
AstCStmt* newp = new AstCStmt(nodep->fileline(), stmt);
AstCStmt* newp = new AstCStmt(nodep->fileline(), "(*__Vcb)(");
newp->addBodysp(argnodesp);
VL_DANGLING(argnodesp);
newp->addBodysp(new AstText(nodep->fileline(), args, true));
@ -1131,7 +1129,7 @@ private:
cfuncp->funcPublic(nodep->taskPublic());
cfuncp->dpiExport(nodep->dpiExport());
cfuncp->dpiImportWrapper(nodep->dpiImport());
cfuncp->isStatic(!(nodep->dpiImport() || nodep->taskPublic() || nodep->classMethod()));
cfuncp->isStatic(nodep->dpiExport());
cfuncp->isVirtual(nodep->isVirtual());
cfuncp->pure(nodep->pure());
if (nodep->name() == "new") {
@ -1145,21 +1143,12 @@ private:
// cfuncp->dpiImport // Not set in the wrapper - the called function has it set
if (cfuncp->dpiExport()) cfuncp->cname(nodep->cname());
bool needSyms = !nodep->dpiImport();
if (needSyms) {
if (nodep->taskPublic()) {
// We need to get a pointer to all of our variables (may
// have eval'ed something else earlier)
cfuncp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symClassVar()
+ " = this->__VlSymsp;\n"));
} else {
// Need symbol table
cfuncp->argTypes(EmitCBaseVisitor::symClassVar());
if (cfuncp->name() == "new") {
cfuncp->addInitsp(
new AstCStmt(nodep->fileline(),
VIdProtect::protect("_ctor_var_reset") + "(vlSymsp);\n"));
}
if (!nodep->dpiImport() && !nodep->taskPublic()) {
// Need symbol table
cfuncp->argTypes(EmitCBaseVisitor::symClassVar());
if (cfuncp->name() == "new") {
const string stmt = VIdProtect::protect("_ctor_var_reset") + "(vlSymsp);\n";
cfuncp->addInitsp(new AstCStmt(nodep->fileline(), stmt));
}
}
if (nodep->dpiContext()) {
@ -1169,11 +1158,6 @@ private:
createInputVar(cfuncp, "__Vlineno", AstBasicDTypeKwd::INT);
}
if (!nodep->dpiImport()) {
cfuncp->addInitsp(
new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign() + "\n"));
}
if (nodep->dpiExport()) {
AstScopeName* snp = nodep->scopeNamep();
UASSERT_OBJ(snp, nodep, "Missing scoping context");

51
src/V3Trace.cpp
View File

@ -485,33 +485,43 @@ private:
name += cvtToStr(funcNump++);
FileLine* const flp = m_topScopep->fileline();
AstCFunc* const funcp = new AstCFunc(flp, name, m_topScopep);
const string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* tracep");
funcp->argTypes(argTypes);
funcp->funcType(type);
funcp->dontCombine(true);
const bool isTopFunc
= type == AstCFuncType::TRACE_FULL || type == AstCFuncType::TRACE_CHANGE;
if (isTopFunc) {
funcp->argTypes("void* voidSelf, " + v3Global.opt.traceClassBase() + "* tracep");
funcp->isStatic(true);
funcp->addInitsp(new AstCStmt(
flp, prefixNameProtect(m_topModp) + "* const __restrict vlSelf = static_cast<"
+ prefixNameProtect(m_topModp) + "*>(voidSelf);\n"));
funcp->addInitsp(new AstCStmt(flp, symClassAssign()));
} else {
funcp->argTypes(v3Global.opt.traceClassBase() + "* tracep");
funcp->isStatic(false);
}
funcp->isLoose(true);
funcp->slow(type == AstCFuncType::TRACE_FULL || type == AstCFuncType::TRACE_FULL_SUB);
funcp->symProlog(true);
funcp->declPrivate(true);
// Add it to top scope
m_topScopep->addActivep(funcp);
// Add call to new function
if (callfromp) {
AstCCall* callp = new AstCCall(funcp->fileline(), funcp);
callp->argTypes("userp, tracep");
callp->argTypes("tracep");
callfromp->addStmtsp(callp);
}
// Register function
if (regp) {
string registration = "tracep->add";
if (type == AstCFuncType::TRACE_FULL) {
registration += "Full";
regp->addStmtsp(new AstText(flp, "tracep->addFullCb(", true));
} else if (type == AstCFuncType::TRACE_CHANGE) {
registration += "Chg";
regp->addStmtsp(new AstText(flp, "tracep->addChgCb(", true));
} else {
funcp->v3fatalSrc("Don't know how to register this type of function");
}
registration += "Cb(&" + protect(name) + ", __VlSymsp);\n";
AstCStmt* const stmtp = new AstCStmt(flp, registration);
regp->addStmtsp(stmtp);
regp->addStmtsp(new AstAddrOfCFunc(flp, funcp));
regp->addStmtsp(new AstText(flp, ", vlSelf);\n", true));
}
// Add global activity check to TRACE_CHANGE functions
if (type == AstCFuncType::TRACE_CHANGE) {
@ -666,17 +676,22 @@ private:
void createCleanupFunction(AstCFunc* regFuncp) {
FileLine* const fl = m_topScopep->fileline();
AstCFunc* const cleanupFuncp = new AstCFunc(fl, "traceCleanup", m_topScopep);
const string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* /*unused*/");
cleanupFuncp->argTypes(argTypes);
cleanupFuncp->argTypes("void* voidSelf, " + v3Global.opt.traceClassBase()
+ "* /*unused*/");
cleanupFuncp->funcType(AstCFuncType::TRACE_CLEANUP);
cleanupFuncp->slow(false);
cleanupFuncp->symProlog(true);
cleanupFuncp->declPrivate(true);
cleanupFuncp->isStatic(true);
cleanupFuncp->isLoose(true);
m_topScopep->addActivep(cleanupFuncp);
cleanupFuncp->addInitsp(new AstCStmt(
fl, prefixNameProtect(m_topModp) + "* const __restrict vlSelf = static_cast<"
+ prefixNameProtect(m_topModp) + "*>(voidSelf);\n"));
cleanupFuncp->addInitsp(new AstCStmt(fl, symClassAssign()));
// Register it
regFuncp->addStmtsp(new AstCStmt(
fl, string("tracep->addCleanupCb(&" + protect("traceCleanup") + ", __VlSymsp);\n")));
regFuncp->addStmtsp(new AstText(fl, "tracep->addCleanupCb(", true));
regFuncp->addStmtsp(new AstAddrOfCFunc(fl, cleanupFuncp));
regFuncp->addStmtsp(new AstText(fl, ", vlSelf);\n", true));
// Clear global activity flag
cleanupFuncp->addStmtsp(
@ -726,7 +741,7 @@ private:
regFuncp->funcType(AstCFuncType::TRACE_REGISTER);
regFuncp->slow(true);
regFuncp->isStatic(false);
regFuncp->declPrivate(true);
regFuncp->isLoose(true);
m_topScopep->addActivep(regFuncp);
const int parallelism = 1; // Note: will bump this later, code below works for any value

10
src/V3TraceDecl.cpp
View File

@ -72,13 +72,13 @@ private:
AstCFunc* newCFunc(AstCFuncType type, const string& name) {
FileLine* const flp = m_topScopep->fileline();
AstCFunc* const funcp = new AstCFunc(flp, name, m_topScopep);
string argTypes("void* userp, " + v3Global.opt.traceClassBase() + "* tracep");
string argTypes = v3Global.opt.traceClassBase() + "* tracep";
if (m_interface) argTypes += ", int scopet, const char* scopep";
funcp->argTypes(argTypes);
funcp->funcType(type);
funcp->symProlog(true);
funcp->isStatic(false);
funcp->isLoose(true);
funcp->slow(true);
funcp->declPrivate(true);
m_topScopep->addActivep(funcp);
UINFO(5, " Newfunc " << funcp << endl);
return funcp;
@ -86,10 +86,10 @@ private:
void callCFuncSub(AstCFunc* basep, AstCFunc* funcp, AstIntfRef* irp) {
AstCCall* callp = new AstCCall(funcp->fileline(), funcp);
if (irp) {
callp->argTypes("userp, tracep, VLT_TRACE_SCOPE_INTERFACE");
callp->argTypes("tracep, VLT_TRACE_SCOPE_INTERFACE");
callp->addArgsp(irp->unlinkFrBack());
} else {
callp->argTypes("userp, tracep");
callp->argTypes("tracep");
}
basep->addStmtsp(callp);
}

27
test_regress/t/t_c_this.pl Executable file
View File

@ -0,0 +1,27 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2021 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(vlt => 1);
compile();
if ($Self->{vlt_all}) {
# The word 'this' (but only the whole word 'this' should have been replaced
# in the contents.
my $file = "$Self->{obj_dir}/$Self->{VM_PREFIX}.cpp";
my $text = file_contents($file);
error("$file has 'this->clk'") if ($text =~ m/\bthis->clk\b/);
error("$file does not have 'xthis'") if ($text !~ m/\bxthis\b/);
error("$file does not have 'thisx'") if ($text !~ m/\bthisx\b/);
error("$file does not have 'xthisx'") if ($text !~ m/\bxthisx\b/);
}
ok(1);
1;

15
test_regress/t/t_c_this.v Normal file
View File

@ -0,0 +1,15 @@
// DESCRIPTION: Verilator: Verilog Test module
//
// This file ONLY is placed under the Creative Commons Public Domain, for
// any use, without warranty, 2021 by Wilson Snyder.
// SPDX-License-Identifier: CC0-1.0
module t (clk);
input clk;
always @(posedge clk) begin
$c("const CData xthis = this->clk;");
$c("const CData thisx = xthis;");
$c("const CData xthisx = thisx;");
$c("this->clk = xthisx;");
end
endmodule

33
test_regress/t/t_class_extends_this_protect_ids.pl Executable file
View File

@ -0,0 +1,33 @@
#!/usr/bin/env perl
if (!$::Driver) { use FindBin; exec("$FindBin::Bin/bootstrap.pl", @ARGV, $0); die; }
# DESCRIPTION: Verilator: Verilog Test driver/expect definition
#
# Copyright 2020 by Wilson Snyder. This program is free software; you
# can redistribute it and/or modify it under the terms of either the GNU
# Lesser General Public License Version 3 or the Perl Artistic License
# Version 2.0.
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
scenarios(vlt_all => 1);
# This test makes randomly named .cpp/.h files, which tend to collect, so remove them first
foreach my $filename (glob ("$Self->{obj_dir}/*_PS*.cpp"
." $Self->{obj_dir}/*_PS*.h"
." $Self->{obj_dir}/*.d" )) {
print "rm $filename\n" if $Self->{verbose};
unlink $filename;
}
top_filename("t/t_class_extends_this.v");
compile(
verilator_flags2 => ["--protect-ids",
"--protect-key SECRET_KEY"]
);
execute(
check_finished => 1,
);
ok(1);
1;

2
test_regress/t/t_cover_line.out
View File

@ -125,7 +125,7 @@
end
%000002 else if (cyc==5) begin
`ifdef VERILATOR
%000001 $c("call_task();");
%000001 $c("this->call_task();");
`else
call_task();
`endif

2
test_regress/t/t_cover_line.v
View File

@ -104,7 +104,7 @@ module t (/*AUTOARG*/
end
else if (cyc==5) begin
`ifdef VERILATOR
$c("call_task();");
$c("this->call_task();");
`else
call_task();
`endif

6
test_regress/t/t_debug_emitv.out
View File

@ -47,8 +47,6 @@ module Vt_debug_emitv;
end
???? // CFUNC '_final_TOP'
$_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
);
$display("stmt");
always @(posedge clk)@(negedge clk) begin
$display("posedge clk");
@ -238,14 +236,10 @@ class Vt_debug_emitv___024unit__03a__03aCls;
signed int [31:0] member;
???? // CFUNC '__VnoInFunc_method'
$_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
);
???? // CFUNC 'new'
$_CSTMT(_ctor_var_reset(vlSymsp);
);
$_CSTMT(Vt_debug_emitv* const __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;
);
$unit::Cls.member = 32'sh1;
endclass
/*class*/package Vt_debug_emitv___024unit__03a__03aCls__Vclpkg;

2
test_regress/t/t_dpi_var.v
View File

@ -88,7 +88,7 @@ module sub (/*AUTOARG*/
initial begin
// Test the naming
$c("mon_class_name(name());");
$c("mon_class_name(this->name());");
mon_scope_name("%m");
// Scheme A - pass pointer directly
$c("mon_register_a(\"in\",&",in,",false);");

2
test_regress/t/t_extend.v
View File

@ -34,7 +34,7 @@ module t (/*AUTOARG*/
`ifdef VERILATOR
$c("VL_PRINTF(\"Calling $c, calling $c...\\n\");");
$c("VL_PRINTF(\"Cyc=%d\\n\",",cyc,");");
c_worked <= $c("my_function()");
c_worked <= $c("this->my_function()");
c_wider <= $c9("0x10");
`else
c_worked <= 1'b1;

2
test_regress/t/t_extend_class.v
View File

@ -43,7 +43,7 @@ module t_extend_class_v (/*AUTOARG*/
always @* begin
// When "in" changes, call my method
out = $c("m_myobjp->my_math(",in,")");
out = $c("this->m_myobjp->my_math(",in,")");
end
`systemc_header

1
test_regress/t/t_flag_csplit.pl
View File

@ -96,6 +96,7 @@ sub check_cpp {
&& $func !~ /::trace$/
&& $func !~ /::traceInit$/
&& $func !~ /::traceFull$/
&& $func !~ /::final$/
) {
push @funcs, $func;
}

2
test_regress/t/t_flag_csplit_eval.pl
View File

@ -15,7 +15,7 @@ sub check_evals {
local $/; undef $/;
my $wholefile = <$fh>;
if ($wholefile =~ /::_eval[0-9]+/) {
if ($wholefile =~ /___eval[0-9]+/) {
++$got;
}
}

28
test_regress/t/t_func_public.v
View File

@ -16,7 +16,7 @@ module t (clk);
cyc <= cyc + 1;
if (cyc==1) begin
`ifdef verilator
$c("publicTop();");
$c("this->publicTop();");
`endif
end
if (cyc==20) begin
@ -84,32 +84,32 @@ module tpub (
//
`ifdef VERILATOR_PUBLIC_TASKS
if (cyc==11) begin
$c("publicNoArgs();");
$c("publicSetBool(true);");
$c("publicSetLong(0x11bca);");
$c("publicSetQuad(0x66655554444ULL);");
$c("publicSetFlop(0x321);");
$c("this->publicNoArgs();");
$c("this->publicSetBool(true);");
$c("this->publicSetLong(0x11bca);");
$c("this->publicSetQuad(0x66655554444ULL);");
$c("this->publicSetFlop(0x321);");
//Unsupported: $c("WData w[3] = {0x12, 0x5678_9123, 0x1245_2352}; publicSetWide(w);");
end
if (cyc==12) begin
$c("got_bool = publicGetSetBool(true);");
$c("got_long = publicGetSetLong(0x11bca);");
$c("got_quad = publicGetSetQuad(0xaaaabbbbccccULL);");
$c("this->got_bool = this->publicGetSetBool(true);");
$c("this->got_long = this->publicGetSetLong(0x11bca);");
$c("this->got_quad = this->publicGetSetQuad(0xaaaabbbbccccULL);");
end
if (cyc==13) begin
$c("{ bool gb; publicGetBool(gb); got_bool=gb; }");
$c("{ bool gb; this->publicGetBool(gb); this->got_bool=gb; }");
if (1'b1 != got_bool) $stop;
$c("publicGetLong(got_long);");
$c("this->publicGetLong(this->got_long);");
if (24'h11bca != got_long) $stop;
$c("{ vluint64_t qq; publicGetQuad(qq); got_quad=qq; }");
$c("{ vluint64_t qq; this->publicGetQuad(qq); this->got_quad=qq; }");
if (60'haaaa_bbbb_cccc != got_quad) $stop;
$c("{ WData gw[3]; publicGetWide(gw); VL_ASSIGN_W(72,got_wide,gw); }");
$c("{ WData gw[3]; this->publicGetWide(gw); VL_ASSIGN_W(72,this->got_wide,gw); }");
if (72'hac_abca_aaaa_bbbb_1234 != got_wide) $stop;
//Below doesn't work, because we're calling it inside the loop that sets var_flop
// if (12'h321 != var_flop) $stop;
end
if (cyc==14) begin
if ($c32("publicInstNum()") != i) $stop;
if ($c32("this->publicInstNum()") != i) $stop;
end
`endif
end

2
test_regress/t/t_func_rand.v
View File

@ -20,7 +20,7 @@ module t (clk, Rand);
input [7:0] idx;
begin
`ifdef verilator
QxRand32 = $c ("QxRandTbl(",tbl,",",idx,")");
QxRand32 = $c("this->QxRandTbl(",tbl,",",idx,")");
`else
QxRand32 = 32'hfeed0fad;
`endif

13
test_regress/t/t_inst_tree_inl0_pub1.pl
View File

@ -26,9 +26,7 @@ sub checkRelativeRefs {
my $file = "$Self->{obj_dir}/V$Self->{name}_${mod}.cpp";
my $text = file_contents($file);
# Remove "this->__VlSymsp" which is noise
$text =~ s/this->__VlSymsp//g;
if ($text =~ m/this->/) {
if ($text =~ m/this->/ || $text =~ m/vlSelf->/) {
$found_relative = 1;
}
@ -45,12 +43,9 @@ if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Combined CFuncs\s+(\d+)/i,
($Self->{vltmt} ? 84 : 52));
# Expect absolute refs in CFuncs for t (top module) and l1 (because it
# has only one instance)
checkRelativeRefs("t", 0);
checkRelativeRefs("l1", 0);
# Others should get relative references
# Everything should use relative references
checkRelativeRefs("t", 1);
checkRelativeRefs("l1", 1);
checkRelativeRefs("l2", 1);
checkRelativeRefs("l3", 1);
checkRelativeRefs("l4", 1);

11
test_regress/t/t_inst_tree_inl0_pub1_norelcfuncs.pl
View File

@ -24,13 +24,18 @@ if ($Self->{vlt_all}) {
file_grep($Self->{stats}, qr/Optimizations, Combined CFuncs\s+(\d+)/i,
($Self->{vltmt} ? 0 : 31));
# Should not find any 'this->' except some 'this->__VlSymsp'
# Should not find any 'this->' or 'vlSelf->' except some specific cases
my @files = `ls $Self->{obj_dir}/*.cpp`;
foreach my $file (@files) {
chomp $file;
my $text = file_contents($file);
$text =~ s/this->__VlSymsp//g;
if ($text =~ m/this->/) {
$text =~ s/(vlSelf|this)->vlSymsp//g;
$text =~ s/vlSelf->.* = VL_RAND_RESET.*;//g;
$text =~ s/vlSelf->__Vm_even_cycle//g;
$text =~ s/vlSelf->__Vm_even_cycle//g;
$text =~ s/vlSelf->__Vm_mt_(final|\d+)//g;
$text =~ s/vlSelf->__Vm_threadPoolp//g;
if ($text =~ m/this->/ || $text =~ m/vlSelf->/) {
error("$file has unexpected this-> refs when --norelative-cfuncs");
}
}

4
test_regress/t/t_param_public.v
View File

@ -27,7 +27,7 @@ module a;
parameter ONE /*verilator public*/ = 22;
initial if (ONE != 1) $stop;
`ifdef VERILATOR
initial if ($c32("ONE") != 1) $stop;
initial if ($c32("this->ONE") != 1) $stop;
`endif
endmodule
@ -36,7 +36,7 @@ module b #(
);
initial if (TWO != 2) $stop;
`ifdef VERILATOR
initial if ($c32("TWO") != 2) $stop;
initial if ($c32("this->TWO") != 2) $stop;
`endif
endmodule

3
test_regress/t/t_protect_ids_key.out
View File

@ -29,6 +29,7 @@
<map from="PSABAY" to="_eval_initial"/>
<map from="PSOLeN" to="_eval_initial_loop"/>
<map from="PSBUJ6" to="_eval_settle"/>
<map from="PSAsei" to="_final"/>
<map from="PSV5uq" to="_sequent__TOP__1"/>
<map from="PS8sdG" to="_sequent__TOP__t__DOT__secret_inst__1"/>
<map from="PScyq8" to="clk"/>
@ -38,6 +39,6 @@
<map from="PSBSVV" to="t/t_protect_ids.v"/>
<map from="PSB07q" to="t__DOT__secret_inst2__DOT__secret_cyc"/>
<map from="this" to="this"/>
<map from="vlSelf" to="vlSelf"/>
<map from="vlSymsp" to="vlSymsp"/>
<map from="vlTOPp" to="vlTOPp"/>
</verilator_id_map>

2
test_regress/t/t_unopt_converge_initial_run_bad.out
View File

@ -1,5 +1,5 @@
-V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
-V{t#,#}+ Vt_unopt_converge_initial_run_bad::_change_request
-V{t#,#}+ Vt_unopt_converge_initial_run_bad___change_request
-V{t#,#} CHANGE: t/t_unopt_converge_initial.v:19: x
%Error: t/t_unopt_converge_initial.v:7: Verilated model didn't DC converge
Aborting...

2
test_regress/t/t_unopt_converge_print_bad.out
View File

@ -1,5 +1,5 @@
-V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
-V{t#,#}+ Vt_unopt_converge_print_bad::_change_request
-V{t#,#}+ Vt_unopt_converge_print_bad___change_request
-V{t#,#} CHANGE: t/t_unopt_converge.v:19: x
%Error: t/t_unopt_converge.v:7: Verilated model didn't converge
Aborting...

2
test_regress/t/t_unopt_converge_run_bad.out
View File

@ -1,5 +1,5 @@
-V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
-V{t#,#}+ Vt_unopt_converge_run_bad::_change_request
-V{t#,#}+ Vt_unopt_converge_run_bad___change_request
-V{t#,#} CHANGE: t/t_unopt_converge.v:19: x
%Error: t/t_unopt_converge.v:7: Verilated model didn't converge
Aborting...

39
test_regress/t/t_verilated_debug.out
View File

@ -1,29 +1,30 @@
-V{t#,#}- Verilated::debug is on. Message prefix indicates {<thread>,<sequence_number>}.
-V{t#,#}+ Vt_verilated_debug::_ctor_var_reset
-V{t#,#}+ Vt_verilated_debug___ctor_var_reset
internalsDump:
Version: Verilator ###
Argv: obj_vlt/t_verilated_debug/Vt_verilated_debug
scopesDump:
-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval
-V{t#,#}+ Vt_verilated_debug::_eval_debug_assertions
-V{t#,#}+ Vt_verilated_debug::_eval_initial
-V{t#,#}+ Vt_verilated_debug::_initial__TOP__1
-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval_step
-V{t#,#}+ Vt_verilated_debug___eval_debug_assertions
-V{t#,#}+ Vt_verilated_debug___eval_initial
-V{t#,#}+ Vt_verilated_debug___initial__TOP__1
Data: w96: 000000aa 000000bb 000000cc
-V{t#,#}+ Vt_verilated_debug::_eval_settle
-V{t#,#}+ Vt_verilated_debug::_eval
-V{t#,#}+ Vt_verilated_debug::_change_request
-V{t#,#}+ Vt_verilated_debug::_change_request_1
-V{t#,#}+ Initial loop
-V{t#,#}+ Vt_verilated_debug___eval_settle
-V{t#,#}+ Vt_verilated_debug___eval
-V{t#,#}+ Vt_verilated_debug___change_request
-V{t#,#}+ Vt_verilated_debug___change_request_1
-V{t#,#}+ Clock loop
-V{t#,#}+ Vt_verilated_debug::_eval
-V{t#,#}+ Vt_verilated_debug::_change_request
-V{t#,#}+ Vt_verilated_debug::_change_request_1
-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval
-V{t#,#}+ Vt_verilated_debug::_eval_debug_assertions
-V{t#,#}+ Vt_verilated_debug___eval
-V{t#,#}+ Vt_verilated_debug___change_request
-V{t#,#}+ Vt_verilated_debug___change_request_1
-V{t#,#}+++++TOP Evaluate Vt_verilated_debug::eval_step
-V{t#,#}+ Vt_verilated_debug___eval_debug_assertions
-V{t#,#}+ Clock loop
-V{t#,#}+ Vt_verilated_debug::_eval
-V{t#,#}+ Vt_verilated_debug::_sequent__TOP__2
-V{t#,#}+ Vt_verilated_debug___eval
-V{t#,#}+ Vt_verilated_debug___sequent__TOP__2
*-* All Finished *-*
-V{t#,#}+ Vt_verilated_debug::_change_request
-V{t#,#}+ Vt_verilated_debug::_change_request_1
-V{t#,#}+ Vt_verilated_debug::final
-V{t#,#}+ Vt_verilated_debug___change_request
-V{t#,#}+ Vt_verilated_debug___change_request_1
-V{t#,#}+ Vt_verilated_debug___final