forked from github/verilator
401 lines
17 KiB
C++
401 lines
17 KiB
C++
// -*- mode: C++; c-file-style: "cc-mode" -*-
|
|
//*************************************************************************
|
|
// DESCRIPTION: Verilator: Waves tracing
|
|
//
|
|
// Code available from: https://verilator.org
|
|
//
|
|
//*************************************************************************
|
|
//
|
|
// Copyright 2003-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.
|
|
//
|
|
// Verilator is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
//*************************************************************************
|
|
// V3TraceDecl's Transformations:
|
|
// Create trace CFUNCs
|
|
// For each VARSCOPE
|
|
// If appropriate type of signal, create a TRACE
|
|
//
|
|
//*************************************************************************
|
|
|
|
#include "config_build.h"
|
|
#include "verilatedos.h"
|
|
|
|
#include "V3Global.h"
|
|
#include "V3TraceDecl.h"
|
|
#include "V3EmitCBase.h"
|
|
#include "V3Stats.h"
|
|
|
|
#include <cstdarg>
|
|
|
|
//######################################################################
|
|
// TraceDecl state, as a visitor of each AstNode
|
|
|
|
class TraceDeclVisitor : public EmitCBaseVisitor {
|
|
private:
|
|
// NODE STATE
|
|
|
|
// STATE
|
|
AstScope* m_scopetopp; // Current top scope
|
|
AstCFunc* m_initFuncp; // Trace function being built
|
|
AstCFunc* m_initSubFuncp; // Trace function being built (under m_init)
|
|
int m_initSubStmts; // Number of statements in function
|
|
AstCFunc* m_fullFuncp; // Trace function being built
|
|
AstCFunc* m_chgFuncp; // Trace function being built
|
|
int m_funcNum; // Function number being built
|
|
AstVarScope* m_traVscp; // Signal being trace constructed
|
|
AstNode* m_traValuep; // Signal being traced's value to trace in it
|
|
string m_traShowname; // Signal being traced's component name
|
|
bool m_interface; // Currently tracing an interface
|
|
|
|
VDouble0 m_statSigs; // Statistic tracking
|
|
VDouble0 m_statIgnSigs; // Statistic tracking
|
|
|
|
// METHODS
|
|
VL_DEBUG_FUNC; // Declare debug()
|
|
|
|
const char* vscIgnoreTrace(AstVarScope* nodep) {
|
|
// Return true if this shouldn't be traced
|
|
// See also similar rule in V3Coverage::varIgnoreToggle
|
|
AstVar* varp = nodep->varp();
|
|
if (!varp->isTrace()) {
|
|
return "Verilator trace_off";
|
|
}
|
|
else if (!nodep->isTrace()) {
|
|
return "Verilator cell trace_off";
|
|
}
|
|
else if (!v3Global.opt.traceUnderscore()) {
|
|
string prettyName = varp->prettyName();
|
|
if (!prettyName.empty() && prettyName[0] == '_')
|
|
return "Leading underscore";
|
|
if (prettyName.find("._") != string::npos)
|
|
return "Inlined leading underscore";
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AstCFunc* newCFunc(AstCFuncType type, const string& name, bool slow) {
|
|
AstCFunc* funcp = new AstCFunc(m_scopetopp->fileline(), name, m_scopetopp);
|
|
funcp->slow(slow);
|
|
string argTypes(EmitCBaseVisitor::symClassVar()+", "+v3Global.opt.traceClassBase()
|
|
+"* vcdp, uint32_t code");
|
|
if (m_interface) argTypes += ", const char* scopep";
|
|
funcp->argTypes(argTypes);
|
|
funcp->funcType(type);
|
|
funcp->symProlog(true);
|
|
m_scopetopp->addActivep(funcp);
|
|
UINFO(5," Newfunc "<<funcp<<endl);
|
|
return funcp;
|
|
}
|
|
void callCFuncSub(AstCFunc* basep, AstCFunc* funcp, AstIntfRef* irp) {
|
|
AstCCall* callp = new AstCCall(funcp->fileline(), funcp);
|
|
callp->argTypes("vlSymsp, vcdp, code");
|
|
if (irp) callp->addArgsp(irp->unlinkFrBack());
|
|
basep->addStmtsp(callp);
|
|
}
|
|
AstCFunc* newCFuncSub(AstCFunc* basep) {
|
|
string name = basep->name()+"__"+cvtToStr(++m_funcNum);
|
|
AstCFunc* funcp = NULL;
|
|
if (basep->funcType()==AstCFuncType::TRACE_INIT
|
|
|| basep->funcType()==AstCFuncType::TRACE_INIT_SUB) {
|
|
funcp = newCFunc(AstCFuncType::TRACE_INIT_SUB, name, basep->slow());
|
|
} else {
|
|
basep->v3fatalSrc("Strange base function type");
|
|
}
|
|
if (!m_interface) callCFuncSub(basep, funcp, NULL);
|
|
return funcp;
|
|
}
|
|
void addTraceDecl(const VNumRange& arrayRange,
|
|
int widthOverride) { // If !=0, is packed struct/array where basicp size misreflects one element
|
|
VNumRange bitRange;
|
|
AstBasicDType* bdtypep = m_traValuep->dtypep()->basicp();
|
|
if (widthOverride) bitRange = VNumRange(widthOverride-1, 0, false);
|
|
else if (bdtypep) bitRange = bdtypep->nrange();
|
|
AstTraceDecl* declp = new AstTraceDecl(m_traVscp->fileline(), m_traShowname,
|
|
m_traVscp->varp(), m_traValuep,
|
|
bitRange, arrayRange, m_interface);
|
|
UINFO(9,"Decl "<<declp<<endl);
|
|
|
|
if (!m_interface && v3Global.opt.outputSplitCTrace()
|
|
&& m_initSubStmts > v3Global.opt.outputSplitCTrace()) {
|
|
m_initSubFuncp = newCFuncSub(m_initFuncp);
|
|
m_initSubStmts = 0;
|
|
}
|
|
|
|
m_initSubFuncp->addStmtsp(declp);
|
|
m_initSubStmts += EmitCBaseCounterVisitor(declp).count();
|
|
|
|
m_chgFuncp->addStmtsp(new AstTraceInc(m_traVscp->fileline(),
|
|
declp, m_traValuep->cloneTree(true)));
|
|
// The full version will get constructed in V3Trace
|
|
}
|
|
void addIgnore(const char* why) {
|
|
++m_statIgnSigs;
|
|
m_initSubFuncp->addStmtsp(
|
|
new AstComment(m_traVscp->fileline(),
|
|
"Tracing: "+m_traShowname+" // Ignored: "+why, true));
|
|
}
|
|
|
|
// VISITORS
|
|
virtual void visit(AstTopScope* nodep) VL_OVERRIDE {
|
|
m_scopetopp = nodep->scopep();
|
|
// Make containers for TRACEDECLs first
|
|
m_initFuncp = newCFunc(AstCFuncType::TRACE_INIT, "traceInitThis", true);
|
|
m_fullFuncp = newCFunc(AstCFuncType::TRACE_FULL, "traceFullThis", true);
|
|
m_chgFuncp = newCFunc(AstCFuncType::TRACE_CHANGE, "traceChgThis", false);
|
|
//
|
|
m_initSubFuncp = newCFuncSub(m_initFuncp);
|
|
// And find variables
|
|
iterateChildren(nodep);
|
|
}
|
|
virtual void visit(AstScope* nodep) VL_OVERRIDE {
|
|
AstCell* cellp = VN_CAST(nodep->aboveCellp(), Cell);
|
|
if (cellp && VN_IS(cellp->modp(), Iface)) {
|
|
AstCFunc* origSubFunc = m_initSubFuncp;
|
|
int origSubStmts = m_initSubStmts;
|
|
{
|
|
m_interface = true;
|
|
m_initSubFuncp = newCFuncSub(origSubFunc);
|
|
string scopeName = nodep->prettyName();
|
|
size_t lastDot = scopeName.find_last_of('.');
|
|
UASSERT_OBJ(lastDot != string::npos, nodep,
|
|
"Expected an interface scope name to have at least one dot");
|
|
scopeName = scopeName.substr(0, lastDot+1);
|
|
size_t scopeLen = scopeName.length();
|
|
|
|
AstIntfRef* nextIrp = cellp->intfRefp();
|
|
// While instead of for loop because interface references will
|
|
// be unlinked as we go
|
|
while (nextIrp) {
|
|
AstIntfRef* irp = nextIrp;
|
|
nextIrp = VN_CAST(irp->nextp(), IntfRef);
|
|
|
|
string irpName = irp->prettyName();
|
|
if (scopeLen > irpName.length()) continue;
|
|
string intfScopeName = irpName.substr(0, scopeLen);
|
|
if (scopeName != intfScopeName) continue;
|
|
callCFuncSub(origSubFunc, m_initSubFuncp, irp);
|
|
++origSubStmts;
|
|
}
|
|
iterateChildren(nodep);
|
|
}
|
|
m_initSubFuncp = origSubFunc;
|
|
m_initSubStmts = origSubStmts;
|
|
m_interface = false;
|
|
} else {
|
|
iterateChildren(nodep);
|
|
}
|
|
}
|
|
virtual void visit(AstVarScope* nodep) VL_OVERRIDE {
|
|
iterateChildren(nodep);
|
|
// Prefilter - things that get through this if will either get
|
|
// traced or get a comment as to why not traced.
|
|
// Generally this equation doesn't need updating, instead use
|
|
// varp->isTrace() and/or vscIgnoreTrace.
|
|
if ((!nodep->varp()->isTemp() || nodep->varp()->isTrace())
|
|
&& !nodep->varp()->isFuncLocal()) {
|
|
UINFO(5, " vsc "<<nodep<<endl);
|
|
AstVar* varp = nodep->varp();
|
|
AstScope* scopep = nodep->scopep();
|
|
// Compute show name
|
|
// This code assumes SPTRACEVCDC_VERSION >= 1330;
|
|
// it uses spaces to separate hierarchy components.
|
|
if (m_interface) {
|
|
m_traShowname = AstNode::vcdName(varp->name());
|
|
} else {
|
|
m_traShowname = AstNode::vcdName(scopep->name() + " " + varp->name());
|
|
if (m_traShowname.substr(0, 4) == "TOP ") m_traShowname.replace(0, 4, "");
|
|
}
|
|
UASSERT_OBJ(m_initSubFuncp, nodep, "NULL");
|
|
|
|
m_traVscp = nodep;
|
|
m_traValuep = NULL;
|
|
if (vscIgnoreTrace(nodep)) {
|
|
addIgnore(vscIgnoreTrace(nodep));
|
|
} else {
|
|
++m_statSigs;
|
|
if (nodep->valuep()) m_traValuep = nodep->valuep()->cloneTree(true);
|
|
else m_traValuep = new AstVarRef(nodep->fileline(), nodep, false);
|
|
{
|
|
// Recurse into data type of the signal; the visitors will call addTraceDecl()
|
|
iterate(varp->dtypep()->skipRefToEnump());
|
|
}
|
|
// Cleanup
|
|
if (m_traValuep) VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = NULL);
|
|
}
|
|
m_traVscp = NULL;
|
|
m_traValuep = NULL;
|
|
m_traShowname = "";
|
|
}
|
|
}
|
|
// VISITORS - Data types when tracing
|
|
virtual void visit(AstConstDType* nodep) VL_OVERRIDE {
|
|
if (m_traVscp) {
|
|
iterate(nodep->subDTypep()->skipRefToEnump());
|
|
}
|
|
}
|
|
virtual void visit(AstRefDType* nodep) VL_OVERRIDE {
|
|
if (m_traVscp) {
|
|
iterate(nodep->subDTypep()->skipRefToEnump());
|
|
}
|
|
}
|
|
virtual void visit(AstUnpackArrayDType* nodep) VL_OVERRIDE {
|
|
// Note more specific dtypes above
|
|
if (m_traVscp) {
|
|
if (static_cast<int>(nodep->arrayUnpackedElements()) > v3Global.opt.traceMaxArray()) {
|
|
addIgnore("Wide memory > --trace-max-array ents");
|
|
} else if (VN_IS(nodep->subDTypep()->skipRefToEnump(), BasicDType) // Nothing lower than this array
|
|
&& m_traVscp->dtypep()->skipRefToEnump() == nodep) { // Nothing above this array
|
|
// Simple 1-D array, use existing V3EmitC runtime loop rather than unrolling
|
|
// This will put "(index)" at end of signal name for us
|
|
if (m_traVscp->dtypep()->skipRefToEnump()->isString()) {
|
|
addIgnore("Unsupported: strings");
|
|
} else {
|
|
addTraceDecl(nodep->declRange(), 0);
|
|
}
|
|
} else {
|
|
// Unroll now, as have no other method to get right signal names
|
|
AstNodeDType* subtypep = nodep->subDTypep()->skipRefToEnump();
|
|
for (int i=nodep->lsb(); i<=nodep->msb(); ++i) {
|
|
string oldShowname = m_traShowname;
|
|
AstNode* oldValuep = m_traValuep;
|
|
{
|
|
m_traShowname += string("(")+cvtToStr(i)+string(")");
|
|
m_traValuep = new AstArraySel(nodep->fileline(),
|
|
m_traValuep->cloneTree(true),
|
|
i - nodep->lsb());
|
|
|
|
m_traValuep->dtypep(subtypep);
|
|
iterate(subtypep);
|
|
VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = NULL);
|
|
}
|
|
m_traShowname = oldShowname;
|
|
m_traValuep = oldValuep;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
virtual void visit(AstPackArrayDType* nodep) VL_OVERRIDE {
|
|
if (m_traVscp) {
|
|
if (!v3Global.opt.traceStructs()) {
|
|
// Everything downstream is packed, so deal with as one trace unit.
|
|
// This may not be the nicest for user presentation, but is
|
|
// a much faster way to trace
|
|
addTraceDecl(VNumRange(), nodep->width());
|
|
} else {
|
|
AstNodeDType* subtypep = nodep->subDTypep()->skipRefToEnump();
|
|
for (int i=nodep->lsb(); i<=nodep->msb(); ++i) {
|
|
string oldShowname = m_traShowname;
|
|
AstNode* oldValuep = m_traValuep;
|
|
{
|
|
m_traShowname += string("(")+cvtToStr(i)+string(")");
|
|
m_traValuep = new AstSel(nodep->fileline(), m_traValuep->cloneTree(true),
|
|
(i - nodep->lsb())*subtypep->width(),
|
|
subtypep->width());
|
|
m_traValuep->dtypep(subtypep);
|
|
iterate(subtypep);
|
|
VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = NULL);
|
|
}
|
|
m_traShowname = oldShowname;
|
|
m_traValuep = oldValuep;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
virtual void visit(AstNodeUOrStructDType* nodep) VL_OVERRIDE {
|
|
if (m_traVscp) {
|
|
if (nodep->packed() && !v3Global.opt.traceStructs()) {
|
|
// Everything downstream is packed, so deal with as one trace unit
|
|
// This may not be the nicest for user presentation, but is
|
|
// a much faster way to trace
|
|
addTraceDecl(VNumRange(), nodep->width());
|
|
} else {
|
|
if (!nodep->packed()) {
|
|
addIgnore("Unsupported: Unpacked struct/union");
|
|
} else {
|
|
for (AstMemberDType* itemp = nodep->membersp();
|
|
itemp; itemp=VN_CAST(itemp->nextp(), MemberDType)) {
|
|
AstNodeDType* subtypep = itemp->subDTypep()->skipRefToEnump();
|
|
string oldShowname = m_traShowname;
|
|
AstNode* oldValuep = m_traValuep;
|
|
{
|
|
m_traShowname += string(" ")+itemp->prettyName();
|
|
if (VN_IS(nodep, StructDType)) {
|
|
m_traValuep = new AstSel(nodep->fileline(),
|
|
m_traValuep->cloneTree(true),
|
|
itemp->lsb(), subtypep->width());
|
|
m_traValuep->dtypep(subtypep);
|
|
iterate(subtypep);
|
|
VL_DO_CLEAR(m_traValuep->deleteTree(), m_traValuep = NULL);
|
|
} else { // Else union, replicate fields
|
|
iterate(subtypep);
|
|
}
|
|
}
|
|
m_traShowname = oldShowname;
|
|
m_traValuep = oldValuep;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
virtual void visit(AstBasicDType* nodep) VL_OVERRIDE {
|
|
if (m_traVscp) {
|
|
if (nodep->isString()) {
|
|
addIgnore("Unsupported: strings");
|
|
} else {
|
|
addTraceDecl(VNumRange(), 0);
|
|
}
|
|
}
|
|
}
|
|
virtual void visit(AstEnumDType* nodep) VL_OVERRIDE {
|
|
iterate(nodep->skipRefp());
|
|
}
|
|
virtual void visit(AstNodeDType* nodep) VL_OVERRIDE {
|
|
// Note more specific dtypes above
|
|
if (!m_traVscp) return;
|
|
addIgnore("Unsupported: data type");
|
|
}
|
|
|
|
//--------------------
|
|
virtual void visit(AstNode* nodep) VL_OVERRIDE {
|
|
iterateChildren(nodep);
|
|
}
|
|
|
|
public:
|
|
// CONSTRUCTORS
|
|
explicit TraceDeclVisitor(AstNetlist* nodep) {
|
|
m_scopetopp = NULL;
|
|
m_initFuncp = NULL;
|
|
m_initSubFuncp = NULL;
|
|
m_initSubStmts = 0;
|
|
m_fullFuncp = NULL;
|
|
m_chgFuncp = NULL;
|
|
m_funcNum = 0;
|
|
m_traVscp = NULL;
|
|
m_traValuep = NULL;
|
|
m_interface = false;
|
|
iterate(nodep);
|
|
}
|
|
virtual ~TraceDeclVisitor() {
|
|
V3Stats::addStat("Tracing, Traced signals", m_statSigs);
|
|
V3Stats::addStat("Tracing, Ignored signals", m_statIgnSigs);
|
|
}
|
|
};
|
|
|
|
//######################################################################
|
|
// Trace class functions
|
|
|
|
void V3TraceDecl::traceDeclAll(AstNetlist* nodep) {
|
|
UINFO(2,__FUNCTION__<<": "<<endl);
|
|
{
|
|
TraceDeclVisitor visitor (nodep);
|
|
} // Destruct before checking
|
|
V3Global::dumpCheckGlobalTree("tracedecl", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
|
|
}
|