Support tracing/coverage of underscore signals, bug280.

Changes

@@ -5,6 +5,8 @@ indicates the contributor was also the author of the fix; Thanks!
 
 * Verilator 3.8****
 
+***  Support tracing/coverage of underscore signals, bug280.  [by Jason McMullan]
+
 **** Increase define recursions before error.  [Paul Liu]
 
 * Verilator 3.803 2010/07/10

bin/verilator

@@ -207,6 +207,7 @@ descriptions in the next sections for more information.
     --coverage-line             Enable line coverage
     --coverage-toggle           Enable toggle coverage
     --coverage-user             Enable PSL/SVL user coverage
+    --coverage-underscore       Enable covarge of _signals
      -D<var>[=<value>]          Set preprocessor define
     --debug                     Enable debugging
     --debug-check               Enable debugging assertions
@@ -256,6 +257,7 @@ descriptions in the next sections for more information.
     --top-module <topname>      Name of top level input module
     --trace                     Enable waveform creation
     --trace-depth <levels>      Depth of tracing
+    --trace-underscore          Enable tracing of _signals
      -U<var>                    Undefine preprocessor define
     --unroll-count <loops>      Tune maximum loop iterations
     --unroll-stmts <stmts>      Tune maximum loop body size
@@ -426,6 +428,11 @@ counting such behavior.
 A /*verilator coverage_off/on */ comment pair can be used around signals
 that do not need toggle analysis, such as RAMs and register files.
 
+=item --coverage-underscore
+
+Enable coverage of signals that start with an underscore. Normally, these
+signals are not covered.  See also --trace-underscore.
+
 =item --coverage-user
 
 Enables user inserted functional coverage.  Currently, all functional
@@ -750,6 +757,11 @@ Specify the number of levels deep to enable tracing, for example
 entire model.  Using a small number will decrease visibility, but greatly
 improve runtime and trace file size.
 
+=item --trace-underscore
+
+Enable tracing of signals that start with an underscore. Normally, these
+signals are not output during tracing.  See also --coverage-underscore.
+
 =item -UI<var>
 
 Undefines the given preprocessor symbol.

src/V3Coverage.cpp

@@ -81,10 +81,12 @@ private:
 	string prettyName = nodep->prettyName();
 	if (!nodep->isToggleCoverable())
 	    return "Not relevant signal type";
-	if (prettyName.c_str()[0] == '_')
+	if (!v3Global.opt.coverageUnderscore()) {
-	    return "Leading underscore";
+	    if (prettyName.c_str()[0] == '_')
-	if (prettyName.find("._") != string::npos)
+	        return "Leading underscore";
-	    return "Inlined leading underscore";
+	    if (prettyName.find("._") != string::npos)
+	        return "Inlined leading underscore";
+	}
 	if ((nodep->width()*nodep->arrayElements()) > 256) return "Wide bus/array > 256 bits";
 	// We allow this, though tracing doesn't
 	// if (nodep->arrayp(1)) return "Unsupported: Multi-dimensional array";

src/V3Options.cpp

@@ -611,6 +611,7 @@ void V3Options::parseOptsList(FileLine* fl, int argc, char** argv) {
 	    else if ( onoff   (sw, "-coverage", flag/*ref*/) )	{ coverage(flag); }
 	    else if ( onoff   (sw, "-coverage-line", flag/*ref*/) ){ m_coverageLine = flag; }
 	    else if ( onoff   (sw, "-coverage-toggle", flag/*ref*/) ){ m_coverageToggle = flag; }
+	    else if ( onoff   (sw, "-coverage-underscore", flag/*ref*/) ){ m_coverageUnderscore = flag; }
 	    else if ( onoff   (sw, "-coverage-user", flag/*ref*/) ){ m_coverageUser = flag; }
 	    else if ( onoff   (sw, "-covsp", flag/*ref*/) )	{ }  // TBD
 	    else if ( onoff   (sw, "-debug-check", flag/*ref*/) ){ m_debugCheck = flag; }
@@ -634,6 +635,7 @@ void V3Options::parseOptsList(FileLine* fl, int argc, char** argv) {
 	    else if ( !strcmp (sw, "-sv") )				{ m_language = V3LangCode::L1800_2005; }
 	    else if ( onoff   (sw, "-trace", flag/*ref*/) )		{ m_trace = flag; }
 	    else if ( onoff   (sw, "-trace-dups", flag/*ref*/) )	{ m_traceDups = flag; }
+	    else if ( onoff   (sw, "-trace-underscore", flag/*ref*/) )	{ m_traceUnderscore = flag; }
 	    else if ( onoff   (sw, "-underline-zero", flag/*ref*/) )	{ m_underlineZero = flag; }  // Undocumented, old Verilator-2
 	    // Optimization
 	    else if ( !strncmp (sw, "-O", 2) ) {
@@ -993,6 +995,7 @@ V3Options::V3Options() {
     m_autoflush = false;
     m_coverageLine = false;
     m_coverageToggle = false;
+    m_coverageUnderscore = false;
     m_coverageUser = false;
     m_debugCheck = false;
     m_dumpTree = false;
@@ -1014,6 +1017,7 @@ V3Options::V3Options() {
     m_systemPerl = false;
     m_trace = false;
     m_traceDups = false;
+    m_traceUnderscore = false;
     m_underlineZero = false;
 
     m_errorLimit = 50;

src/V3Options.h

@@ -103,6 +103,7 @@ class V3Options {
     bool	m_cdc;		// main switch: --cdc
     bool	m_coverageLine;	// main switch: --coverage-block
     bool	m_coverageToggle;// main switch: --coverage-toggle
+    bool	m_coverageUnderscore;// main switch: --coverage-underscore
     bool	m_coverageUser;	// main switch: --coverage-func
     bool	m_debugCheck;	// main switch: --debug-check
     bool	m_dumpTree;	// main switch: --dump-tree
@@ -122,6 +123,7 @@ class V3Options {
     bool	m_stats;	// main switch: --stats
     bool	m_trace;	// main switch: --trace
     bool	m_traceDups;	// main switch: --trace-dups
+    bool	m_traceUnderscore;// main switch: --trace-underscore
     bool	m_underlineZero;// main switch: --underline-zero; undocumented old Verilator 2
 
     int		m_errorLimit;	// main switch: --error-limit
@@ -222,12 +224,14 @@ class V3Options {
     bool coverage() const { return m_coverageLine || m_coverageToggle || m_coverageUser; }
     bool coverageLine() const { return m_coverageLine; }
     bool coverageToggle() const { return m_coverageToggle; }
+    bool coverageUnderscore() const { return m_coverageUnderscore; }
     bool coverageUser() const { return m_coverageUser; }
     bool debugCheck() const { return m_debugCheck; }
     bool dumpTree() const { return m_dumpTree; }
     bool exe() const { return m_exe; }
     bool trace() const { return m_trace; }
     bool traceDups() const { return m_traceDups; }
+    bool traceUnderscore() const { return m_traceUnderscore; }
     bool outFormatOk() const { return m_outFormatOk; }
     bool keepTempFiles() const { return (V3Error::debugDefault()!=0); }
     bool pinsUint8() const { return m_pinsUint8; }

src/V3TraceDecl.cpp

@@ -69,10 +69,12 @@ private:
 	string prettyName = nodep->prettyName();
 	if (!nodep->isTrace())
 	    return "Verilator trace_off";
-	if (prettyName.c_str()[0] == '_')
+	if (!v3Global.opt.traceUnderscore()) {
-	    return "Leading underscore";
+	    if (prettyName.c_str()[0] == '_')
-	if (prettyName.find("._") != string::npos)
+	        return "Leading underscore";
-	    return "Inlined leading underscore";
+	    if (prettyName.find("._") != string::npos)
+	        return "Inlined leading underscore";
+        }
 	if (nodep->width() > 256) return "Wide bus > 256 bits";
 	if (nodep->arrayElements() > 32) return "Wide memory > 32 ents";
 	if (!(nodep->dtypeSkipRefp()->castBasicDType()