Version bump

Signed-off-by: Wilson Snyder <[email protected]>

COPYING.LESSER

@@ -1,4 +1,4 @@
-		   GNU LESSER GENERAL PUBLIC LICENSE
+                   GNU LESSER GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>

Changes

@@ -2,6 +2,59 @@ Revision history for Verilator
 
 The contributors that suggested a given feature are shown in []. Thanks!
 
+* Verilator 4.002 2018-09-16
+
+**    This is a major release.  Any patches may require major rework to apply.
+      [Thanks everyone]
+
+**    Add multithreaded model generation.
+
+**    Add runtime arguments.
+
+**    Add GTKWave LXT2 native tracing, bug1333. [Yu Sheng Lin]
+
+**    Note $random has new algorithm; results may vary vs. previous versions.
+
+***   Better optimize large always block splitting, bug1244. [John Coiner]
+
+***   Add new reloop optimization for repetitive assignment compression.
+
+***   Support string.atoi and similar methods, bug1289. [Joel Holdsworth]
+
+****  Fix internals to be C++ null-pointer-check clean.
+
+****  Fix internals to avoid 'using namespace std'.
+
+****  Fix Verilation performance issues, bug1316. [John Coiner]
+
+****  Fix clocker attributes to not propagate on concats. [John Coiner]
+
+****  Fix first clock edge and --x-initial-edge, bug1327. [Rupert Swarbrick]
+
+****  Fix compile error on tracing of string arrays, bug1338. [Iztok Jeras]
+
+****  Fix number parsing with newline after radix, bug1340. [George Cuan]
+
+****  Fix string ?: conditional type resolution, bug1345. [Iztok Jeras]
+
+****  Fix duplicate symbol error on generate tri, bug1347. [Tomas Dzetkulic]
+
+
+* Verilator 3.926 2018-08-22
+
+****  Add OBJCACHE envvar support to examples and generated Makefiles.
+
+****  Change MODDUP errors to warnings, msg2588. [Marshal Qiao]
+
+****  Fix define argument stringification (`"), broke since 3.914. [Joe DErrico]
+
+****  Fix to ignore Unicode UTF-8 BOM sequences, msg2576. [HyungKi Jeong]
+
+****  Fix std:: build error, bug1322.
+
+****  Fix function inlining inside certain while loops, bug1330. [Julien Margetts]
+
+
 * Verilator 3.924 2018-06-12
 
 ***   Renamed --profile-cfuncs to --prof-cfuncs.

MANIFEST.SKIP

@@ -31,8 +31,8 @@ include/verilated.mk$
 test_regress/.gdbinit$
 config.cache$
 config.status$
-verilator.log
-verilator.tex
+verilator\.log
+verilator\.tex
 verilator.pc$
 verilator_bin.*
 verilator_coverage_bin.*

Makefile.in

@@ -56,6 +56,7 @@ INSTALL_DATA = @INSTALL_DATA@
 MAKEINFO = makeinfo
 POD2TEXT = pod2text
 POD2LATEXFIX = $(srcdir)/src/pod2latexfix
+MKINSTALLDIRS = $(SHELL) $(srcdir)/src/mkinstalldirs
 PERL = @PERL@
 
 # Destination prefix for RPMs
@@ -120,18 +121,20 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	bin/verilator \
 	bin/verilator_coverage \
 	bin/verilator_difftree \
+	bin/verilator_gantt \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
-	doxygen-mainpage doxygen.config veripool-logo.png \
-	install-sh configure mkinstalldirs *.pod \
+	doxygen-mainpage doxygen.config verilator_logo.png \
+	install-sh configure *.pod \
 	include/*.[chv]* \
 	include/*.in \
 	include/.*ignore \
+	include/lxt2/*.[chv]* \
 	include/vltstd/*.[chv]* \
 	.*attributes */.*attributes  */*/.*attributes \
 	src/.*ignore src/*.in src/*.cpp src/*.[chly] \
 	src/astgen src/bisonpre src/*fix src/cppcheck_filtered \
-	src/vlcovgen \
+	src/vlcovgen src/mkinstalldirs \
 	src/.gdbinit \
 	src/*.pl src/*.pod \
 	examples/*/.*ignore examples/*/Makefile* \
@@ -154,10 +157,12 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 INST_PROJ_FILES = \
 	bin/verilator \
 	bin/verilator_coverage \
+	bin/verilator_gantt \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
 	include/verilated.mk \
 	include/*.[chv]* \
+	include/lxt2/*.[chv]* \
 	include/vltstd/*.[chv]* \
 
 INST_PROJ_BIN_FILES = \
@@ -183,8 +188,8 @@ all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 .PHONY:verilator_coverage_bin_dbg
 verilator_exe verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg:
 	@echo ------------------------------------------------------------
-	@echo "making verilator in src" ; \
-	  (cd src && $(MAKE) $(OBJCACHE_JOBS) )
+	@echo "making verilator in src"
+	$(MAKE) -C src $(OBJCACHE_JOBS)
 
 .PHONY:msg_test
 msg_test: all_nomsg
@@ -210,7 +215,7 @@ smoke-test: all_nomsg
 	test_regress/t/t_a_first_sc.pl
 
 test_regress: all_nomsg
-	@(cd test_regress && $(MAKE))
+	$(MAKE) -C test_regress
 
 examples: all_nomsg
 	for p in examples/* ; do \
@@ -230,8 +235,8 @@ verilator.html: ${srcdir}/bin/verilator
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-verilator.pdf: ${srcdir}/bin/verilator Makefile
-	pod2latex --full --out verilator.tex ${srcdir}/bin/verilator
+verilator.pdf: ${srcdir}/bin/verilator Makefile $(POD2LATEXFIX)
+	pod2latex --full --out verilator.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE)" "${DISTDATE}" < verilator.tex > verilator2.tex
 	mv verilator2.tex verilator.tex
 	pdflatex verilator.tex
@@ -246,8 +251,8 @@ README.html: README.pod
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-README.pdf: README.pod Makefile
-	pod2latex --full --out README.tex README.pod
+README.pdf: README.pod Makefile $(POD2LATEXFIX)
+	pod2latex --full --out README.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) README File" "${DISTDATE}" < README.tex > README2.tex
 	mv README2.tex README.tex
 	pdflatex README.tex
@@ -262,8 +267,8 @@ internals.html: internals.pod
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-internals.pdf: internals.pod Makefile
-	pod2latex --full --out internals.tex internals.pod
+internals.pdf: internals.pod Makefile $(POD2LATEXFIX)
+	pod2latex --full --out internals.tex $<
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) Internals Manual" "${DISTDATE}" < internals.tex > internals2.tex
 	mv internals2.tex internals.tex
 	pdflatex internals.tex
@@ -272,12 +277,12 @@ internals.pdf: internals.pod Makefile
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
 VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg \
-	verilator_coverage verilator_includer verilator_profcfunc
+	verilator_coverage verilator_gantt verilator_includer verilator_profcfunc
 # Some scripts go into both the search path and pkgdatadir,
 # so they can be found by the user, and under $VERILATOR_ROOT.
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
-VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_profcfunc.1
+VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_gantt.1 verilator_profcfunc.1
 
 VL_INST_INC_BLDDIR_FILES = \
 	include/verilated_config.h \
@@ -286,33 +291,35 @@ VL_INST_INC_BLDDIR_FILES = \
 # Files under srcdir, instead of build time
 VL_INST_INC_SRCDIR_FILES = \
 	include/*.[chv]* \
+	include/lxt2/*.[chv]* \
 	include/vltstd/*.[chv]* \
 
 VL_INST_DATA_SRCDIR_FILES = \
 	examples/*/*.[chv]*  examples/*/Makefile* \
 
 installbin:
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir)
+	$(MKINSTALLDIRS) $(DESTDIR)$(bindir)
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage $(DESTDIR)$(bindir)/verilator_coverage )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_gantt $(DESTDIR)$(bindir)/verilator_gantt )
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
-	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg )
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/bin
+	( cd bin ; $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg )
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
 
 # Man files can either be part of the original kit, or built in current directory
-# So important we use $< so VPATH is searched
+# So important we use $^ so VPATH is searched
 installman: $(VL_INST_MAN_FILES)
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
-	cd $(srcdir) \
-	; for p in $(VL_INST_MAN_FILES) ; do \
+	$(MKINSTALLDIRS) $(DESTDIR)$(mandir)/man1
+	for p in $^ ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
 installdata:
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/include/vltstd
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/lxt2
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/include/vltstd
 	for p in $(VL_INST_INC_BLDDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
@@ -320,15 +327,15 @@ installdata:
 	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/tracing_c
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgconfigdir)
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgconfigdir)
 	$(INSTALL_DATA) verilator.pc $(DESTDIR)$(pkgconfigdir)
 
 # We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
@@ -341,6 +348,7 @@ uninstall:
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_DATA_SRCDIR_FILES)
 	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
 	-rmdir $(DESTDIR)$(pkgdatadir)/bin
+	-rmdir $(DESTDIR)$(pkgdatadir)/include/lxt2
 	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
 	-rmdir $(DESTDIR)$(pkgdatadir)/include
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
@@ -392,7 +400,7 @@ install-cadtools: dist
 	strip bin/verilator_bin*
 	strip bin/verilator_coverage_bin*
 	$(MAKE) install-cadtools-quick
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/man/man1
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/man/man1
 	for p in $(VL_INST_MAN_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(VERILATOR_CAD_DIR)/man/man1/$$p; \
 	done
@@ -405,8 +413,9 @@ ifeq ($(CFG_WITH_DEFENV),yes)
 	false
 endif
 	@echo "Install-cadtools-quick (no strip) to $(VERILATOR_CAD_DIR)"
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/include/vltstd
-	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/bin
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/lxt2
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/include/vltstd
+	$(MKINSTALLDIRS) $(VERILATOR_CAD_DIR)/bin
 	for p in $(INST_PROJ_FILES) ; do \
 	  $(INST_PROJ_CVS) $$p $(VERILATOR_CAD_DIR)/$$p; \
 	done
@@ -477,7 +486,7 @@ maintainer-clean::
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
 	  echo making $@ in $$dir ; \
-	  (cd $$dir && $(MAKE) $@) ; \
+	  $(MAKE) -C $$dir $@ ; \
 	done
 
 clean mostlyclean distclean maintainer-clean::

README.pod

@@ -78,7 +78,14 @@ instead.)
 
 =item
 
-You will need the C<flex> and C<bison> packages installed.
+To use Verilator you will need the C<perl>, C<make> (or C<gmake>), and
+C<g++> (or C<clang>) packages.
+
+To use Verilator LTX2 tracing you will need the C<gtkwave> and C<libgz> (on
+Ubuntu C<zlibc> C<zlib1g> C<zlib1g-dev>) packages installed.
+
+To compile Verilator in addition to the above you need the C<flex>,
+C<bison> and C<texi2html> packages installed.
 
 =item
 

TODO

@@ -5,119 +5,115 @@
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
 
+* Language support:
+** Fix ordering of each bit separately in a signal (mips)
+   assign b[3:0] = b[7:4];  assign b[7:4] = in;
+** Support UDP gate primitives/ cell libraries
+   (have code for combos - problem is sequential udps)
+** Function to eval combo logic after /*verilator public*/ functions [gwaters]
+** Support generated clocks (correctness)
+** Recursive functions
+** Verilog configuration files
+** Expression coverage (see notes)
+** Better tristate support
+** UVM
 
-Language support:
-	* Fix ordering of each bit separately in a signal (mips)
-		assign b[3:0] = b[7:4];  assign b[7:4] = in;
-	* Support UDP gate primitives/ cell libraries
-		(have code for combos - problem is sequential udps)
-	* Function to eval combo logic after /*verilator public*/ functions [gwaters]
-	* Support generated clocks (correctness)
-	* Real numbers
-	* Recursive functions
-	* Verilog configuration files
-	* Structs/unions (have starting point)
-	* DPI to define C/C++ calls from Verilog
-	* Expression coverage (see notes)
-	* Better tristate support
+* Long-term Features
+** Assertions
+** Tristate support
 
-Long-term Features
-	* Assertions
-	* Tristate support
-	* Multithreaded execution
+* Configure/Make/Install
+** Distribute with flex/bison already expanded?
+   Flex library not needed.  Probably too difficult to be worth it.
 
-Configure/Make/Install
-	* Distribute with flex/bison already expanded?
-	  Flex library not needed.  Probably too difficult to be worth it.
+* Testing:
+** Capture all inputs into global "rerun it" file
+** Code to make wrapper that sets signals, so can do comparison checks
+** New random program generator
+** Better graph viewer with search and zoom
+** Port and test against opencores.org code
+** // verilator debug in code so can see only tree affecting those nodes
 
-Testing:
-	* Capture all inputs into global "rerun it" file
-	* Code to make wrapper that sets signals, so can do comparison checks
-	* New random program generator
-	* Better graph viewer with search and zoom
-	* Port and test against opencores.org code
-	* // verilator debug in code so can see only tree affecting those nodes
+* Usability:
+** Detect and pre-remove most UNOPTFLATs
+** Better reporting of unopt problems, including what lines of code
+** Report more errors (all of them?) before exiting [Eugene Weber]
+** Auto-create scons config files
+** Print version/etc message at runtime. (4.000?)
+   Include number of lines of code, percent comments, code complexity measurement
+   <-80chars------------------------------------------------------------------->
+   Verilator 3.600 - The fast free open-sourced simulator.  Copyright 2001-2013.
+   Verilated #### modules, #### instances, ##### sigs,
+         #### non-comment lines, ##### ops, ### KB model size
 
-Usability:
-	* Detect and pre-remove most UNOPTFLATs (4.000)
-	* Better reporting of unopt problems, including what lines of code
-	* Report more errors (all of them?) before exiting [Eugene Weber]
-	* Auto-create scons config files
-	* Print version/etc message at runtime. (4.000?)
-	  Include number of lines of code, percent comments, code complexity measurement
-	  <-80chars------------------------------------------------------------------->
-	  Verilator 3.600 - The fast free open-sourced simulator.  Copyright 2001-2013.
-	  Verilated #### modules, #### instances, ##### sigs,
-	  	    #### non-comment lines, ##### ops, ### KB model size
+* Lint:
+** CDCRSTLOGIC should allow filtering with paths
+   "waive CDCRSTLOGIC --from a.b.sig  --to a.c.sig --via OR"
 
-Lint:
-	* CDCRSTLOGIC should allow filtering with paths
-	  "waive CDCRSTLOGIC --from a.b.sig  --to a.c.sig --via OR"
+* Internal Code:
+** A Visitor class that understands how to traverse data types
+** V3Graph should be templated container type, taking in Vertex + Edge types
+** Instead of string, have an VEncodedString/VIdString which contains __DOT__ish
+   things, to reduce bugs.  Also add _20 trailing space to \ encoded names.
 
-Internal Code:
-	* A Visitor class that understands how to traverse data types
-	* V3Graph should be templated container type, taking in Vertex + Edge types
-	* Instead of string, have an VEncodedString/VIdString which contains __DOT__ish
-	  things, to reduce bugs.  Also add _20 trailing space to \ encoded names. (4.000)
+* Runtime:
+** New evalulation loop   ~/src/verilator/notes/event_loop.txt (4.000?)
+** Remove all private internal functions from top level wrapper header, move
+   to new level
+** Completely standalone simulation
+    main() records arguments for $test$plusvars
+    instantiates top,
+    does tracing  (support $dump?)
+    calls top->simulateForever()
+    exits
 
-Runtime:
-	* New evalulation loop   ~/src/verilator/notes/event_loop.txt (4.000?)
-	* Remove all private internal functions from top level wrapper header, move
-	  to new level (4.000?)
-	* Completely standalone simulation (4.000)
-	   main() records arguments for $test$plusvars
-	   instantiates top,
-	   does tracing  (support $dump?)
-	   calls top->simulateForever()
-	   exits
-
-Performance:
-	* Latch optimizations
-	* Constant propagation
-		Extra cleaning AND:  1 & ((VARREF >> 1) | ((&VARREF >> 1) & VARREF))
-		Extra shift (perhaps due to clean): if (1 & CAST (VARREF >> #))
-	* Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
-		Could propagate the AND into pos/negedges and let domaining optimize.
-	* Negedge reset
-		Switch to remove negedges that don't matter
-		Can't remove async resets from control flops (like in syncronizers)
-	* If all references to array have a constant index, blow up into separate signals-per-index
-	* Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
-	* Move _last sets and all other combo logic inside master
-		if() that triggers on all possible sense items
-	* Rewrite and combine V3Life, V3Subst
-		If block temp only ever set in one place to constant, propagate it
-			Used in t_mem for array delayed assignments
-		Replace variables if set later in same cfunc branch
-			See for example duplicate sets of _narrow in cycle 90/91 of t_select_plusloop
-	* Same assignment on both if branches
-		"if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
-		Careful though, as b could appear in the statement or multiple times in statement
-		(Could just require exatly two 'b's in statement)
-	* Simplify XOR/XNOR/AND/OR bit selection trees
-		Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
-	* Combine variables into wider elements
-		Parallel statements on different bits should become single signal
-		Variables that are always consumed in "parallel" can be joined
-	* Duplicate assignments in gate optimization
-		Common to have many separate posedge blocks, each with identical
-		reset_r <= rst_in
-	* If signal is used only once (not counting trace), always gate substitute
-		Don't merge if any combining would form circ logic (out goes back to in)
-	* Multiple assignments each bit can become single assign with concat
-		Make sure a SEL of a CONCAT can get the single bit back.
-	* Usually blocks/values
-		Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
-	* Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
-	* I-cache packing improvements (what/how?)
-	* Data cache organization (order of vars in class)
-		First have clocks,
-		then bools instead of uint32_t's
-		then based on what sense list they come from, all outputs, then all inputs
-		finally have any signals part of a "usually" block, or constant.
-	* Rather then tracking widths, have a MSB...LSB of this expression
-		(or better, a bitmask of bits relevant in this expression)
-	* Track recirculation and convert into clock-enables
-	* Clock enables should become new clocking domains for speed
-	* If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
-	* Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)
+* Performance:
+** Latch optimizations
+** Constant propagation
+   Extra cleaning AND:  1 & ((VARREF >> 1) | ((&VARREF >> 1) & VARREF))
+   Extra shift (perhaps due to clean): if (1 & CAST (VARREF >> #))
+** Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
+   Could propagate the AND into pos/negedges and let domaining optimize.
+** Negedge reset
+   Switch to remove negedges that don't matter
+   Can't remove async resets from control flops (like in syncronizers)
+** If all references to array have a constant index, blow up into separate signals-per-index
+** Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
+** Move _last sets and all other combo logic inside master
+   if() that triggers on all possible sense items
+** Rewrite and combine V3Life, V3Subst
+   If block temp only ever set in one place to constant, propagate it
+     Used in t_mem for array delayed assignments
+   Replace variables if set later in same cfunc branch
+     See for example duplicate sets of _narrow in cycle 90/91 of t_select_plusloop
+** Same assignment on both if branches
+   "if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
+   Careful though, as b could appear in the statement or multiple times in statement
+   (Could just require exatly two 'b's in statement)
+** Simplify XOR/XNOR/AND/OR bit selection trees
+   Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
+** Combine variables into wider elements
+   Parallel statements on different bits should become single signal
+   Variables that are always consumed in "parallel" can be joined
+** Duplicate assignments in gate optimization
+   Common to have many separate posedge blocks, each with identical
+   reset_r <= rst_in
+** If signal is used only once (not counting trace), always gate substitute
+   Don't merge if any combining would form circ logic (out goes back to in)
+** Multiple assignments each bit can become single assign with concat
+   Make sure a SEL of a CONCAT can get the single bit back.
+** Usually blocks/values
+   Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
+** Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
+** I-cache packing improvements (what/how?)
+** Data cache organization (order of vars in class)
+   First have clocks,
+   then bools instead of uint32_t's
+   then based on what sense list they come from, all outputs, then all inputs
+   finally have any signals part of a "usually" block, or constant.
+** Rather then tracking widths, have a MSB...LSB of this expression
+   (or better, a bitmask of bits relevant in this expression)
+** Track recirculation and convert into clock-enables
+** Clock enables should become new clocking domains for speed
+** If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
+** Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)

bin/verilator

@@ -338,6 +338,7 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
     --pipe-filter <command>     Filter all input through a script
     --prefix <topname>          Name of top level class
     --prof-cfuncs               Name functions for profiling
+    --prof-threads              Enable generating gantt chart data for threads
     --private                   Debugging; see docs
     --public                    Debugging; see docs
      -pvalue+<name>=<value>     Overwrite toplevel parameter
@@ -350,8 +351,12 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
     --stats-vars                Provide statistics on variables
      -sv                        Enable SystemVerilog parsing
      +systemverilogext+<ext>    Synonym for +1800-2017ext+<ext>
+    --threads <threads>         Enable multithreading
+    --threads-dpi <mode>        Enable multithreaded DPI
+    --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
     --top-module <topname>      Name of top level input module
     --trace                     Enable waveform creation
+    --trace-lxt2                Enable LXT2 waveform creation
     --trace-depth <levels>      Depth of tracing
     --trace-max-array <depth>   Maximum bit width for tracing
     --trace-max-width <width>   Maximum array depth for tracing
@@ -380,6 +385,19 @@ detailed descriptions in L</"VERILATION ARGUMENTS"> for more information.
     --x-initial-edge            Enable initial X->0 and X->1 edge triggers
      -y <dir>                   Directory to search for modules
 
+This is a short summary of the arguments to run-time Verilated arguments.
+detailed descriptions in L</"RUNTIME ARGUMENTS"> for more information.
+
+     +verilator+debug                  Enable debugging
+     +verilator+debugi+<value>         Enable debugging at a level
+     +verilator+help                   Display help
+     +verilator+prof+threads+file+I<filename>  Set profile filename
+     +verilator+prof+threads+start+I<value>    Set profile starting point
+     +verilator+prof+threads+window+I<value>   Set profile duration
+     +verilator+rand+reset+<value>     Set random reset technique
+     +verilator+V                      Verbose version and config
+     +verilator+version                Show version and exit
+
 
 =head1 VERILATION ARGUMENTS
 
@@ -1070,6 +1088,18 @@ Verilog module and line number the statement came from.  This allows gprof
 or oprofile reports to be correlated with the original Verilog source
 statements. See also L<verilator_profcfunc>.
 
+=item --prof-threads
+
+Enable gantt chart data collection for threaded builds.
+
+Verilator will record the start and end time of each macro-task across a
+number of calls to eval. (What is a macro-task? See the Verilator internals
+document.)
+
+When profiling is enabled, the runtime will emit a blurb of profiling data
+in non-human-friendly form. The C<verilator_gantt> script will transform
+this into a nicer visual format and produce some related statistics.
+
 =item --private
 
 Opposite of --public.  Is the default; this option exists for backwards
@@ -1124,7 +1154,10 @@ Enable including save and restore functions in the generated model.
 
 The user code must create a VerilatedSerialize or VerilatedDeserialze
 object then calling the << or >> operators on the generated model and any
-other data the process needs saved/restored.  For example:
+other data the process needs saved/restored.  These functions are not
+thread safe, and are typically called only by a main thread.
+
+For example:
 
     void save_model(const char* filenamep) {
         VerilatedSave os;
@@ -1163,6 +1196,42 @@ compatibility with other simulators.
 
 A synonym for C<+1800-2017ext+>I<ext>.
 
+=item --threads I<threads>
+
+=item --no-threads
+
+With --threads 0 or --no-threads, the default, the generated model is not
+thread safe. With --threads 1, the generated model is single threaded but
+may run in a multithreaded environment. With --threads N, where N >= 2, the
+model is generated to run multithreaded on up to N threads. See
+L</"MULTITHREADING">.
+
+=item --threads-dpi all
+
+=item --threads-dpi none
+
+=item --threads-dpi pure
+
+When using --dpi with --threads, control what DPI tasks are thread safe.
+
+With --threads-dpi all, enable Verilator to assume all DPI imports are
+threadsafe, and to use thread-local storage for communication with DPI,
+potentially improving performance. Any DPI libraries need appropriate
+mutexes to avoid undefined behavior.
+
+With --threads-dpi none, Verilator assume DPI imports are not thread safe,
+and Verilator will serialize calls to DPI imports by default, potentially
+harming performance.
+
+With --threads-dpi pure, the default, Verilator assumes DPI pure imports
+are threadsafe, but non-pure DPI imports are not.
+
+=item --threads-max-mtasks I<value>
+
+Rarely needed.  When using --threads, specify the number of mtasks the
+model is to be partitioned into. If unspecified, Verilator approximates a
+good value.
+
 =item --top-module I<topname>
 
 When the input Verilog contains more than one top level module, specifies
@@ -1172,17 +1241,23 @@ designs with only one top.
 
 =item --trace
 
-Adds waveform tracing code to the model.  Verilator will generate
-additional {prefix}__Trace*.cpp files that will need to be compiled.  In
-addition verilated_vcd_sc.cpp (for SystemC traces) or verilated_vcd_c.cpp
-(for both) must be compiled and linked in.  If using the Verilator
-generated Makefiles, these files will be added as source targets for you.
-If you're not using the Verilator makefiles, you will need to add these to
-your Makefile manually.
+Adds waveform tracing code to the model using VCD format. This overrides
+C<--trace-lxt2>.
+
+Verilator will generate additional {prefix}__Trace*.cpp files that will
+need to be compiled.  In addition verilated_vcd_sc.cpp (for SystemC traces)
+or verilated_vcd_c.cpp (for both) must be compiled and linked in.  If using
+the Verilator generated Makefiles, these files will be added as source
+targets for you.  If you're not using the Verilator makefiles, you will
+need to add these to your Makefile manually.
 
 Having tracing compiled in may result in some small performance losses,
 even when waveforms are not turned on during model execution.
 
+=item --trace-lxt2
+
+Enable LXT2 waveform tracing in the model. This overrides C<--trace>.
+
 =item --trace-depth I<levels>
 
 Specify the number of levels deep to enable tracing, for example
@@ -1432,6 +1507,67 @@ are desired for error messages instead of relative filenames.
 =back
 
 
+=head1 RUNTIME ARGUMENTS
+
+The following are the arguments that may be passed to a Verilated
+executable, provided that executable calls Verilated::commandArgs().
+
+All runtime arguments begin with +verilator, so that the user's executable
+may skip over all +verilator arguments when parsing its command line.
+
+=over 4
+
+=item +verilator+debug
+
+Enable debugging.  Equivalent to +verilator+debugi+4.
+
+=item +verilator+debugi+I<value>
+
+Enable debugging at the provided level.
+
+=item +verilator+help
+
+Display help and exit.
+
+=item +verilator+prof+threads+file+I<filename>
+
+When using --prof-threads, the filename to dump to.  Defaults to
+"profile_threads.dat".
+
+=item +verilator+prof+threads+start+I<value>
+
+When using --prof-threads, Verilator will wait until $time is at this
+value, then start the profiling warmup, then capturing. Generally this
+should be set to some time that is well within the normal operation of the
+simulation, i.e. outside of reset. If 0, the dump is disabled. Defaults to
+1.
+
+=item +verilator+prof+threads+window+I<value>
+
+When using --prof-threads, after $time reaches
++verilator+prof+threads+start, Verilator will warm up the profiling for
+this number of eval() calls, then will capture the profiling of this number
+of eval() calls.  Defaults to 2, which makes sense for a
+single-clock-domain module where it's typical to want to capture one
+posedge eval() and one negedge eval().
+
+=item +verilator+rand+reset+I<value>
+
+When a model was Verilated using "-x-inital unique", sets the
+initialization technique.  0 = Reset to zeros. 1 = Reset to all-ones.  2 =
+Randomize.  See L</"Unknown states">.
+
+=item +verilator+V
+
+Shows the verbose version, including configuration information.
+
+=item +verilator+version
+
+Displays program version and exits.
+
+=back
+
+
 =head1 EXAMPLE C++ EXECUTION
 
 We'll compile this example into C++.
@@ -1586,6 +1722,9 @@ compile times, and --x-assign=fast --x-initial=fast may increase the risk
 of reset bugs in trade for performance; see the above documentation for
 these flags.
 
+If using Verilated multithreaded, use C<numactl> to ensure you are using
+non-conflicting hardware resources. See L</"MULTITHREADING">.
+
 Minor Verilog code changes can also give big wins.  You should not have any
 UNOPTFLAT warnings from Verilator.  Fixing these warnings can result in
 huge improvements; one user fixed their one UNOPTFLAT warning by making a
@@ -1707,8 +1846,8 @@ needed at runtime.
 
 Optionally specifies a caching or distribution program to place in front of
 all runs of the C++ Compiler.  For example, "objcache --read --write", or
-"ccache".  If using distcc, it would generally be run under either objcache
-or ccache; see the documentation for those programs.
+"ccache".  If using distcc or icecc/icecream, they would generally be run
+under either objcache or ccache; see the documentation for those programs.
 
 =item SYSTEMC
 
@@ -2127,6 +2266,91 @@ the names of the .cpp files to compile in from the make variables generated
 in obj_dir/Vour_classes.mk.
 
 
+=head1 MULTITHREADING
+
+Verilator experimentally supports multithreading.
+
+With --no-threads, the default, the model is not thread safe, and any use
+of more than one thread calling into one or even different Verilated models
+may result in unpredictable behavior. This gives the highest single thread
+performance.
+
+With --threads 1, the generated model is single threaded, however the
+support libraries are multithread safe. This allows different
+instantiations of model(s) to potentially each be run under a different
+thread.  All threading is the responsibility of the user's C++ testbench.
+
+With --threads N, where N is at least 2, the generated model will be
+designed to run in parallel on N threads. The thread calling eval()
+provides one of those threads, and the generated model will create and
+manage the other N-1 threads. It's the client's responsibility not to
+oversubscribe the available CPU cores. Under CPU oversubscription, the
+Verilated model should not livelock nor deadlock, however, you can expect
+performance to be far worse than it would be with proper stoichiometry of
+threads and CPU cores.
+
+The remainder of this section describe behavior with --threads 1 or
+--threads N (not --no-threads).
+
+VL_THREADED is defined when compiling a threaded Verilated module, causing
+the Verilated support classes become threadsafe.
+
+The thread used for constructing a model must the the same thread that
+calls eval() into the model, this is called the "eval thread". The thread
+used to perform certain global operations such as saving and tracing must
+be done by a "main thread". In most cases the eval thread and main thread
+are the same thread (i.e. the user's top C++ testbench runs on a single
+thread), but this is not required.
+
+When running a multithreaded model, the default Linux task scheduler often
+works against the model, by assuming threads are short lived, and thus
+often schedules threads using multiple hyperthreads within the same
+physical core. For best performance use the C<numactl> program to (when the
+threading count fits) select unique physical cores on the same socket. For
+example, if a model was Verilated with "--threads 4", we consult
+
+   egrep 'processor|physical id|core id' /proc/cpuinfo
+
+To select cores 0, 1, 2, and 3 that are all located on the same socket (0)
+but different physical cores.  (Also useful is "numactl --hardware", or
+C<lscpu> but those doesn't show Hyperthreading cores.) Then we execute
+
+   numactl -m 0 -C 0,1,2,3 -- verilated_executable_name
+
+This will limit memory to socket 0, and threads to cores 0, 1, 2, 3,
+(presumably on socket 0) optimizing performance.  Of course this must be
+adjusted if you want another simulator using e.g. socket 1, or if you
+Verilated with a different number of threads.  To see what CPUs are
+actually used, use --prof-threads.
+
+=head2 Multithreaded Verilog and Library Support
+
+$display/$stop/$finish are delayed until the end of an eval() call in order
+to maintain ordering between threads. This may result in additional tasks
+completing after the $stop or $finish.
+
+=over 4
+
+If using --coverage, the coverage routines are fully thread safe.
+
+If using --dpi, Verilator assumes pure DPI imports are thread safe,
+balancing performance versus saftey. See --threads-dpi.
+
+If using --savable, the save/restore classes are not multithreaded and are
+must be called only by the eval thread.
+
+If using --sc, the SystemC kernel is not thread safe, therefore the eval
+thread and main thread must be the same.
+
+If using --trace, the tracing classes must be constructed and called from
+the main thread.
+
+If using --vpi, since SystemVerilog VPI was not architected by IEEE to be
+multithreaded, Verilator requires all VPI calls are only made from the main
+thread.
+
+=back
+
 =head1 CONFIGURATION FILES
 
 In addition to the command line, warnings and other features may be
@@ -3361,10 +3585,14 @@ correctly.
 
 =item MODDUP
 
-Error that a module has multiple definitions.  Generally this indicates a
+Warns that a module has multiple definitions.  Generally this indicates a
 coding error, or a mistake in a library file and it's good practice to have
-one module per file to avoid these issues.  For some gate level netlists
-duplicates are unavoidable, and this error may be disabled.
+one module per file (and only put each file once on the command line) to
+avoid these issues.  For some gate level netlists duplicates are sometimes
+unavoidable, and MODDUP should be disabled.
+
+Ignoring this warning will cause the more recent module definition to be
+discarded.
 
 =item MULTIDRIVEN
 
@@ -3587,6 +3815,21 @@ section for more details.
 Ignoring this warning will only slow simulations, it will simulate
 correctly.
 
+=item UNOPTTHREADS
+
+Warns that the thread scheduler was unable to partition the design to fill
+the requested number of threads.
+
+One workaround is to request fewer threads with C<--threads>.
+
+Another possible workaround is to allow more MTasks in the runtime, by
+increasing the value of --threads-max-mtasks. More MTasks will result in
+more communication and synchronization overhead at runtime; the scheduler
+attempts to minimize the number of MTasks for this reason.
+
+Ignoring this warning will only slow simulations, it will simulate
+correctly.
+
 =item UNPACKED
 
 Warns that unpacked structs and unions are not supported.
@@ -3862,11 +4105,29 @@ trace file if you want all data to land in the same output file.
         tfp->close();
     }
 
+=item How do I generate LXT2 waveforms (traces) in C++?
+
+LXT2 a format by GTKWave, which is usually 10x smaller than VCD format.
+This version provides a basic LXT2 support.
+To dump LXT2 format, add the --trace switch to Verilator and change the include path in the testbench to:
+
+    #include "verilated_lxt2_c.h"
+    VerilatedLxt2C* tfp = new VerilatedLxt2C;
+
+Note that currently supporting both LXT2 and VCD in a single simulation is impossible,
+but such requirement could be rare.
+
+=item How do I generate LXT2 waveforms (traces) in SystemC?
+
+The LXT2 library from GTKWave does not currently support SystemC; use VCD
+format instead.
+
 =item How do I view waveforms (traces)?
 
-Verilator makes standard VCD (Value Change Dump) files.  They are viewable
-with the public domain GtkWave (recommended) or Dinotrace (legacy)
-programs, or any of the many commercial offerings.
+Verilator makes standard VCD (Value Change Dump) and LXT2 files.  VCD files are viewable
+with the public domain GTKWave (recommended) or Dinotrace (legacy)
+programs, or any of the many commercial offerings;
+LXT2 is supported by GTKWave only.
 
 =item How do I reduce the size of large waveform (trace) files?
 
@@ -4136,6 +4397,8 @@ performance gain.
 
 In 2009, major SystemVerilog and DPI language support was added.
 
+In 2018, Verilator 4.000 was released with multithreaded support.
+
 Currently, various language features and performance enhancements are added
 as the need arises.  Verilator is now about 3x faster than in 2002, and is
 faster than many popular commercial simulators.
@@ -4147,7 +4410,7 @@ When possible, please instead report bugs to L<http://www.veripool.org/>.
 
 Wilson Snyder <[email protected]>
 
-Major concepts by Paul Wasson, Duane Galbi and Jie Xu.
+Major concepts by Paul Wasson, Duane Galbi, John Coiner and Jie Xu.
 
 
 =head1 CONTRIBUTORS
@@ -4171,52 +4434,57 @@ Some of the people who have provided ideas and feedback for Verilator
 include: Ahmed El-Mahmoudy, David Addison, Tariq B. Ahmad, Nikana
 Anastasiadis, Hans Van Antwerpen, Vasu Arasanipalai, Jens Arm, Sharad
 Bagri, Andrew Bardsley, Matthew Barr, Geoff Barrett, Julius Baxter, Jeremy
-Bennett, Michael Berman, David Binderman, Johan Bjork, David Black, Daniel
-Bone, Gregg Bouchard, Christopher Boumenot, Nick Bowler, Byron Bradley,
-Bryan Brady, Charlie Brej, J Briquet, Lane Brooks, John Brownlee, Jeff
-Bush, Lawrence Butcher, Ted Campbell, Chris Candler, Lauren Carlson, Donal
-Casey, Terry Chen, Enzo Chi, Robert A. Clark, Allan Cochrane, John Coiner,
-Gunter Dannoritzer, Ashutosh Das, Bernard Deadman, John Demme, Mike Denio,
-John Deroo, Philip Derrick, John Dickol, Ruben Diez, Danny Ding, Ivan
-Djordjevic, Jonathon Donaldson, Sebastian Dressler, Alex Duller, Jeff
-Dutton, Usuario Eda, Chandan Egbert, Joe Eiler, Ahmed El-Mahmoudy, Robert
-Farrell, Eugen Fekete, Fabrizio Ferrandi, Brian Flachs, Andrea Foletto, Bob
-Fredieu, Christian Gelinek, Glen Gibb, Shankar Giri, Dan Gisselquist, Sam
-Gladstone, Amir Gonnen, Chitlesh Goorah, Xuan Guo, Neil Hamilton, Jannis
-Harder, Junji Hashimoto, Thomas Hawkins, Robert Henry, David Hewson, Jamey
-Hicks, Hiroki Honda, Alex Hornung, David Horton, Jae Hossell, Alan Hunter,
-Jamie Iles, Ben Jackson, Shareef Jalloq, Krzysztof Jankowski, HyungKi
-Jeong, Iztok Jeras, James Johnson, Christophe Joly, Franck Jullien, Mike
-Kagen, Arthur Kahlich, Kaalia Kahn, Guy-Armand Kamendje, Vasu Kandadi,
-Patricio Kaplan, Ralf Karge, Dan Katz, Sol Katzman, Jonathan Kimmitt, Olof
-Kindgren, Sobhan Klnv, Gernot Koch, Soon Koh, Steve Kolecki, Brett Koonce,
-Wojciech Koszek, Varun Koyyalagunta, David Kravitz, Roland Kruse, Sergey
-Kvachonok, Ed Lander, Steve Lang, Stephane Laurent, Walter Lavino,
-Christian Leber, Igor Lesik, John Li, Eivind Liland, Charlie Lind, Andrew
-Ling, Paul Liu, Derek Lockhart, Arthur Low, Stefan Ludwig, Dan Lussier,
-Fred Ma, Duraid Madina, Mark Marshall, Alfonso Martinez, Yves Mathieu,
+Bennett, Michael Berman, Victor Besyakov, David Binderman, Johan Bjork,
+David Black, Tymoteusz Blazejczyk, Daniel Bone, Gregg Bouchard, Christopher
+Boumenot, Nick Bowler, Byron Bradley, Bryan Brady, Charlie Brej, J Briquet,
+Lane Brooks, John Brownlee, Jeff Bush, Lawrence Butcher, Ted Campbell,
+Chris Candler, Lauren Carlson, Donal Casey, Sebastien Van Cauwenberghe,
+Terry Chen, Enzo Chi, Robert A. Clark, Allan Cochrane, John Coiner, Laurens
+van Dam, Gunter Dannoritzer, Ashutosh Das, Bernard Deadman, John Demme,
+Mike Denio, John Deroo, Philip Derrick, Joe DErrico, John Dickol, Ruben
+Diez, Danny Ding, Ivan Djordjevic, Jonathon Donaldson, Sebastian Dressler,
+Alex Duller, Jeff Dutton, Usuario Eda, Chandan Egbert, Joe Eiler, Ahmed
+El-Mahmoudy, Trevor Elbourne, Robert Farrell, Eugen Fekete, Fabrizio
+Ferrandi, Brian Flachs, Andrea Foletto, Bob Fredieu, Duane Galbi, Christian
+Gelinek, Glen Gibb, Shankar Giri, Dan Gisselquist, Sam Gladstone, Amir
+Gonnen, Chitlesh Goorah, Xuan Guo, Neil Hamilton, Jannis Harder, Junji
+Hashimoto, Thomas Hawkins, Robert Henry, David Hewson, Jamey Hicks, Joel
+Holdsworth, Hiroki Honda, Alex Hornung, David Horton, Jae Hossell, Alan
+Hunter, James Hutchinson, Jamie Iles, Ben Jackson, Shareef Jalloq,
+Krzysztof Jankowski, HyungKi Jeong, Iztok Jeras, James Johnson, Christophe
+Joly, Franck Jullien, James Jung, Mike Kagen, Arthur Kahlich, Kaalia Kahn,
+Guy-Armand Kamendje, Vasu Kandadi, Patricio Kaplan, Ralf Karge, Dan Katz,
+Sol Katzman, Jonathan Kimmitt, Olof Kindgren, Dan Kirkham, Sobhan Klnv,
+Gernot Koch, Soon Koh, Steve Kolecki, Brett Koonce, Wojciech Koszek, Varun
+Koyyalagunta, David Kravitz, Roland Kruse, Sergey Kvachonok, Ed Lander,
+Steve Lang, Stephane Laurent, Walter Lavino, Christian Leber, Igor Lesik,
+John Li, Eivind Liland, Yu Sheng Lin, Charlie Lind, Andrew Ling, Paul Liu,
+Derek Lockhart, Arthur Low, Stefan Ludwig, Dan Lussier, Fred Ma, Duraid
+Madina, Julien Margetts, Mark Marshall, Alfonso Martinez, Yves Mathieu,
 Patrick Maupin, Jason McMullan, Elliot Mednick, Wim Michiels, Miodrag
 Milanovic, Wai Sum Mong, Sean Moore, Dennis Muhlestein, John Murphy,
 Richard Myers, Dimitris Nalbantis, Bob Newgard, Cong Van Nguyen, Paul
 Nitza, Pete Nixon, Lisa Noack, Mark Nodine, Andreas Olofsson, James
 Pallister, Brad Parker, Maciej Piechotka, David Pierce, Dominic Plunkett,
 David Poole, Mike Popoloski, Rich Porter, Niranjan Prabhu, Usha
-Priyadharshini, Mark Jackson Pulver, Prateek Puri, Chris Randall, Anton
-Rapp, Odd Magne Reitan, Frederic Requin, Alberto Del Rio, Oleg Rodionov,
-Paul Rolfe, Jan Egil Ruud, John Sanguinetti, Galen Seitz, Salman Sheikh,
-Mike Shinkarovsky, Rafael Shirakawa, Jeffrey Short, Rodney Sinclair, Steven
-Slatter, Brian Small, Alex Solomatnikov, Wei Song, Art Stamness, John
-Stevenson, Rob Stoddard, Todd Strader, John Stroebel, Sven Stucki, Emerson
-Suguimoto, Gene Sullivan, Renga Sundararajan, Yutetsu Takatsukasa, Peter
-Tengstrand, Wesley Terpstra, Stefan Thiede, Gary Thomas, Kevin Thompson,
-Ian Thompson, Mike Thyer, Hans Tichelaar, Steve Tong, Michael Tresidder,
-Holger Waechtler, Stefan Wallentowitz, Shawn Wang, Greg Waters, Thomas
-Watts, Eugene Weber, David Welch, Thomas J Whatson, Leon Wildman, Gerald
-Williams, Trevor Williams, Jeff Winston, Joshua Wise, Clifford Wolf, Johan
-Wouters, Ding Xiaoliang, Jie Xu, Mandy Xu, Luke Yang, and Amir
-Yazdanbakhsh.
+Priyadharshini, Mark Jackson Pulver, Prateek Puri, Marshal Qiao, Chris
+Randall, Anton Rapp, Josh Redford, Odd Magne Reitan, Frederic Requin,
+Alberto Del Rio, Oleg Rodionov, Paul Rolfe, Arjen Roodselaar, Jan Egil
+Ruud, John Sanguinetti, Galen Seitz, Salman Sheikh, Mike Shinkarovsky,
+Rafael Shirakawa, Jeffrey Short, Rodney Sinclair, Steven Slatter, Brian
+Small, Wilson Snyder, Alex Solomatnikov, Wei Song, Art Stamness, John
+Stevenson, Patrick Stewart, Rob Stoddard, Todd Strader, John Stroebel, Sven
+Stucki, Emerson Suguimoto, Gene Sullivan, Renga Sundararajan, Yutetsu
+Takatsukasa, Peter Tengstrand, Wesley Terpstra, Rui Terra, Stefan Thiede,
+Gary Thomas, Kevin Thompson, Ian Thompson, Mike Thyer, Hans Tichelaar,
+Steve Tong, Michael Tresidder, Holger Waechtler, Stefan Wallentowitz, Shawn
+Wang, Paul Wasson, Greg Waters, Thomas Watts, Eugene Weber, David Welch,
+Thomas J Whatson, Leon Wildman, Gerald Williams, Trevor Williams, Jeff
+Winston, Joshua Wise, Clifford Wolf, Johan Wouters, Junyi Xi, Ding
+Xiaoliang, Jie Xu, Mandy Xu, Luke Yang, and Amir Yazdanbakhsh.
 
-Thanks to them, and all those we've missed including above.
+Thanks to them, and all those we've missed including above, or wished to
+remain anonymous.
 
 
 =head1 DISTRIBUTION
@@ -4231,7 +4499,7 @@ License Version 2.0.
 
 =head1 SEE ALSO
 
-L<verilator_coverage>, L<verilator_profcfunc>, L<make>,
+L<verilator_coverage>, L<verilator_gantt>, L<verilator_profcfunc>, L<make>,
 
 L<verilator --help> which is the source for this document,
 

bin/verilator_gantt

@@ -0,0 +1,560 @@
+: # -*-Mode: perl;-*- use perl, wherever it is
+eval 'exec perl -wS $0 ${1+"$@"}'
+  if 0;
+# See copyright, etc in below POD section.
+######################################################################
+
+use strict;
+use warnings;
+use Getopt::Long;
+use IO::File;
+use Pod::Usage;
+use vars qw ($Debug);
+
+$Debug = 0;
+my $Opt_File;
+my $Opt_Time_Per_Char = 0;  # rdtsc ticks per char in gantt chart, 0=auto
+my $opt_vcd = "profile_threads.vcd";
+
+our %Threads;
+our %Mtasks;
+our %Global;
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config("no_auto_abbrev");
+if (! GetOptions(
+          "help"        => \&usage,
+          "scale=i"     => \$Opt_Time_Per_Char,
+          "debug"       => sub { $Debug = 1; },
+          "vcd=s"       => \$opt_vcd,
+          "no-vcd!"     => sub { $opt_vcd = undef; },
+          "<>"          => \&parameter,
+    )) {
+    die "%Error: Bad usage, try 'verilator_gantt --help'\n";
+}
+
+$Opt_File = "profile_threads.dat" if !defined $Opt_File;
+
+process($Opt_File);
+write_vcd($opt_vcd) if defined $opt_vcd;
+exit(0);
+
+#######################################################################
+
+sub usage {
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
+    exit (1);
+}
+
+sub parameter {
+    my $param = shift;
+    if (!defined $Opt_File) {
+        $Opt_File = $param;
+    } else {
+        die "%Error: Unknown parameter: $param\n";
+    }
+}
+
+#######################################################################
+
+sub process {
+    my $filename = shift;
+
+    read_data($filename);
+    report();
+}
+
+#######################################################################
+
+sub read_data {
+    my $filename = shift;
+
+    %Global = (rdtsc_cycle_time => 0);
+
+    my $fh = IO::File->new ($filename) or die "%Error: $! $filename,";
+    while (my $line = $fh->getline) {
+        if ($line =~ m/VLPROF mtask\s(\d+)\sstart\s(\d+)\send\s(\d+)\selapsed\s(\d+)\spredict_time\s(\d+)\scpu\s(\d+)\son thread (\d+)/) {
+            my $mtask = $1;
+            my $start = $2;
+            my $end = $3;
+            my $elapsed_time = $4;
+            my $predict_time = $5;
+            my $cpu = $6;
+            my $thread = $7;
+            $Threads{$thread}{$start}{mtask} = $mtask;
+            $Threads{$thread}{$start}{end} = $end;
+            $Threads{$thread}{$start}{cpu} = $cpu;
+
+            if (!exists $Mtasks{$mtask}{elapsed}) {
+                $Mtasks{$mtask}{elapsed} = 0;
+            }
+            $Mtasks{$mtask}{elapsed} += $elapsed_time;
+            $Mtasks{$mtask}{predict} = $predict_time;
+            $Mtasks{$mtask}{end} = max($Mtasks{$mtask}{end}, $end);
+        }
+        elsif ($line =~ /^VLPROFTHREAD/) {}
+        elsif ($line =~ m/VLPROF arg\s+(\S+)\+([0-9.])\s*$/
+               || $line =~ m/VLPROF arg\s+(\S+)\s+([0-9.])\s*$/) {
+            $Global{args}{$1} = $2;
+        }
+        elsif ($line =~ m/VLPROF stat\s+(\S+)\s+([0-9.]+)/) {
+            $Global{stats}{$1} = $2;
+        }
+        elsif ($line =~ /^#/) {}
+        elsif ($Debug) {
+            chomp $line;
+            print "Unk: $line\n";
+        }
+        # TODO -- this is parsing text printed by a client.
+        # Really, verilator proper should generate this
+        # if it's useful...
+        if ($line =~ m/rdtsc time = (\d+) ticks/) {
+            $Global{rdtsc_cycle_time} = $1;
+        }
+    }
+}
+
+sub report {
+    print "Verilator Gantt report\n";
+
+    print "\nArgument settings:\n";
+    foreach my $arg (sort keys %{$Global{args}}) {
+        my $plus = ($arg =~ /^\+/) ? "+" : " ";
+        printf "  %s%s%d\n", $arg, $plus, $Global{args}{$arg};
+    }
+
+    my $nthreads = scalar keys %Threads;
+    $Global{cpus}{cpu_time} = {};
+    foreach my $thread (keys %Threads) {
+        # Make potentially multiple characters per column
+        foreach my $start (keys %{$Threads{$thread}}) {
+            my $cpu = $Threads{$thread}{$start}{cpu};
+            my $elapsed = $Threads{$thread}{$start}{end} - $start;
+            $Global{cpus}{cpu_time}{$cpu} += $elapsed;
+        }
+    }
+
+    my $mt_mtask_time = 0;
+    my $long_mtask_time = 0;
+    my $last_end = 0;
+    foreach my $mtask (keys %Mtasks) {
+        $mt_mtask_time += $Mtasks{$mtask}{elapsed};
+        $last_end = max($last_end, $Mtasks{$mtask}{end});
+        $long_mtask_time = max($long_mtask_time, $Mtasks{$mtask}{elapsed});
+    }
+    $Global{last_end} = $last_end;
+
+    report_graph();
+
+    # If we know cycle time in the same (rdtsc) units,
+    # this will give us an actual utilization number,
+    # (how effectively we keep the cores busy.)
+    #
+    # It also gives us a number we can compare against
+    # serial mode, to estimate the overhead of data sharing,
+    # which will show up in the total elapsed time. (Overhead
+    # of synchronization and scheduling should not.)
+    print "\nAnalysis:\n";
+    printf "  Total threads             = %d\n", $nthreads;
+    printf "  Total mtasks              = %d\n", scalar(keys %Mtasks);
+    printf "  Total cpus used           = %d\n", scalar(keys %{$Global{cpus}});
+    printf "  Total yields              = %d\n", $Global{stats}{yields};
+    printf "  Total eval time           = %d rdtsc ticks\n", $Global{last_end};
+    printf "  Longest mtask time        = %d rdtsc ticks\n", $long_mtask_time;
+    printf "  All-thread mtask time     = %d rdtsc ticks\n", $mt_mtask_time;
+    my $long_efficiency = $long_mtask_time/($Global{last_end});
+    printf "  Longest-thread efficiency = %0.1f%%\n", $long_efficiency*100;
+    my $mt_efficiency = $mt_mtask_time/($Global{last_end}*$nthreads);
+    printf "  All-thread efficiency     = %0.1f%%\n", $mt_efficiency*100;
+    printf "  All-thread speedup        = %0.1f\n", $mt_efficiency*$nthreads;
+    if ($Global{rdtsc_cycle_time} > 0) {
+        my $ut = $mt_mtask_time / $Global{rdtsc_cycle_time};
+        print "tot_mtask_cpu=$mt_mtask_time cyc=$Global{rdtsc_cycle_time} ut=$ut\n";
+    }
+
+    my @p2e_ratios;
+    my $min_p2e = 1000000;
+    my $min_mtask;
+    my $max_p2e = -1000000;
+    my $max_mtask;
+    foreach my $mtask (sort keys %Mtasks) {
+        if ($Mtasks{$mtask}{elapsed} > 0) {
+            if ($Mtasks{$mtask}{predict} == 0) {
+                $Mtasks{$mtask}{predict} = 1;  # don't log(0) below
+            }
+            my $p2e_ratio = log( $Mtasks{$mtask}{predict} / $Mtasks{$mtask}{elapsed} );
+            #print "log(p2e $mtask) = $p2e_ratio   (predict $Mtasks{$mtask}{predict}, elapsed $Mtasks{$mtask}{elapsed})\n";
+            push @p2e_ratios, $p2e_ratio;
+
+            if ($p2e_ratio > $max_p2e) {
+                $max_p2e = $p2e_ratio;
+                $max_mtask = $mtask;
+            }
+            if ($p2e_ratio < $min_p2e) {
+                $min_p2e = $p2e_ratio;
+                $min_mtask = $mtask;
+            }
+        }
+    }
+
+    print "\nStatistics:\n";
+    print "  min log(p2e) = $min_p2e  from mtask $min_mtask (predict $Mtasks{$min_mtask}{predict}, elapsed $Mtasks{$min_mtask}{elapsed})\n";
+    print "  max log(p2e) = $max_p2e  from mtask $max_mtask (predict $Mtasks{$max_mtask}{predict}, elapsed $Mtasks{$max_mtask}{elapsed})\n";
+
+    my $stddev = stddev(\@p2e_ratios);
+    my $mean = mean(\@p2e_ratios);
+    print "  mean = " . ($mean) . "\n";
+    print "  stddev = " . ($stddev) . "\n";
+    print "  e ^ stddev = " . exp($stddev). "\n";
+    print "\n";
+}
+
+sub report_graph {
+    my $time_per = $Opt_Time_Per_Char;
+    if ($time_per == 0) {
+        $time_per = ($Global{last_end} / 40);  # Start with 40 columns
+        while ($time_per > 10) {
+            my ($graph, $conflicts) = _make_graph($time_per);
+            last if !$conflicts;
+            $time_per = int($time_per/2);
+        }
+        # One more step so we can fit more labels
+        $time_per = int($time_per/2);
+    }
+
+    my ($graph, $conflicts) = _make_graph($time_per);
+
+    print "\nThread gantt graph:\n";
+    print "  Legend: One character width = $time_per rdtsc ticks\n";
+    print "  Legend: '&' = multiple mtasks in this period (character width)\n";
+
+    my $scale = "   <-".$Global{last_end}." rdtsc total";
+    for (my $col = length($scale);  # -2 for '->' below
+         $col < ($Global{last_end}/$time_per); ++$col) {
+        $scale .= "-";
+    }
+    print "  $scale->\n";
+
+    foreach my $thread (sort keys %{$graph}) {
+        print "  t: ";
+        _print_graph_line($graph->{$thread}, '');
+    }
+}
+
+sub _make_graph {
+    my $time_per = shift;
+
+    my $graph = {};  # {thread}{column}{char=>'x' or chars=>#}
+    my $conflicts = 0;
+    foreach my $thread (keys %Threads) {
+        # Make potentially multiple characters per column
+        foreach my $start (sort {$a <=> $b} keys %{$Threads{$thread}}) {
+            my $end = $Threads{$thread}{$start}{end};
+            my $mtask = $Threads{$thread}{$start}{mtask};
+            my $cpu = $Threads{$thread}{$start}{cpu};
+
+            my $startcol = _time_col($time_per, $start);
+            my $endcol = _time_col($time_per, $end);
+
+            my $label = "[";
+            $label .= "$cpu";  # Maybe make optional in future
+            my $width = $endcol - $startcol + 1;
+            while (length($label) < ($width-1)) {  # -1 for ']'
+                $label .= "-";
+            }
+            $label .= "]";
+            $graph->{$thread}[$startcol]{char} .= $label;
+        }
+        if ($Debug) {
+            print "# Multicol: "; _print_graph_line($graph->{$thread}, '|');
+        }
+        # Expand line to one char per column
+        for (my $col = 0; $col <= $#{$graph->{$thread}}; ++$col) {
+            if (my $chars = $graph->{$thread}[$col]{char}) {
+                my $ok = 1;
+                for (my $coladd = 1; $coladd<length($chars); ++$coladd) {
+                    if ($graph->{$thread}[$col + $coladd]{char}) {
+                        $ok = 0; last;
+                    }
+                }
+                if (!$ok) {
+                    if ($chars =~ /\[.*\[/) {  # Two begins or more
+                        $conflicts++;
+                        $graph->{$thread}[$col]{char} = "&";
+                    } else {
+                        $graph->{$thread}[$col]{char} = "[";
+                    }
+                    for (my $coladd = 1; $coladd<length($chars); ++$coladd) {
+                        if ($graph->{$thread}[$col + $coladd]{char}) {
+                            last;
+                        } else {
+                            $graph->{$thread}[$col + $coladd]{char} = 'x';
+                        }
+                    }
+                } else {
+                    my $coladd = 0;
+                    foreach my $char (split //, $chars) {
+                        $graph->{$thread}[$col+$coladd]{char} = $char;
+                        ++$coladd;
+                    }
+                }
+            }
+        }
+        if ($Debug) {
+            print "# Singlcol: "; _print_graph_line($graph->{$thread}, '|');
+        }
+    }
+    print "# Conflicts $conflicts\n" if $Debug;
+    return ($graph, $conflicts);
+}
+
+sub _print_graph_line {
+    my $graph_thread = shift;
+    my $sep = shift;
+    for (my $col = 0; $col <= $#{$graph_thread}; ++$col) {
+        my $c = $graph_thread->[$col]{char}; $c=' ' if !defined $c;
+        print $c, $sep;
+    }
+    print "\n";
+}
+
+sub _time_col {
+    my $time_per = shift;
+    my $time = shift;
+    return int($time/$time_per);
+}
+
+#######################################################################
+
+sub write_vcd {
+    my $filename = shift;
+    print "Writing $filename\n";
+    my $fh = IO::File->new(">$filename") or die "%Error: $! $filename,";
+    my $vcd = {values => {},  # {<time>}{<code>} = value
+               sigs => {},  # {<module>}{<sig}} = code
+               code => 0,
+    };
+
+    my %parallelism;
+    foreach my $thread (keys %Threads) {
+        my $mcode = ($vcd->{sigs}{threads}{"thread${thread}_mtask"} ||= $vcd->{code}++);
+        foreach my $start (sort {$a <=> $b} keys %{$Threads{$thread}}) {
+            my $end = $Threads{$thread}{$start}{end};
+            my $mtask = $Threads{$thread}{$start}{mtask};
+            my $cpu = $Threads{$thread}{$start}{cpu};
+            $vcd->{values}{$start}{$mcode} = $mtask;
+            $vcd->{values}{$end}{$mcode} = undef;
+            $parallelism{$start}++;
+            $parallelism{$end}--;
+
+            my $ccode = $vcd->{sigs}{cpus}{"cpu${cpu}_thread"} ||= $vcd->{code}++;
+            $vcd->{values}{$start}{$ccode} = $thread;
+            $vcd->{values}{$end}{$ccode} = undef;
+
+            my $mcode = $vcd->{sigs}{mtasks}{"mtask${mtask}_cpu"} ||= $vcd->{code}++;
+            $vcd->{values}{$start}{$mcode} = $cpu;
+            $vcd->{values}{$end}{$mcode} = undef;
+        }
+    }
+    {
+        my $pcode = ($vcd->{sigs}{Stats}{"parallelism"} ||= $vcd->{code}++);
+        my $value = 0;
+        foreach my $time (sort {$a<=>$b} keys %parallelism) {
+            $value += $parallelism{$time};
+            $vcd->{values}{$time}{$pcode} = $value;
+        }
+    }
+
+    $fh->print('$version Generated by verilator_gantt $end'."\n");
+    $fh->print('$timescale 1ns $end'."\n");
+    $fh->print("\n");
+
+    my %all_codes;
+    $fh->print(' $scope module gantt $end'."\n");
+    foreach my $module (sort keys %{$vcd->{sigs}}) {
+        $fh->printf('  $scope module %s $end'."\n", $module);
+        foreach my $sig (sort keys %{$vcd->{sigs}{$module}}) {
+            my $code = $vcd->{sigs}{$module}{$sig};
+            $fh->printf('   $var wire 32 v%x %s [31:0] $end'."\n",
+                        $code, $sig);
+            $all_codes{$code} = 1;
+        }
+        $fh->print('  $upscope $end'."\n");
+    }
+    $fh->print(' $upscope $end'."\n");
+    $fh->print('$enddefinitions $end'."\n");
+    $fh->print("\n");
+
+    my $first = 1;
+    foreach my $time (sort {$a <=> $b} keys %{$vcd->{values}}) {
+        if ($first) {
+            $first = 0;
+            # Start with Z for any signals without time zero data
+            foreach my $code (keys %all_codes) {
+                if (!defined $vcd->{values}{$time}{$code}) {
+                    $vcd->{values}{$time}{$code} = undef;
+                }
+            }
+        }
+        $fh->printf("#%d\n", $time);
+        foreach my $code (sort keys %{$vcd->{values}{$time}}) {
+            my $value = $vcd->{values}{$time}{$code};
+            if (defined $value) {
+                $fh->printf("b%b v%x\n", $value, $code);
+            } else {
+                $fh->printf("bz v%x\n", $code);
+            }
+        }
+    }
+}
+
+#######################################################################
+# Similar to Statistics::Basic functions, but avoid a package dependency
+
+sub max {
+    my $n = $_[0]; shift;
+    while (defined $_[0]) {
+        $n = $_[0] if !defined $n || $_[0] > $n;
+        shift;
+    }
+    return $n;
+}
+
+sub mean {
+    my $arrayref = shift;
+    my $n = 0;
+    my $sum = 0;
+    foreach my $v (@$arrayref) {
+        $sum += $v;
+        $n++;
+    }
+    return undef if !$n;
+    return $sum/$n;
+}
+
+sub stddev {
+    my $arrayref = shift;
+    my $n = 0;
+    my $sum = 0;
+    my $sumsq = 0;
+    foreach my $v (@$arrayref) {
+        $sum += $v;
+        $sumsq += $v**2;
+        $n++;
+    }
+    return undef if !$n;
+    return sqrt(($sumsq/$n) - ($sum/$n)**2);
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+verilator_gantt - Create Gantt chart of multi-threaded execution
+
+=head1 SYNOPSIS
+
+Creates a visual representation to help analyze Verilator multithreaded
+simulation performance, by showing when each macro-task starts and ends,
+and showing when each thread is busy or idle.
+
+The generated Gantt chart has time on the X-axis. Times shown are to the
+scale printed, i.e. a certain about of time for each character width.  The
+Y-axis shows threads, each thread's execution is shown on one line.  That
+line shows "[" at the position in time when it executes.
+
+Following the "[" is the cpu number the task executed on, followed by zero
+or more "-" to make the width of the characters match the scaled execution
+time, followed by a "]".  If the scale is too small, the cpu number and
+mtask number will not be printed.  If the scale is very small, a "&"
+indicates multiple mtasks started at that time position.
+
+Also creates a value change dump (VCD) format dump file which may be viewed
+in a waveform viewer (e.g. C<GTKWave>).  See below.
+
+=head1 USAGE
+
+  Build with --prof-threads.
+
+  Run a sim with +verilator+prof+threads+window 2.
+
+  This will create profile_threads.dat.
+
+  Then run:
+
+  verilator_gantt profile_threads.dat
+
+  The report will be printed on standard output, this also generates
+  profile_threads.vcd
+
+  View profile_threads.vcd in a waveform viewer.
+
+=head1 VCD SIGNALS
+
+In waveforms there are the following signals. Most signals the "decimal"
+format will remove the leading zeros and make the traces easier to read.
+
+parallelism: The number of mtasks active at this time, for best performance
+this will match the thread count. You may want to use an "analog step"
+format to view this signal.
+
+cpu#_thread: For the given CPU number, the thread number executing.
+
+mtask#_cpu; For the given mtask id, the CPU it is executing on.
+
+thread#_mtask: For the given thread number, the mtask id executing.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item I<filename>
+
+The filename to read data from, defaults to "profile_threads.dat".
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item --scale I<n>
+
+On the X-axis of the generated Gantt chart, each character represents this
+many time units. (On x86, time units are rdtsc ticks.)  Defaults to 0,
+which will automatically compute a reasonable scale where no two mtasks
+need to fit into same character width's worth of scaled time.
+
+=item --no-vcd
+
+=item --vcd I<filename>
+
+Set output filename for vcd dump, or disable. Default is
+verilator_gantt.vcd.
+
+=back
+
+=head1 DISTRIBUTION
+
+The latest version is available from L<http://www.veripool.org/>.
+
+Copyright 2018-2018 by Wilson Snyder.  Verilator 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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+C<verilator>
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "$V4/bin/verilator_gantt $V4/test_regress/obj_vltmt/t_gantt/vlt_sim.log"
+### End:

configure.ac

@@ -6,7 +6,9 @@
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[3.924 2018-06-12])
+AC_INIT([Verilator],[4.002 2018-09-16],
+        [https://www.veripool.org/verilator],
+        [verilator],[https://www.veripool.org/verilator])
 # When releasing, also update header of Changes file
 # and commit using "devel release" or "Version bump" message
 
@@ -15,6 +17,14 @@ AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk incl
 
 AC_MSG_RESULT([configuring for $PACKAGE_STRING])
 
+# Ignore automake flags passed by Ubuntu builds
+AC_ARG_ENABLE([dependency-tracking],
+              [AS_HELP_STRING([--disable-dependency-tracking], [ignored])])
+AC_ARG_ENABLE([maintainer-mode],
+              [AS_HELP_STRING([--enable-maintainer-mode], [ignored])])
+AC_ARG_ENABLE([silent-rules],
+              [AS_HELP_STRING([--disable-silent-rules], [ignored])])
+
 # Special Substitutions - CFG_WITH_DEFENV
 AC_MSG_CHECKING(whether to use hardcoded paths)
 AC_ARG_ENABLE([defenv],
@@ -65,6 +75,21 @@ AC_ARG_ENABLE([longtests],
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)
 
+# CFG_WITH_PREC11
+AC_MSG_CHECKING(whether allow pre-C++11)
+AC_ARG_ENABLE([prec11],
+              [AS_HELP_STRING([--enable-prec11],
+                              [enable pre-C++11 compilers])],
+              [case "${enableval}" in
+                yes) CFG_WITH_PREC11=yes ;;
+                no)  CFG_WITH_PREC11=no ;;
+                *)   AC_MSG_ERROR([bad value ${enableval} for --enable-prec11]) ;;
+               esac],
+              [CFG_WITH_PREC11=no;]
+              )
+AC_SUBST(CFG_WITH_PREC11)
+AC_MSG_RESULT($CFG_WITH_PREC11)
+
 # Compiler flags
 CFLAGS=-I${includedir}
 CPPFLAGS=-I${includedir}
@@ -165,15 +190,44 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
     fi
    ])
 
+AC_DEFUN([_MY_LDLIBS_CHECK_FLAG],
+   [# _MY_LDLIBS_CHECK_FLAG(flag) -- Check if linker supports specific options
+    # Set $_my_result appropriately
+    ACO_SAVE_LIBS="$LIBS"
+    LIBS="$LIBS $1"
+    AC_MSG_CHECKING([whether $CXX linker accepts $1])
+    AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM([[]])],
+         [_my_result=yes
+          if test -s conftest.err; then
+            if grep -e "$1" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi],
+         [_my_result=no])
+    AC_MSG_RESULT($_my_result)
+    LIBS="$ACO_SAVE_LIBS"
+   ])
+
+AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
+   [# _MY_LDLIBS_CHECK_OPT(flag) -- Check if linker supports specific options
+    # If it does, append flag to variable
+    _MY_LDLIBS_CHECK_FLAG($2)
+    if test "$_my_result" = "yes" ; then
+       $1="$$1 $2"
+    fi
+   ])
+
 # Flag to select newest language standard supported
 # Macros work such that first option that passes is the one we take
+# gnu++17 code is clean, but SystemC in 2018 doesn't link with it (bug1339)
 # gnu++14 is the newest that Verilator supports
 # std++03 is the oldest that Verilator supports
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++17)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++14)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++11)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++03)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++17)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++14)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++11)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++03)
@@ -183,11 +237,11 @@ AC_SUBST(CFG_CXXFLAGS_STD_NEWEST)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++03)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++11)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++14)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++17)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++17)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++03)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++11)
 _MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++14)
-_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++17)
+#_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++17)
 AC_SUBST(CFG_CXXFLAGS_STD_OLDEST)
 
 # Flags for compiling Verilator internals including parser, and Verilated files
@@ -201,7 +255,6 @@ AC_SUBST(CFG_CXXFLAGS_WEXTRA)
 # Flags for compiling Verilator internals including parser always
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-delete-null-pointer-checks)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-undefined-bool-conversion)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
@@ -233,6 +286,13 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 
+# Find multithread linker flags
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-mt)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-pthread)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-lpthread)
+_MY_LDLIBS_CHECK_OPT(CFG_LDLIBS_THREADS,-latomic)
+AC_SUBST(CFG_LDLIBS_THREADS)
+
 # Set CFG_WITH_THREADED if can support threading
 AC_MSG_CHECKING(whether $CXX supports Verilated threads)
 ACO_SAVE_CXXFLAGS="$CXXFLAGS"
@@ -250,6 +310,22 @@ CFG_WITH_THREADED=$_my_result
 AC_SUBST(CFG_WITH_THREADED)
 AC_MSG_RESULT($CFG_WITH_THREADED)
 
+# Check compiler flag
+if test "$CFG_WITH_THREADED" = "no" ; then
+   if test "$CFG_WITH_PREC11" = "no" ; then
+      AC_MSG_NOTICE([[]])
+      AC_MSG_ERROR([[the $CXX compiler appears to not support C++11.
+
+Verilator plans to require a C++11 or newer compiler in a future release,
+unless sufficient people report problems. Therefore, if you do not have a
+C++11 compiler, please post a message to
+https://www.veripool.org/boards/3/topics/2580-Verilator-Requiring-C-11-compiler
+indicating your OS and when you think C++11 might be ok, and then rerun
+configure with the --enable-prec11 argument. Thanks.]])
+
+   fi
+fi
+
 # Checks for library functions.
 AC_CHECK_MEMBER([struct stat.st_mtim.tv_nsec],
     [AC_DEFINE([HAVE_STAT_NSEC],[1],[Defined if struct stat has st_mtim.tv_nsec])],

doxygen.config

@@ -630,12 +630,8 @@ WARN_LOGFILE           =
 # with spaces.
 
 INPUT                  = doxygen-mainpage \
-		         include \
+                         include \
                          src \
-                         test_c \
-                         test_regress \
-                         test_sc \
-                         test_v
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

examples/tracing_c/Makefile_obj

@@ -17,6 +17,9 @@ default: Vtop
 # Include the rules made by Verilator
 include Vtop.mk
 
+# Use OBJCACHE (ccache) if using gmake and its installed
+COMPILE.cc = $(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
+
 #######################################################################
 # Compile flags
 

examples/tracing_c/sim_main.cpp

@@ -7,8 +7,6 @@
 // Include common routines
 #include <verilated.h>
 
-#include <sys/stat.h>  // mkdir
-
 // Include model header, generated from Verilating "top.v"
 #include "Vtop.h"
 
@@ -20,8 +18,8 @@
 // Current simulation time (64-bit unsigned)
 vluint64_t main_time = 0;
 // Called by $time in Verilog
-double sc_time_stamp () {
-    return main_time; // Note does conversion to real, to match SystemC
+double sc_time_stamp() {
+    return main_time;  // Note does conversion to real, to match SystemC
 }
 
 int main(int argc, char** argv, char** env) {
@@ -51,7 +49,7 @@ int main(int argc, char** argv, char** env) {
         VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
         tfp = new VerilatedVcdC;
         top->trace(tfp, 99);  // Trace 99 levels of hierarchy
-        mkdir("logs", 0777);
+        Verilated::mkdir("logs");
         tfp->open("logs/vlt_dump.vcd");  // Open the dump file
     }
 #endif
@@ -112,7 +110,7 @@ int main(int argc, char** argv, char** env) {
 
     //  Coverage analysis (since test passed)
 #if VM_COVERAGE
-    mkdir("logs", 0777);
+    Verilated::mkdir("logs");
     VerilatedCov::write("logs/coverage.dat");
 #endif
 

examples/tracing_sc/Makefile_obj

@@ -17,6 +17,9 @@ default: Vtop
 # Include the rules made by Verilator
 include Vtop.mk
 
+# Use OBJCACHE (ccache) if using gmake and its installed
+COMPILE.cc = $(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c
+
 #######################################################################
 # Compile flags
 

examples/tracing_sc/sc_main.cpp

@@ -96,7 +96,7 @@ int sc_main(int argc, char* argv[]) {
         cout << "Enabling waves into logs/vlt_dump.vcd...\n";
         tfp = new VerilatedVcdSc;
         top->trace(tfp, 99);
-        mkdir("logs", 0777);
+        Verilated::mkdir("logs");
         tfp->open("logs/vlt_dump.vcd");
     }
 #endif
@@ -134,7 +134,7 @@ int sc_main(int argc, char* argv[]) {
 
     //  Coverage analysis (since test passed)
 #if VM_COVERAGE
-    mkdir("logs", 0777);
+    Verilated::mkdir("logs");
     VerilatedCov::write("logs/coverage.dat");
 #endif
 

include/lxt2/lxt2_config.h

@@ -0,0 +1,12 @@
+/* This file specifically for LXT2 usage */
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define to 1 if you have `alloca', as a function or macro. */
+#define HAVE_ALLOCA 1
+
+/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
+#define HAVE_ALLOCA_H 1
+
+/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
+#define HAVE_FSEEKO 1

include/lxt2/lxt2_write.h

@@ -0,0 +1,314 @@
+/*
+ * Copyright (c) 2003-2012 Tony Bybell.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef DEFS_LXTW_H
+#define DEFS_LXTW_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <zlib.h>
+
+#ifndef HAVE_FSEEKO
+#define fseeko fseek
+#define ftello ftell
+#endif
+
+#include "wavealloca.h"
+
+#define LXT2_WR_HDRID (0x1380)
+#define LXT2_WR_VERSION (0x0001)
+
+#define LXT2_WR_GRANULE_SIZE (64)
+#define LXT2_WR_GRANULE_NUM (256)
+#define LXT2_WR_PARTIAL_SIZE (2048)
+
+#define LXT2_WR_GRAN_SECT_TIME 0
+#define LXT2_WR_GRAN_SECT_DICT 1
+#define LXT2_WR_GRAN_SECT_TIME_PARTIAL 2
+
+#define LXT2_WR_GZWRITE_BUFFER 4096
+#define LXT2_WR_SYMPRIME 500009
+
+typedef uint64_t lxttime_t;
+typedef  int64_t lxtstime_t;
+
+
+#ifndef _MSC_VER
+	#ifdef __MINGW32__
+		#define LXT2_WR_LLD "%I64d"
+	#else
+        	#define LXT2_WR_LLD "%lld"
+	#endif
+        #define LXT2_WR_LLDESC(x) x##LL
+        #define LXT2_WR_ULLDESC(x) x##ULL
+#else
+        #define LXT2_WR_LLD "%I64d"
+        #define LXT2_WR_LLDESC(x) x##i64
+        #define LXT2_WR_ULLDESC(x) x##i64
+#endif
+
+#if LXT2_WR_GRANULE_SIZE > 32
+typedef unsigned long long granmsk_t;
+#define LXT2_WR_GRAN_0VAL (LXT2_WR_ULLDESC(0))
+#define LXT2_WR_GRAN_1VAL (LXT2_WR_ULLDESC(1))
+#else
+typedef unsigned int granmsk_t;
+#define LXT2_WR_GRAN_0VAL (0)
+#define LXT2_WR_GRAN_1VAL (1)
+#endif
+
+
+enum LXT2_WR_Encodings {
+	LXT2_WR_ENC_0,
+	LXT2_WR_ENC_1,
+	LXT2_WR_ENC_INV,
+	LXT2_WR_ENC_LSH0,
+	LXT2_WR_ENC_LSH1,
+	LXT2_WR_ENC_RSH0,
+	LXT2_WR_ENC_RSH1,
+
+	LXT2_WR_ENC_ADD1,
+	LXT2_WR_ENC_ADD2,
+	LXT2_WR_ENC_ADD3,
+	LXT2_WR_ENC_ADD4,
+
+	LXT2_WR_ENC_SUB1,
+	LXT2_WR_ENC_SUB2,
+	LXT2_WR_ENC_SUB3,
+	LXT2_WR_ENC_SUB4,
+
+	LXT2_WR_ENC_X,
+	LXT2_WR_ENC_Z,
+
+	LXT2_WR_ENC_BLACKOUT,
+
+	LXT2_WR_DICT_START
+	};
+
+/*
+ * integer splay
+ */
+typedef struct lxt2_wr_ds_tree_node lxt2_wr_ds_Tree;
+struct lxt2_wr_ds_tree_node {
+    lxt2_wr_ds_Tree * left, * right;
+    granmsk_t item;
+    int val;
+    lxt2_wr_ds_Tree * next;
+};
+
+
+/*
+ * string splay
+ */
+typedef struct lxt2_wr_dslxt_tree_node lxt2_wr_dslxt_Tree;
+struct lxt2_wr_dslxt_tree_node {
+    lxt2_wr_dslxt_Tree * left, * right;
+    char *item;
+    unsigned int val;
+    lxt2_wr_dslxt_Tree * next;
+};
+
+
+struct lxt2_wr_trace
+{
+FILE *handle;
+gzFile zhandle;
+
+lxt2_wr_dslxt_Tree *dict;	/* dictionary manipulation */
+unsigned int num_dict_entries;
+unsigned int dict_string_mem_required;
+lxt2_wr_dslxt_Tree *dict_head;
+lxt2_wr_dslxt_Tree *dict_curr;
+
+lxt2_wr_ds_Tree *mapdict;	/* bitmap compression */
+unsigned int num_map_entries;
+lxt2_wr_ds_Tree *mapdict_head;
+lxt2_wr_ds_Tree *mapdict_curr;
+
+off_t position;
+off_t zfacname_predec_size, zfacname_size, zfacgeometry_size;
+off_t zpackcount, zpackcount_cumulative;
+off_t current_chunk, current_chunkz;
+
+struct lxt2_wr_symbol *sym[LXT2_WR_SYMPRIME];
+struct lxt2_wr_symbol **sorted_facs;
+struct lxt2_wr_symbol *symchain;
+unsigned int numfacs, numalias;
+int numfacbytes;
+int longestname;
+
+int numsections, numblock;
+off_t facname_offset, facgeometry_offset;
+
+lxttime_t mintime, maxtime;
+lxtstime_t timezero;
+unsigned int timegranule;
+int timescale;
+unsigned int timepos;
+unsigned int maxgranule;
+lxttime_t firsttime, lasttime;
+lxttime_t timetable[LXT2_WR_GRANULE_SIZE];
+
+unsigned int partial_iter;
+
+char *compress_fac_str;
+int compress_fac_len;
+
+lxttime_t flushtime;
+unsigned flush_valid : 1;
+
+unsigned do_strip_brackets : 1;
+unsigned emitted : 1;			/* gate off change field zmode changes when set */
+unsigned timeset : 1;			/* time has been modified from 0..0 */
+unsigned bumptime : 1;			/* says that must go to next time position in granule as value change exists for current time */
+unsigned granule_dirty : 1;		/* for flushing out final block */
+unsigned blackout : 1;			/* blackout on/off */
+unsigned partial : 1;			/* partial (vertical) trace support */
+unsigned partial_zip : 1;		/* partial (vertical) trace support for zip subregions */
+unsigned no_checkpoint : 1;		/* turns off interblock checkpointing */
+unsigned partial_preference : 1;	/* partial preference encountered on some facs */
+
+char initial_value;
+
+char zmode[4];				/* fills in with "wb0".."wb9" */
+unsigned int gzbufpnt;
+unsigned char gzdest[LXT2_WR_GZWRITE_BUFFER + 4];	/* enough for zlib buffering */
+
+char *lxtname;
+off_t break_size;
+off_t break_header_size;
+unsigned int break_number;
+};
+
+
+struct lxt2_wr_symbol
+{
+struct lxt2_wr_symbol *next;
+struct lxt2_wr_symbol *symchain;
+char *name;
+int namlen;
+
+int facnum;
+struct lxt2_wr_symbol *aliased_to;
+
+char *value;	/* fac's actual value */
+
+unsigned int rows;
+int msb, lsb;
+int len;
+int flags;
+
+unsigned partial_preference : 1;	/* in order to shove nets to the first partial group */
+
+unsigned int chgpos;
+granmsk_t msk;				/* must contain LXT2_WR_GRANULE_SIZE bits! */
+unsigned int chg[LXT2_WR_GRANULE_SIZE];
+};
+
+
+#define LXT2_WR_SYM_F_BITS         (0)
+#define LXT2_WR_SYM_F_INTEGER      (1<<0)
+#define LXT2_WR_SYM_F_DOUBLE       (1<<1)
+#define LXT2_WR_SYM_F_STRING       (1<<2)
+#define LXT2_WR_SYM_F_TIME         (LXT2_WR_SYM_F_STRING)      /* user must correctly format this as a string */
+#define LXT2_WR_SYM_F_ALIAS        (1<<3)
+
+#define LXT2_WR_SYM_F_SIGNED       (1<<4)
+#define LXT2_WR_SYM_F_BOOLEAN      (1<<5)
+#define LXT2_WR_SYM_F_NATURAL      ((1<<6)|(LXT2_WR_SYM_F_INTEGER))
+#define LXT2_WR_SYM_F_POSITIVE     ((1<<7)|(LXT2_WR_SYM_F_INTEGER))
+#define LXT2_WR_SYM_F_CHARACTER    (1<<8)
+
+#define LXT2_WR_SYM_F_CONSTANT     (1<<9)
+#define LXT2_WR_SYM_F_VARIABLE     (1<<10)
+#define LXT2_WR_SYM_F_SIGNAL       (1<<11)
+
+#define LXT2_WR_SYM_F_IN           (1<<12)
+#define LXT2_WR_SYM_F_OUT          (1<<13)
+#define LXT2_WR_SYM_F_INOUT        (1<<14)
+
+#define LXT2_WR_SYM_F_WIRE         (1<<15)
+#define LXT2_WR_SYM_F_REG          (1<<16)
+
+
+			/* file I/O */
+struct lxt2_wr_trace *	lxt2_wr_init(const char *name);
+void 			lxt2_wr_flush(struct lxt2_wr_trace *lt);
+void 			lxt2_wr_close(struct lxt2_wr_trace *lt);
+
+			/* for dealing with very large traces, split into multiple files approximately "siz" in length */
+void 			lxt2_wr_set_break_size(struct lxt2_wr_trace *lt, off_t siz);
+
+			/* 0 = no compression, 9 = best compression, 4 = default */
+void			lxt2_wr_set_compression_depth(struct lxt2_wr_trace *lt, unsigned int depth);
+
+			/* default is partial off, turning on makes for faster trace reads, nonzero zipmode causes vertical compression */
+void			lxt2_wr_set_partial_off(struct lxt2_wr_trace *lt);
+void			lxt2_wr_set_partial_on(struct lxt2_wr_trace *lt, int zipmode);
+void			lxt2_wr_set_partial_preference(struct lxt2_wr_trace *lt, const char *name);
+
+			/* turning off checkpointing makes for smaller files */
+void			lxt2_wr_set_checkpoint_off(struct lxt2_wr_trace *lt);
+void			lxt2_wr_set_checkpoint_on(struct lxt2_wr_trace *lt);
+
+			/* facility creation */
+void                    lxt2_wr_set_initial_value(struct lxt2_wr_trace *lt, char value);
+struct lxt2_wr_symbol *	lxt2_wr_symbol_find(struct lxt2_wr_trace *lt, const char *name);
+struct lxt2_wr_symbol *	lxt2_wr_symbol_add(struct lxt2_wr_trace *lt, const char *name, unsigned int rows, int msb, int lsb, int flags);
+struct lxt2_wr_symbol *	lxt2_wr_symbol_alias(struct lxt2_wr_trace *lt, const char *existing_name, const char *alias, int msb, int lsb);
+void			lxt2_wr_symbol_bracket_stripping(struct lxt2_wr_trace *lt, int doit);
+
+			/* each granule is LXT2_WR_GRANULE_SIZE (32 or 64) timesteps, default is 256 per section */
+void 			lxt2_wr_set_maxgranule(struct lxt2_wr_trace *lt, unsigned int maxgranule);
+
+			/* time ops */
+void 			lxt2_wr_set_timescale(struct lxt2_wr_trace *lt, int timescale);
+void 			lxt2_wr_set_timezero(struct lxt2_wr_trace *lt, lxtstime_t timeval);
+int 			lxt2_wr_set_time(struct lxt2_wr_trace *lt, unsigned int timeval);
+int 			lxt2_wr_inc_time_by_delta(struct lxt2_wr_trace *lt, unsigned int timeval);
+int 			lxt2_wr_set_time64(struct lxt2_wr_trace *lt, lxttime_t timeval);
+int 			lxt2_wr_inc_time_by_delta64(struct lxt2_wr_trace *lt, lxttime_t timeval);
+
+                        /* allows blackout regions in LXT files */
+void                    lxt2_wr_set_dumpoff(struct lxt2_wr_trace *lt);
+void                    lxt2_wr_set_dumpon(struct lxt2_wr_trace *lt);
+
+			/* left fill on bit_string uses vcd semantics (left fill with value[0] unless value[0]=='1', then use '0') */
+int 			lxt2_wr_emit_value_int(struct lxt2_wr_trace *lt, struct lxt2_wr_symbol *s, unsigned int row, int value);
+int 			lxt2_wr_emit_value_double(struct lxt2_wr_trace *lt, struct lxt2_wr_symbol *s, unsigned int row, double value);
+int 			lxt2_wr_emit_value_string(struct lxt2_wr_trace *lt, struct lxt2_wr_symbol *s, unsigned int row, char *value);
+int 			lxt2_wr_emit_value_bit_string(struct lxt2_wr_trace *lt, struct lxt2_wr_symbol *s, unsigned int row, char *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/lxt2/wavealloca.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Tony Bybell 1999.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#ifndef WAVE_ALLOCA_H
+#define WAVE_ALLOCA_H
+#include <stdlib.h>
+#ifdef HAVE_ALLOCA_H
+#include <alloca.h>
+#elif defined(__GNUC__)
+#ifndef __MINGW32__
+#ifndef alloca
+#define alloca __builtin_alloca
+#endif
+#else
+#include <malloc.h>
+#endif
+#elif defined(_MSC_VER)
+#include <malloc.h>
+#define alloca _alloca
+#endif
+#define wave_alloca alloca
+#endif
+

include/verilated.cpp

@@ -26,6 +26,11 @@
 #define _VERILATED_CPP_
 #include "verilated_imp.h"
 #include <cctype>
+#include <sys/stat.h>  // mkdir
+
+#if defined(WIN32) || defined(__MINGW32__)
+# include <direct.h>  // mkdir
+#endif
 
 #define VL_VALUE_STRING_MAX_WIDTH 8192	///< Max static char array for VL_VALUE_STRING
 
@@ -38,6 +43,7 @@ VerilatedVoidCb Verilated::s_flushCb = NULL;
 
 // Keep below together in one cache line
 Verilated::Serialized Verilated::s_s;
+Verilated::NonSerialized Verilated::s_ns;
 VL_THREAD_LOCAL Verilated::ThreadLocal Verilated::t_s;
 
 Verilated::CommandArgValues Verilated::s_args;
@@ -48,7 +54,7 @@ VerilatedImp VerilatedImp::s_s;
 // User definable functions
 
 #ifndef VL_USER_FINISH		// Define this to override this function
-void vl_finish (const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
+void vl_finish(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
     if (0 && hier) {}
     VL_PRINTF("- %s:%d: Verilog $finish\n", filename, linenum);  // Not VL_PRINTF_MT, already on main thread
     if (Verilated::gotFinish()) {
@@ -61,15 +67,15 @@ void vl_finish (const char* filename, int linenum, const char* hier) VL_MT_UNSAF
 #endif
 
 #ifndef VL_USER_STOP		// Define this to override this function
-void vl_stop (const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
+void vl_stop(const char* filename, int linenum, const char* hier) VL_MT_UNSAFE {
     Verilated::gotFinish(true);
     Verilated::flushCall();
-    vl_fatal (filename,linenum,hier,"Verilog $stop");
+    vl_fatal(filename,linenum,hier,"Verilog $stop");
 }
 #endif
 
 #ifndef VL_USER_FATAL	// Define this to override this function
-void vl_fatal (const char* filename, int linenum, const char* hier, const char* msg) VL_MT_UNSAFE {
+void vl_fatal(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_UNSAFE {
     if (0 && hier) {}
     Verilated::gotFinish(true);
     VL_PRINTF("%%Error: %s:%d: %s\n", filename, linenum, msg);  // Not VL_PRINTF_MT, already on main thread
@@ -84,7 +90,7 @@ void vl_fatal (const char* filename, int linenum, const char* hier, const char*
 //===========================================================================
 // Wrapper to call certain functions via messages when multithreaded
 
-void VL_FINISH_MT (const char* filename, int linenum, const char* hier) VL_MT_SAFE {
+void VL_FINISH_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE {
 #ifdef VL_THREADED
     VerilatedThreadMsgQueue::post(VerilatedMsg([=](){
 		vl_finish(filename, linenum, hier);
@@ -94,7 +100,7 @@ void VL_FINISH_MT (const char* filename, int linenum, const char* hier) VL_MT_SA
 #endif
 }
 
-void VL_STOP_MT (const char* filename, int linenum, const char* hier) VL_MT_SAFE {
+void VL_STOP_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE {
 #ifdef VL_THREADED
     VerilatedThreadMsgQueue::post(VerilatedMsg([=](){
 		vl_stop(filename, linenum, hier);
@@ -104,7 +110,7 @@ void VL_STOP_MT (const char* filename, int linenum, const char* hier) VL_MT_SAFE
 #endif
 }
 
-void VL_FATAL_MT (const char* filename, int linenum, const char* hier, const char* msg) VL_MT_SAFE {
+void VL_FATAL_MT(const char* filename, int linenum, const char* hier, const char* msg) VL_MT_SAFE {
 #ifdef VL_THREADED
     VerilatedThreadMsgQueue::post(VerilatedMsg([=](){
 		vl_fatal(filename, linenum, hier, msg);
@@ -196,28 +202,24 @@ Verilated::Serialized::Serialized() {
     s_fatalOnVpiError = true; // retains old default behaviour
 }
 
-//===========================================================================
-// Random reset -- Only called at init time, so don't inline.
-
-IData VL_RAND32() VL_MT_SAFE {
-#ifdef VL_THREADED
-    static VL_THREAD_LOCAL bool t_seeded = false;
-    static VL_THREAD_LOCAL drand48_data t_buffer;
-    static VerilatedMutex s_mutex;
-    if (VL_UNLIKELY(!t_seeded)) {
-	t_seeded = true;
-	long seedval;
-	{
-	    VerilatedLockGuard lock(s_mutex);
-	    seedval = lrand48()<<16 ^ lrand48();
-	    if (!seedval) seedval++;
-	}
-	srand48_r(seedval, &t_buffer);
+Verilated::NonSerialized::NonSerialized() {
+    s_profThreadsStart = 1;
+    s_profThreadsWindow = 2;
+    s_profThreadsFilenamep = strdup("profile_threads.dat");
+}
+Verilated::NonSerialized::~NonSerialized() {
+    if (s_profThreadsFilenamep) {
+        free(const_cast<char*>(s_profThreadsFilenamep)); s_profThreadsFilenamep=NULL;
     }
-    long v0; lrand48_r(&t_buffer, &v0);
-    long v1; lrand48_r(&t_buffer, &v1);
-    return (v0<<16) ^ v1;
-#elif defined(_WIN32) && !defined(__CYGWIN__)
+}
+
+//===========================================================================
+// Random -- Mostly called at init time, so not inline.
+
+static vluint32_t vl_sys_rand32() VL_MT_UNSAFE {
+    // Return random 32-bits using system library.
+    // Used only to construct seed for Verilator's PNRG.
+#if defined(_WIN32) && !defined(__CYGWIN__)
     // Windows doesn't have lrand48(), although Cygwin does.
     return (rand()<<16) ^ rand();
 #else
@@ -225,21 +227,46 @@ IData VL_RAND32() VL_MT_SAFE {
 #endif
 }
 
+vluint64_t vl_rand64() VL_MT_SAFE {
+    static VerilatedMutex s_mutex;
+    static VL_THREAD_LOCAL bool t_seeded = false;
+    static VL_THREAD_LOCAL vluint64_t t_state[2];
+    if (VL_UNLIKELY(!t_seeded)) {
+	t_seeded = true;
+	{
+            long seedval;
+	    VerilatedLockGuard lock(s_mutex);
+            t_state[0] = (((vluint64_t)vl_sys_rand32())<<32
+                          ^ ((vluint64_t)vl_sys_rand32()));
+            t_state[1] = (((vluint64_t)vl_sys_rand32())<<32
+                          ^ ((vluint64_t)vl_sys_rand32()));
+            // Fix state as algorithm is slow to randomize if many zeros
+            // This causes a loss of ~ 1 bit of seed entropy, no big deal
+            if (VL_COUNTONES_I(t_state[0]) < 10) t_state[0] = ~t_state[0];
+            if (VL_COUNTONES_I(t_state[1]) < 10) t_state[1] = ~t_state[1];
+	}
+    }
+    // Xoroshiro128+ algorithm
+    vluint64_t result = t_state[0] + t_state[1];
+    t_state[1] ^= t_state[0];
+    t_state[0] = (((t_state[0] << 55) | (t_state[0] >> 9))
+                  ^ t_state[1] ^ (t_state[1] << 14));
+    t_state[1] = (t_state[1] << 36) | (t_state[1] >> 28);
+    return result;
+}
+
 IData VL_RANDOM_I(int obits) VL_MT_SAFE {
-    return VL_RAND32() & VL_MASK_I(obits);
+    return vl_rand64() & VL_MASK_I(obits);
 }
-
 QData VL_RANDOM_Q(int obits) VL_MT_SAFE {
-    QData data = ((QData)VL_RAND32()<<VL_ULL(32)) | (QData)VL_RAND32();
-    return data & VL_MASK_Q(obits);
+    return vl_rand64() & VL_MASK_Q(obits);
 }
-
 WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) VL_MT_SAFE {
     for (int i=0; i<VL_WORDS_I(obits); ++i) {
 	if (i<(VL_WORDS_I(obits)-1)) {
-	    outwp[i] = VL_RAND32();
+	    outwp[i] = vl_rand64();
 	} else {
-	    outwp[i] = VL_RAND32() & VL_MASK_I(obits);
+	    outwp[i] = vl_rand64() & VL_MASK_I(obits);
 	}
     }
     return outwp;
@@ -254,7 +281,6 @@ IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
     if (obits<32) data &= VL_MASK_I(obits);
     return data;
 }
-
 QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
     if (Verilated::randReset()==0) return 0;
     QData data = VL_ULL(~0);
@@ -264,7 +290,6 @@ QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
     if (obits<64) data &= VL_MASK_Q(obits);
     return data;
 }
-
 WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE {
     for (int i=0; i<VL_WORDS_I(obits); ++i) {
 	if (i<(VL_WORDS_I(obits)-1)) {
@@ -1367,7 +1392,7 @@ void VL_READMEM_N(
     FILE* fp = fopen(ofilenamep.c_str(), "r");
     if (VL_UNLIKELY(!fp)) {
         // We don't report the Verilog source filename as it slow to have to pass it down
-        VL_FATAL_MT (ofilenamep.c_str(), 0, "", "$readmem file not found");
+        VL_FATAL_MT(ofilenamep.c_str(), 0, "", "$readmem file not found");
         return;
     }
     // Prep for reading
@@ -1414,8 +1439,8 @@ void VL_READMEM_N(
                     //printf(" Value width=%d  @%x = %c\n", width, addr, c);
                     if (VL_UNLIKELY(addr >= static_cast<IData>(depth+array_lsb)
                                     || addr < static_cast<IData>(array_lsb))) {
-                        VL_FATAL_MT (ofilenamep.c_str(), linenum, "",
-                                     "$readmem file address beyond bounds of array");
+                        VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
+                                    "$readmem file address beyond bounds of array");
                     } else {
                         int entry = addr - array_lsb;
                         QData shift = hex ? VL_ULL(4) : VL_ULL(1);
@@ -1444,15 +1469,15 @@ void VL_READMEM_N(
                             datap[0] |= value;
                         }
                         if (VL_UNLIKELY(value>=(1<<shift))) {
-                            VL_FATAL_MT (ofilenamep.c_str(), linenum, "",
-                                         "$readmemb (binary) file contains hex characters");
+                            VL_FATAL_MT(ofilenamep.c_str(), linenum, "",
+                                        "$readmemb (binary) file contains hex characters");
                         }
                     }
                 }
                 innum = true;
             }
             else {
-                VL_FATAL_MT (ofilenamep.c_str(), linenum, "", "$readmem file syntax error");
+                VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file syntax error");
             }
         }
         lastc = c;
@@ -1462,7 +1487,7 @@ void VL_READMEM_N(
     // Final checks
     fclose(fp);
     if (VL_UNLIKELY(end != VL_UL(0xffffffff) && addr != (end+1))) {
-        VL_FATAL_MT (ofilenamep.c_str(), linenum, "", "$readmem file ended before specified ending-address");
+        VL_FATAL_MT(ofilenamep.c_str(), linenum, "", "$readmem file ended before specified ending-address");
     }
 }
 
@@ -1648,6 +1673,20 @@ void Verilated::fatalOnVpiError(bool flag) VL_MT_SAFE {
     VerilatedLockGuard lock(m_mutex);
     s_s.s_fatalOnVpiError = flag;
 }
+void Verilated::profThreadsStart(vluint64_t flag) VL_MT_SAFE {
+    VerilatedLockGuard lock(m_mutex);
+    s_ns.s_profThreadsStart = flag;
+}
+void Verilated::profThreadsWindow(vluint64_t flag) VL_MT_SAFE {
+    VerilatedLockGuard lock(m_mutex);
+    s_ns.s_profThreadsWindow = flag;
+}
+void Verilated::profThreadsFilenamep(const char* flagp) VL_MT_SAFE {
+    VerilatedLockGuard lock(m_mutex);
+    if (s_ns.s_profThreadsFilenamep) free(const_cast<char*>(s_ns.s_profThreadsFilenamep));
+    s_ns.s_profThreadsFilenamep = strdup(flagp);
+}
+
 
 const char* Verilated::catName(const char* n1, const char* n2) VL_MT_SAFE {
     // Returns new'ed data
@@ -1684,7 +1723,7 @@ void Verilated::flushCall() VL_MT_SAFE {
 }
 
 void Verilated::commandArgs(int argc, const char** argv) VL_MT_SAFE {
-    VerilatedLockGuard lock(m_mutex);
+    VerilatedLockGuard lock(s_args.m_argMutex);
     s_args.argc = argc;
     s_args.argv = argv;
     VerilatedImp::commandArgs(argc,argv);
@@ -1707,6 +1746,14 @@ void Verilated::overWidthError(const char* signame) VL_MT_SAFE {
     VL_FATAL_MT("unknown",0,"", msg.c_str());
 }
 
+void Verilated::mkdir(const char* dirname) VL_MT_UNSAFE {
+#if defined(_WIN32) || defined(__MINGW32__)
+    ::mkdir(dirname);
+#else
+    ::mkdir(dirname, 0777);
+#endif
+}
+
 void Verilated::quiesce() VL_MT_SAFE {
 #ifdef VL_THREADED
     // Wait until all threads under this evaluation are quiet
@@ -1780,9 +1827,61 @@ void VerilatedImp::commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s
     if (!s_s.m_argVecLoaded) s_s.m_argVec.clear();
     for (int i=0; i<argc; ++i) {
         s_s.m_argVec.push_back(argv[i]);
+        commandArgVl(argv[i]);
     }
     s_s.m_argVecLoaded = true;  // Can't just test later for empty vector, no arguments is ok
 }
+void VerilatedImp::commandArgVl(const std::string& arg) {
+    if (0 == strncmp(arg.c_str(), "+verilator+", strlen("+verilator+"))) {
+        std::string value;
+        if (0) {
+        }
+        else if (arg == "+verilator+debug") {
+            Verilated::debug(4);
+        }
+        else if (commandArgVlValue(arg, "+verilator+debugi+", value/*ref*/)) {
+            Verilated::debug(atoi(value.c_str()));
+        }
+        else if (arg == "+verilator+help") {
+            versionDump();
+            VL_PRINTF_MT("For help, please see 'verilator --help'\n");
+            VL_FATAL_MT("COMMAND_LINE", 0, "", "Exiting due to command line argument (not an error)");
+        }
+        else if (commandArgVlValue(arg, "+verilator+prof+threads+start+", value/*ref*/)) {
+            Verilated::profThreadsStart(atoll(value.c_str()));
+        }
+        else if (commandArgVlValue(arg, "+verilator+prof+threads+window+", value/*ref*/)) {
+            Verilated::profThreadsWindow(atol(value.c_str()));
+        }
+        else if (commandArgVlValue(arg, "+verilator+prof+threads+file+", value/*ref*/)) {
+            Verilated::profThreadsFilenamep(value.c_str());
+        }
+        else if (commandArgVlValue(arg, "+verilator+rand+reset+", value/*ref*/)) {
+            Verilated::randReset(atoi(value.c_str()));
+        }
+        else if (arg == "+verilator+V") {
+            versionDump();  // Someday more info too
+            VL_FATAL_MT("COMMAND_LINE", 0, "", "Exiting due to command line argument (not an error)");
+        }
+        else if (arg == "+verilator+version") {
+            versionDump();
+            VL_FATAL_MT("COMMAND_LINE", 0, "", "Exiting due to command line argument (not an error)");
+        }
+        else {
+            VL_PRINTF_MT("%%Warning: Unknown +verilator runtime argument: '%s'\n", arg.c_str());
+        }
+    }
+}
+bool VerilatedImp::commandArgVlValue(const std::string& arg,
+                                     const std::string& prefix, std::string& valuer) {
+    size_t len = prefix.length();
+    if (0==strncmp(prefix.c_str(), arg.c_str(), len)) {
+        valuer = arg.substr(len);
+        return true;
+    } else {
+        return false;
+    }
+}
 
 //======================================================================
 // VerilatedSyms:: Methods
@@ -1907,7 +2006,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap,
     if (!finalize) return;
 
     if (!m_varsp) m_varsp = new VerilatedVarNameMap();
-    VerilatedVar var (namep, datap, vltype, (VerilatedVarFlags)vlflags, dims);
+    VerilatedVar var(namep, datap, vltype, (VerilatedVarFlags)vlflags, dims);
 
     va_list ap;
     va_start(ap,dims);

include/verilated.h

@@ -79,6 +79,8 @@ class VerilatedVar;
 class VerilatedVarNameMap;
 class VerilatedVcd;
 class VerilatedVcdC;
+class VerilatedLxt2;
+class VerilatedLxt2C;
 
 enum VerilatedVarType {
     VLVT_UNKNOWN=0,
@@ -120,6 +122,7 @@ class VL_CAPABILITY("mutex") VerilatedMutex {
   public:
     VerilatedMutex() {}
     ~VerilatedMutex() {}
+    const VerilatedMutex& operator!() const { return *this; }  // For -fthread_safety
     /// Acquire/lock mutex
     void lock() VL_ACQUIRE() {
         // Try to acquire the lock by spinning.  If the wait is short,
@@ -327,7 +330,7 @@ public:  // But internals only - called from VerilatedModule's
 class Verilated {
     // MEMBERS
     // Slow path variables
-    static VerilatedMutex m_mutex;  ///< Mutex for all static members, when VL_THREADED
+    static VerilatedMutex m_mutex;  ///< Mutex for s_s/s_ns members, when VL_THREADED
 
     static VerilatedVoidCb  s_flushCb;		///< Flush callback function
 
@@ -344,9 +347,21 @@ class Verilated {
         ~Serialized() {}
     } s_s;
 
+    static struct NonSerialized {  // Non-serialized information
+        // These are reloaded from on command-line settings, so do not need to persist
+        // Fast path
+        vluint64_t s_profThreadsStart;  ///< +prof+threads starting time
+        vluint32_t s_profThreadsWindow;  ///< +prof+threads window size
+        // Slow path
+        const char* s_profThreadsFilenamep;  ///< +prof+threads filename
+        NonSerialized();
+        ~NonSerialized();
+    } s_ns;
+
     // no need to be save-restored (serialized) the
     // assumption is that the restore is allowed to pass different arguments
     static struct CommandArgValues {
+        VerilatedMutex m_argMutex;  ///< Mutex for s_args members, when VL_THREADED
 	int          argc;
 	const char** argv;
         CommandArgValues() : argc(0), argv(NULL) {}
@@ -408,6 +423,14 @@ public:
     /// Enable/disable vpi fatal
     static void fatalOnVpiError(bool flag) VL_MT_SAFE;
     static bool fatalOnVpiError() VL_MT_SAFE { return s_s.s_fatalOnVpiError; }
+    /// --prof-threads related settings
+    static void profThreadsStart(vluint64_t flag) VL_MT_SAFE;
+    static vluint64_t profThreadsStart() VL_MT_SAFE { return s_ns.s_profThreadsStart; }
+    static void profThreadsWindow(vluint64_t flag) VL_MT_SAFE;
+    static vluint32_t profThreadsWindow() VL_MT_SAFE { return s_ns.s_profThreadsWindow; }
+    static void profThreadsFilenamep(const char* flagp) VL_MT_SAFE;
+    static const char* profThreadsFilenamep() VL_MT_SAFE { return s_ns.s_profThreadsFilenamep; }
+
     /// Flush callback for VCD waves
     static void flushCb(VerilatedVoidCb cb) VL_MT_SAFE;
     static void flushCall() VL_MT_SAFE;
@@ -425,6 +448,9 @@ public:
     static const char* productName() VL_PURE { return VERILATOR_PRODUCT; }
     static const char* productVersion() VL_PURE { return VERILATOR_VERSION; }
 
+    /// Convenience OS utilities
+    static void mkdir(const char* dirname) VL_MT_UNSAFE;
+
     /// When multithreaded, quiesce the model to prepare for trace/saves/coverage
     /// This may only be called when no locks are held.
     static void quiesce() VL_MT_SAFE;
@@ -499,31 +525,31 @@ private:
 /// User code may wish to replace this function, to do so, define VL_USER_FINISH.
 /// This code does not have to be thread safe.
 /// Verilator internal code must call VL_FINISH_MT instead, which eventually calls this.
-extern void vl_finish (const char* filename, int linenum, const char* hier);
+extern void vl_finish(const char* filename, int linenum, const char* hier);
 
 /// Routine to call for $stop
 /// User code may wish to replace this function, to do so, define VL_USER_STOP.
 /// This code does not have to be thread safe.
 /// Verilator internal code must call VL_FINISH_MT instead, which eventually calls this.
-extern void vl_stop   (const char* filename, int linenum, const char* hier);
+extern void vl_stop(const char* filename, int linenum, const char* hier);
 
 /// Routine to call for a couple of fatal messages
 /// User code may wish to replace this function, to do so, define VL_USER_FATAL.
 /// This code does not have to be thread safe.
 /// Verilator internal code must call VL_FINISH_MT instead, which eventually calls this.
-extern void vl_fatal  (const char* filename, int linenum, const char* hier,
-		       const char* msg);
+extern void vl_fatal(const char* filename, int linenum, const char* hier,
+                     const char* msg);
 
 //=========================================================================
 // Extern functions -- Slow path
 
 /// Multithread safe wrapper for calls to $finish
-extern void VL_FINISH_MT (const char* filename, int linenum, const char* hier) VL_MT_SAFE;
+extern void VL_FINISH_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE;
 /// Multithread safe wrapper for calls to $stop
-extern void VL_STOP_MT   (const char* filename, int linenum, const char* hier) VL_MT_SAFE;
+extern void VL_STOP_MT(const char* filename, int linenum, const char* hier) VL_MT_SAFE;
 /// Multithread safe wrapper to call for a couple of fatal messages
-extern void VL_FATAL_MT  (const char* filename, int linenum, const char* hier,
-			  const char* msg) VL_MT_SAFE;
+extern void VL_FATAL_MT(const char* filename, int linenum, const char* hier,
+                        const char* msg) VL_MT_SAFE;
 
 /// Print a string, multithread safe. Eventually VL_PRINTF will get called.
 #ifdef VL_THREADED

include/verilated.mk.in

@@ -24,6 +24,8 @@ CFG_CXXFLAGS_STD_OLDEST = @CFG_CXXFLAGS_STD_OLDEST@
 CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
 # Compiler flags that turn on extra warnings
 CFG_CXXFLAGS_WEXTRA = @CFG_CXXFLAGS_WEXTRA@
+# Linker libraries for multithreading
+CFG_LDLIBS_THREADS = @CFG_LDLIBS_THREADS@
 
 ######################################################################
 # Programs
@@ -116,6 +118,7 @@ ifneq ($(VM_THREADS),0)
  ifneq ($(VM_THREADS),)
   # Need C++11 at least, so always default to newest
   CPPFLAGS += -DVL_THREADED $(CFG_CXXFLAGS_STD_NEWEST)
+  LDLIBS += $(CFG_LDLIBS_THREADS)
  endif
 endif
 

include/verilated_cov.cpp

@@ -261,18 +261,18 @@ public:
     }
 
     // We assume there's always call to i/f/p in that order
-    void inserti (VerilatedCovImpItem* itemp) VL_EXCLUDES(m_mutex) {
+    void inserti(VerilatedCovImpItem* itemp) VL_EXCLUDES(m_mutex) {
 	VerilatedLockGuard lock(m_mutex);
 	assert(!m_insertp);
  	m_insertp = itemp;
     }
-    void insertf (const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
+    void insertf(const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
 	VerilatedLockGuard lock(m_mutex);
 	m_insertFilenamep = filenamep;
 	m_insertLineno = lineno;
     }
-    void insertp (const char* ckeyps[MAX_KEYS],
-		  const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
+    void insertp(const char* ckeyps[MAX_KEYS],
+                 const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
 	VerilatedLockGuard lock(m_mutex);
 	assert(m_insertp);
 	// First two key/vals are filename
@@ -334,7 +334,7 @@ public:
 #endif
 	selftest();
 
-	std::ofstream os (filename);
+        std::ofstream os(filename);
 	if (os.fail()) {
 	    std::string msg = std::string("%Error: Can't write '")+filename+"'";
 	    VL_FATAL_MT("",0,"",msg.c_str());
@@ -427,9 +427,9 @@ void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
 #define A(n) const char* key ## n, const char* val ## n		// Argument list
 #define C(n) key ## n, val ## n	// Calling argument list
 #define N(n) "",""	// Null argument list
-void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
-			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
-			     A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
+void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
+                            A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
+                            A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
     const char* keyps[VerilatedCovImpBase::MAX_KEYS]
 	= {NULL,NULL,NULL,	// filename,lineno,page
 	   key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
@@ -444,20 +444,20 @@ void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
 }
 
 // And versions with fewer arguments  (oh for a language with named parameters!)
-void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) VL_MT_SAFE {
+void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) VL_MT_SAFE {
     _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
 	     N(10),N(11),N(12),N(13),N(14),N(15),N(16),N(17),N(18),N(19),
 	     N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
 }
-void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
-			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) VL_MT_SAFE {
+void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
+                            A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) VL_MT_SAFE {
     _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
 	     C(10),C(11),C(12),C(13),C(14),C(15),C(16),C(17),C(18),C(19),
 	     N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
 }
 // Backward compatibility for Verilator
-void VerilatedCov::_insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
-			     K(4),const std::string& val4,  A(5),A(6)) VL_MT_SAFE {
+void VerilatedCov::_insertp(A(0), A(1),  K(2),int val2,  K(3),int val3,
+                            K(4),const std::string& val4,  A(5),A(6)) VL_MT_SAFE {
     std::string val2str = vlCovCvtToStr(val2);
     std::string val3str = vlCovCvtToStr(val3);
     _insertp(C(0),C(1),

include/verilated_cov.h

@@ -73,7 +73,7 @@
 //=============================================================================
 /// Convert VL_COVER_INSERT value arguments to strings
 
-template< class T> std::string vlCovCvtToStr (const T& t) VL_PURE {
+template< class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
     std::ostringstream os; os<<t; return os.str();
 }
 
@@ -91,16 +91,16 @@ public:
     /// Return default filename
     static const char* defaultFilename() VL_PURE { return "coverage.dat"; }
     /// Write all coverage data to a file
-    static void write (const char* filenamep = defaultFilename()) VL_MT_SAFE;
+    static void write(const char* filenamep = defaultFilename()) VL_MT_SAFE;
     /// Insert a coverage item
     /// We accept from 1-30 key/value pairs, all as strings.
     /// Call _insert1, followed by _insert2 and _insert3
     /// Do not call directly; use VL_COVER_INSERT or higher level macros instead
     // _insert1: Remember item pointer with count.  (Not const, as may add zeroing function)
-    static void _inserti (vluint32_t* itemp) VL_MT_SAFE;
-    static void _inserti (vluint64_t* itemp) VL_MT_SAFE;
+    static void _inserti(vluint32_t* itemp) VL_MT_SAFE;
+    static void _inserti(vluint64_t* itemp) VL_MT_SAFE;
     // _insert2: Set default filename and line number
-    static void _insertf (const char* filename, int lineno) VL_MT_SAFE;
+    static void _insertf(const char* filename, int lineno) VL_MT_SAFE;
     // _insert3: Set parameters
     // We could have just the maximum argument version, but this compiles
     // much slower (nearly 2x) than having smaller versions also.  However
@@ -108,15 +108,15 @@ public:
 #define K(n) const char* key ## n
 #define A(n) const char* key ## n, const char* valp ## n	// Argument list
 #define D(n) const char* key ## n = NULL, const char* valp ## n = NULL	// Argument list
-    static void _insertp (D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
-    static void _insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
-			  ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
-    static void _insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
-			  ,A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)
-			  ,A(20),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
+    static void _insertp(D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
+    static void _insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
+                         ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
+    static void _insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
+                         ,A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)
+                         ,A(20),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
     // Backward compatibility for Verilator
-    static void _insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
-			  K(4),const std::string& val4,  A(5),A(6));
+    static void _insertp(A(0), A(1),  K(2),int val2,  K(3),int val3,
+                         K(4),const std::string& val4,  A(5),A(6));
 
 #undef K
 #undef A
@@ -124,7 +124,7 @@ public:
     /// Clear coverage points (and call delete on all items)
     static void clear() VL_MT_SAFE;
     /// Clear items not matching the provided string
-    static void clearNonMatch (const char* matchp) VL_MT_SAFE;
+    static void clearNonMatch(const char* matchp) VL_MT_SAFE;
     /// Zero coverage points
     static void zero() VL_MT_SAFE;
 };

include/verilated_cov_key.h

@@ -104,39 +104,39 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 class VerilatedCovKey {
 public:
     static std::string shortKey(const std::string& key) VL_PURE {
-	// VLCOVGEN_SHORT_AUTO_EDIT_BEGIN
-	if (key == "col0") return VL_CIK_COL0;
-	if (key == "col0_name") return VL_CIK_COL0_NAME;
-	if (key == "col1") return VL_CIK_COL1;
-	if (key == "col1_name") return VL_CIK_COL1_NAME;
-	if (key == "col2") return VL_CIK_COL2;
-	if (key == "col2_name") return VL_CIK_COL2_NAME;
-	if (key == "col3") return VL_CIK_COL3;
-	if (key == "col3_name") return VL_CIK_COL3_NAME;
-	if (key == "column") return VL_CIK_COLUMN;
-	if (key == "comment") return VL_CIK_COMMENT;
-	if (key == "filename") return VL_CIK_FILENAME;
-	if (key == "groupcmt") return VL_CIK_GROUPCMT;
-	if (key == "groupdesc") return VL_CIK_GROUPDESC;
-	if (key == "groupname") return VL_CIK_GROUPNAME;
-	if (key == "hier") return VL_CIK_HIER;
-	if (key == "limit") return VL_CIK_LIMIT;
-	if (key == "lineno") return VL_CIK_LINENO;
-	if (key == "per_instance") return VL_CIK_PER_INSTANCE;
-	if (key == "row0") return VL_CIK_ROW0;
-	if (key == "row0_name") return VL_CIK_ROW0_NAME;
-	if (key == "row1") return VL_CIK_ROW1;
-	if (key == "row1_name") return VL_CIK_ROW1_NAME;
-	if (key == "row2") return VL_CIK_ROW2;
-	if (key == "row2_name") return VL_CIK_ROW2_NAME;
-	if (key == "row3") return VL_CIK_ROW3;
-	if (key == "row3_name") return VL_CIK_ROW3_NAME;
-	if (key == "table") return VL_CIK_TABLE;
-	if (key == "thresh") return VL_CIK_THRESH;
-	if (key == "type") return VL_CIK_TYPE;
-	if (key == "weight") return VL_CIK_WEIGHT;
-	// VLCOVGEN_SHORT_AUTO_EDIT_END
-	return key;
+        // VLCOVGEN_SHORT_AUTO_EDIT_BEGIN
+        if (key == "col0") return VL_CIK_COL0;
+        if (key == "col0_name") return VL_CIK_COL0_NAME;
+        if (key == "col1") return VL_CIK_COL1;
+        if (key == "col1_name") return VL_CIK_COL1_NAME;
+        if (key == "col2") return VL_CIK_COL2;
+        if (key == "col2_name") return VL_CIK_COL2_NAME;
+        if (key == "col3") return VL_CIK_COL3;
+        if (key == "col3_name") return VL_CIK_COL3_NAME;
+        if (key == "column") return VL_CIK_COLUMN;
+        if (key == "comment") return VL_CIK_COMMENT;
+        if (key == "filename") return VL_CIK_FILENAME;
+        if (key == "groupcmt") return VL_CIK_GROUPCMT;
+        if (key == "groupdesc") return VL_CIK_GROUPDESC;
+        if (key == "groupname") return VL_CIK_GROUPNAME;
+        if (key == "hier") return VL_CIK_HIER;
+        if (key == "limit") return VL_CIK_LIMIT;
+        if (key == "lineno") return VL_CIK_LINENO;
+        if (key == "per_instance") return VL_CIK_PER_INSTANCE;
+        if (key == "row0") return VL_CIK_ROW0;
+        if (key == "row0_name") return VL_CIK_ROW0_NAME;
+        if (key == "row1") return VL_CIK_ROW1;
+        if (key == "row1_name") return VL_CIK_ROW1_NAME;
+        if (key == "row2") return VL_CIK_ROW2;
+        if (key == "row2_name") return VL_CIK_ROW2_NAME;
+        if (key == "row3") return VL_CIK_ROW3;
+        if (key == "row3_name") return VL_CIK_ROW3_NAME;
+        if (key == "table") return VL_CIK_TABLE;
+        if (key == "thresh") return VL_CIK_THRESH;
+        if (key == "type") return VL_CIK_TYPE;
+        if (key == "weight") return VL_CIK_WEIGHT;
+        // VLCOVGEN_SHORT_AUTO_EDIT_END
+        return key;
     }
 };
 

include/verilated_imp.h

@@ -239,6 +239,9 @@ public:
     }
 private:
     static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex);
+    static void commandArgVl(const std::string& arg);
+    static bool commandArgVlValue(const std::string& arg,
+                                  const std::string& prefix, std::string& valuer);
 
 public:
     // METHODS - user scope tracking

include/verilated_lxt2_c.cpp

@@ -0,0 +1,179 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2018 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.
+//
+// This 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.
+//
+//=============================================================================
+///
+/// \file
+/// \brief C++ Tracing in LXT2 Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_lxt2_c.h"
+// Include the GTKWave implementation directly
+#include "lxt2/lxt2_write.cpp"
+
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cerrno>
+#include <ctime>
+#include <algorithm>
+#include <sstream>
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
+//=============================================================================
+
+class VerilatedLxt2CallInfo {
+protected:
+    friend class VerilatedLxt2;
+    VerilatedLxt2Callback_t m_initcb;  ///< Initialization Callback function
+    VerilatedLxt2Callback_t m_fullcb;  ///< Full Dumping Callback function
+    VerilatedLxt2Callback_t m_changecb;  ///< Incremental Dumping Callback function
+    void* m_userthis;  ///< Fake "this" for caller
+    vluint32_t m_code;  ///< Starting code number
+    // CONSTRUCTORS
+    VerilatedLxt2CallInfo (VerilatedLxt2Callback_t icb, VerilatedLxt2Callback_t fcb,
+                           VerilatedLxt2Callback_t changecb,
+                           void* ut, vluint32_t code)
+        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+    ~VerilatedLxt2CallInfo() {}
+};
+
+//=============================================================================
+// VerilatedLxt2
+
+VerilatedLxt2::VerilatedLxt2(lxt2_wr_trace* lxt2)
+    : m_lxt2(lxt2),
+      m_fullDump(true),
+      m_scopeEscape('.') {}
+
+void VerilatedLxt2::open(const char* filename) VL_MT_UNSAFE {
+    m_assertOne.check();
+    m_lxt2 = lxt2_wr_init(filename);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
+        VerilatedLxt2CallInfo* cip = m_callbacks[ent];
+        cip->m_code = 1;
+        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
+    }
+}
+
+void VerilatedLxt2::module(const std::string& name) {
+    m_module = name;
+}
+
+//=============================================================================
+// Decl
+
+void VerilatedLxt2::declSymbol(vluint32_t code, const char* name, int arraynum, int msb, int lsb, int flags) {
+    if (msb == 0 && lsb == 0) {
+        msb = lsb = -1;
+    }
+    std::pair<Code2SymbolType::iterator, bool> p
+        = m_code2symbol.insert(std::make_pair(code, (lxt2_wr_symbol*)(NULL)));
+    std::stringstream name_ss;
+    name_ss <<m_module<<"."<<name;
+    if (arraynum >= 0) {
+        name_ss <<"("<<arraynum<<")";
+    }
+    std::string name_s = name_ss.str();
+    for (std::string::iterator it = name_s.begin(); it != name_s.end(); ++it) {
+        if (isScopeEscape(*it)) {
+            *it = '.';
+        }
+    }
+    if (p.second) {  // New
+        p.first->second = lxt2_wr_symbol_add(m_lxt2, name_s.c_str(), 0, msb, lsb, flags);
+        assert(p.first->second);
+    } else {  // Alias
+        lxt2_wr_symbol_alias(m_lxt2, p.first->second->name, name_s.c_str(), msb, lsb);
+    }
+}
+
+//=============================================================================
+// Callbacks
+
+void VerilatedLxt2::addCallback(
+    VerilatedLxt2Callback_t initcb, VerilatedLxt2Callback_t fullcb,
+    VerilatedLxt2Callback_t changecb, void* userthis) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
+    if (VL_UNLIKELY(isOpen())) {
+        std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
+        VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
+    }
+    VerilatedLxt2CallInfo* vci = new VerilatedLxt2CallInfo(initcb, fullcb, changecb, userthis, 1);
+    m_callbacks.push_back(vci);
+}
+
+//=============================================================================
+// Dumping
+
+void VerilatedLxt2::dump(vluint64_t timeui) {
+    if (!isOpen()) return;
+    if (VL_UNLIKELY(m_fullDump)) {
+        m_fullDump = false;  // No need for more full dumps
+        for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
+            VerilatedLxt2CallInfo* cip = m_callbacks[ent];
+            (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
+        }
+        return;
+    }
+    lxt2_wr_set_time64(m_lxt2, timeui);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedLxt2CallInfo* cip = m_callbacks[ent];
+        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
+    }
+}
+
+//=============================================================================
+// Helpers
+
+char* VerilatedLxt2::quad2Str(vluint64_t newval, int bits) {
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int i = 0; i < bits; ++i) {
+        *s = '0' + ((newval>>(bits-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+char* VerilatedLxt2::array2Str(const vluint32_t* newval, int bits) {
+    int bq = bits/32, br = bits%32;
+    m_valueStrBuffer.resize(bits+1);
+    char* s = m_valueStrBuffer.data();
+    for (int w = bq-1; w >= 0; --w) {
+        for (int i = 0; i < 32; ++i) {
+            *s = '0' + ((newval[w]>>(32-i-1))&1);
+            ++s;
+        }
+    }
+    for (int i = 0; i < br; ++i) {
+        *s = '0' + ((newval[bq]>>(br-i-1))&1);
+        ++s;
+    }
+    *s = '\0';
+    return m_valueStrBuffer.data();
+}
+
+//********************************************************************
+// Local Variables:
+// End:

include/verilated_lxt2_c.h

@@ -0,0 +1,204 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2018 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.
+//
+// This 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.
+//
+//=============================================================================
+///
+/// \file
+/// \brief C++ Tracing in LXT2 Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_LXT2_C_H_
+#define _VERILATED_LXT2_C_H_ 1
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "lxt2/lxt2_write.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+class VerilatedLxt2;
+class VerilatedLxt2CallInfo;
+typedef void (*VerilatedLxt2Callback_t)(VerilatedLxt2* vcdp, void* userthis, vluint32_t code);
+
+//=============================================================================
+// VerilatedLxt2
+/// Base class to create a Verilator LXT2 dump
+/// This is an internally used class - see VerilatedLxt2C for what to call from applications
+
+class VerilatedLxt2 {
+    typedef std::map<vluint32_t, lxt2_wr_symbol*> Code2SymbolType;
+    typedef std::vector<VerilatedLxt2CallInfo*> CallbackVec;
+private:
+    lxt2_wr_trace* m_lxt2;
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
+    bool m_fullDump;
+    char m_scopeEscape;
+    std::string m_module;
+    CallbackVec m_callbacks;  ///< Routines to perform dumping
+    Code2SymbolType m_code2symbol;
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedLxt2);
+    void declSymbol(vluint32_t code, const char* name, int arraynum, int msb, int lsb, int flags);
+    // helpers
+    std::vector<char> m_valueStrBuffer;
+    char* quad2Str(vluint64_t newval, int bits);
+    char* array2Str(const vluint32_t *newval, int bits);
+public:
+    explicit VerilatedLxt2(lxt2_wr_trace* lxt2=NULL);
+    ~VerilatedLxt2() { if (m_lxt2 == NULL) { lxt2_wr_close(m_lxt2); } }
+    bool isOpen() const { return m_lxt2 != NULL; }
+    void open(const char* filename) VL_MT_UNSAFE;
+    void flush() VL_MT_UNSAFE { lxt2_wr_flush(m_lxt2); }
+    void close() VL_MT_UNSAFE {
+        m_assertOne.check();
+        lxt2_wr_close(m_lxt2);
+        m_lxt2 = NULL;
+    }
+    // void set_time_unit(const char* unit); ///< Set time units (s/ms, defaults to ns)
+    // void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+
+    // void set_time_resolution(const char* unit); ///< Set time resolution (s/ms, defaults to ns)
+    // void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
+    // double timescaleToDouble(const char* unitp);
+    // std::string doubleToTimescale(double value);
+
+    /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
+    void scopeEscape(char flag) { m_scopeEscape = flag; }
+    /// Is this an escape?
+    bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }
+    /// Inside dumping routines, called each cycle to make the dump
+    void dump(vluint64_t timeui);
+    /// Inside dumping routines, declare callbacks for tracings
+    void addCallback(VerilatedLxt2Callback_t init, VerilatedLxt2Callback_t full,
+                     VerilatedLxt2Callback_t change,
+                     void* userthis) VL_MT_UNSAFE_ONE;
+
+    /// Inside dumping routines, declare a module
+    void module(const std::string& name);
+    /// Inside dumping routines, declare a signal
+    void declBit(vluint32_t code, const char* name, int arraynum) {
+        this->declSymbol(code, name, arraynum, 0, 0, LXT2_WR_SYM_F_BITS);
+    }
+    void declBus(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
+        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+    }
+    void declDouble(vluint32_t code, const char* name, int arraynum) {
+        this->declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
+    }
+    void declFloat(vluint32_t code, const char* name, int arraynum) {
+        this->declSymbol(code, name, arraynum, 63, 0, LXT2_WR_SYM_F_DOUBLE);
+    }
+    void declQuad(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
+        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+    }
+    void declArray(vluint32_t code, const char* name, int arraynum, int msb, int lsb) {
+        this->declSymbol(code, name, arraynum, msb, lsb, LXT2_WR_SYM_F_BITS);
+    }
+
+    /// Inside dumping routines, dump one signal if it has changed
+    void chgBit(vluint32_t code, const vluint32_t newval) {
+        lxt2_wr_emit_value_int(m_lxt2, m_code2symbol[code], 0, newval);
+    }
+    void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
+        lxt2_wr_emit_value_int(m_lxt2, m_code2symbol[code], 0, newval);
+    }
+    void chgDouble(vluint32_t code, const double newval) {
+        lxt2_wr_emit_value_double(m_lxt2, m_code2symbol[code], 0, newval);
+    }
+    void chgFloat(vluint32_t code, const float newval) {
+        lxt2_wr_emit_value_double(m_lxt2, m_code2symbol[code], 0, newval);
+    }
+    void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        lxt2_wr_emit_value_bit_string(m_lxt2, m_code2symbol[code], 0, quad2Str(newval, bits));
+    }
+    void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        lxt2_wr_emit_value_bit_string(m_lxt2, m_code2symbol[code], 0, array2Str(newval, bits));
+    }
+
+    void fullBit(vluint32_t code, const vluint32_t newval) { chgBit(code, newval); }
+    void fullBus(vluint32_t code, const vluint32_t newval, int bits) { chgBus(code, newval, bits); }
+    void fullDouble(vluint32_t code, const double newval) { chgDouble(code, newval); }
+    void fullFloat(vluint32_t code, const float newval) { chgFloat(code, newval); }
+    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) { chgQuad(code, newval, bits); }
+    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) { chgArray(code, newval, bits); }
+
+    void declTriBit   (vluint32_t code, const char* name, int arraynum);
+    void declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+    void fullBitX(vluint32_t code);
+    void fullBusX(vluint32_t code, int bits);
+    void fullQuadX(vluint32_t code, int bits);
+    void fullArrayX(vluint32_t code, int bits);
+    void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
+    void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
+    void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
+    void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+};
+
+//=============================================================================
+// VerilatedLxt2C
+/// Create a LXT2 dump file in C standalone (no SystemC) simulations.
+/// Also derived for use in SystemC simulations.
+/// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
+
+class VerilatedLxt2C {
+    VerilatedLxt2 m_sptrace;  ///< Trace file being created
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedLxt2C);
+public:
+    explicit VerilatedLxt2C(lxt2_wr_trace* filep=NULL) : m_sptrace(filep) {}
+    ~VerilatedLxt2C() {}
+public:
+    // ACCESSORS
+    /// Is file open?
+    bool isOpen() const { return m_sptrace.isOpen(); }
+    // METHODS
+    /// Open a new LXT2 file
+    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
+    /// Close dump
+    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
+    /// Flush dump
+    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
+    /// Write one cycle of dump data
+    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
+    /// Write one cycle of dump data - backward compatible and to reduce
+    /// conversion warnings.  It's better to use a vluint64_t time instead.
+    void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    /// Set time units (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_unit(const char* unit) { /* TODO */ }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Set time resolution (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_resolution(const char* unit) { /* TODO */ }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+
+    /// Internal class access
+    inline VerilatedLxt2* spTrace() { return &m_sptrace; };
+};
+
+#endif  // guard

include/verilated_save.cpp

@@ -48,7 +48,7 @@ static const char* const VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last by
 //=============================================================================
 // Searalization
 
-bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
     bufferCheck();
     const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
     vluint8_t miss = 0;
@@ -58,7 +58,7 @@ bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t siz
     return (miss!=0);
 }
 
-VerilatedDeserialize& VerilatedDeserialize::readAssert (const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(readDiffers(datap,size))) {
 	std::string fn = filename();
 	std::string msg = std::string("Can't deserialize save-restore file as was made from different model");
@@ -119,8 +119,8 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
 	assert(0);	// Not supported yet.
     } else {
 	// cppcheck-suppress duplicateExpression
-	m_fd = ::open (filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
-		       , 0666);
+        m_fd = ::open(filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
+                      , 0666);
 	if (m_fd<0) {
 	    // User code can check isOpen()
 	    m_isOpen = false;
@@ -142,8 +142,8 @@ void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
 	assert(0);	// Not supported yet.
     } else {
 	// cppcheck-suppress duplicateExpression
-	m_fd = ::open (filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
-		       , 0666);
+        m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
+                      , 0666);
 	if (m_fd<0) {
 	    // User code can check isOpen()
 	    m_isOpen = false;
@@ -184,7 +184,7 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
 	ssize_t remaining = (m_cp - wp);
 	if (remaining==0) break;
 	errno = 0;
-	ssize_t got = ::write (m_fd, wp, remaining);
+        ssize_t got = ::write(m_fd, wp, remaining);
 	if (got>0) {
 	    wp += got;
 	} else if (got < 0) {
@@ -213,7 +213,7 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
 	ssize_t remaining = (m_bufp+bufferSize() - m_endp);
 	if (remaining==0) break;
 	errno = 0;
-	ssize_t got = ::read (m_fd, m_endp, remaining);
+        ssize_t got = ::read(m_fd, m_endp, remaining);
 	if (got>0) {
 	    m_endp += got;
 	} else if (got < 0) {

include/verilated_threads.cpp

@@ -0,0 +1,229 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2012-2018 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.
+//
+// This 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.
+//
+//=============================================================================
+///
+/// \file
+/// \brief Thread pool for verilated modules
+///
+//=============================================================================
+
+#include "verilatedos.h"
+#include "verilated_threads.h"
+#include <cstdio>
+
+std::atomic<vluint64_t> VlNotification::s_yields;
+
+VL_THREAD_LOCAL VlThreadPool::ProfileTrace* VlThreadPool::t_profilep = NULL;
+
+//=============================================================================
+// VlMTaskVertex
+
+VlMTaskVertex::VlMTaskVertex(vluint32_t upstreamDepCount)
+    : m_upstreamDepsDone(0),
+      m_upstreamDepCount(upstreamDepCount) {
+    assert(atomic_is_lock_free(&m_upstreamDepsDone));
+}
+
+//=============================================================================
+// VlWorkerThread
+
+VlWorkerThread::VlWorkerThread(VlThreadPool* poolp, bool profiling)
+    : m_poolp(poolp)
+    , m_profiling(profiling)
+    , m_exiting(false)
+      // Must init this last -- after setting up fields that it might read:
+    , m_cthread(startWorker, this) {}
+
+VlWorkerThread::~VlWorkerThread() {
+    m_exiting.store(true, std::memory_order_release);
+    {
+        VerilatedLockGuard lk(m_mutex);
+        if (sleeping()) {
+            wakeUp();
+        }
+    }
+    // The thread should exit; join it.
+    m_cthread.join();
+}
+
+void VlWorkerThread::workerLoop() {
+    if (VL_UNLIKELY(m_profiling)) {
+        m_poolp->setupProfilingClientThread();
+    }
+
+    VlNotification alarm;
+    ExecRec work;
+    work.m_fnp = NULL;
+
+    while (1) {
+        bool sleep = false;
+        if (VL_UNLIKELY(!work.m_fnp)) {
+            // Look for work
+            VerilatedLockGuard lk(m_mutex);
+            if (VL_LIKELY(!m_ready.empty())) {
+                dequeWork(&work);
+            } else {
+                // No work available, prepare to sleep. Pass alarm/work
+                // into m_sleepAlarm so wakeUp will tall this function.
+                //
+                // Must modify m_sleepAlarm in the same critical section as
+                // the check for ready work, otherwise we could race with
+                // another thread enqueueing work and never be awoken.
+                m_sleepAlarm.first = &alarm;
+                m_sleepAlarm.second = &work;
+                sleep = true;
+            }
+        }
+
+        // Do this here, not above, to avoid a race with the destructor.
+        if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire)))
+            break;
+
+        if (VL_UNLIKELY(sleep)) {
+            alarm.waitForNotification();  // ZZZzzzzz
+            alarm.reset();
+        }
+        if (VL_LIKELY(work.m_fnp)) {
+            work.m_fnp(work.m_evenCycle, work.m_sym);
+            work.m_fnp = NULL;
+        }
+    }
+
+    if (VL_UNLIKELY(m_profiling)) {
+        m_poolp->tearDownProfilingClientThread();
+    }
+}
+
+void VlWorkerThread::startWorker(VlWorkerThread* workerp) {
+    workerp->workerLoop();
+}
+
+//=============================================================================
+// VlThreadPool
+
+VlThreadPool::VlThreadPool(int nThreads, bool profiling)
+    : m_profiling(profiling) {
+    // --threads N passes nThreads=N-1, as the "main" threads counts as 1
+    unsigned cpus = std::thread::hardware_concurrency();
+    if (cpus < nThreads+1) {
+        VL_PRINTF_MT("%%Warning: System has %u CPUs but model Verilated with"
+                     " --threads %d; may run slow.\n", cpus, nThreads+1);
+    }
+    // Create'em
+    for (int i=0; i<nThreads; ++i) {
+        m_workers.push_back(new VlWorkerThread(this, profiling));
+    }
+    // Set up a profile buffer for the current thread too -- on the
+    // assumption that it's the same thread that calls eval and may be
+    // donated to run mtasks during the eval.
+    if (VL_UNLIKELY(m_profiling)) {
+        setupProfilingClientThread();
+    }
+}
+
+VlThreadPool::~VlThreadPool() {
+    for (int i = 0; i < m_workers.size(); ++i) {
+        // Each ~WorkerThread will wait for its thread to exit.
+        delete m_workers[i];
+    }
+    if (VL_UNLIKELY(m_profiling)) {
+        tearDownProfilingClientThread();
+    }
+}
+
+void VlThreadPool::tearDownProfilingClientThread() {
+    assert(t_profilep);
+    delete t_profilep;
+    t_profilep = NULL;
+}
+
+void VlThreadPool::setupProfilingClientThread() {
+    assert(!t_profilep);
+    t_profilep = new ProfileTrace;
+    // Reserve some space in the thread-local profiling buffer;
+    // try not to malloc while collecting profiling.
+    t_profilep->reserve(4096);
+    {
+        VerilatedLockGuard lk(m_mutex);
+        m_allProfiles.insert(t_profilep);
+    }
+}
+
+void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
+    VerilatedLockGuard lk(m_mutex);
+    for (ProfileSet::iterator it = m_allProfiles.begin();
+         it != m_allProfiles.end(); ++it) {
+        // Every thread's profile trace gets a copy of rec.
+        (*it)->emplace_back(rec);
+    }
+}
+
+void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
+    VerilatedLockGuard lk(m_mutex);
+    VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep););
+
+    FILE* fp = fopen(filenamep, "w");
+    if (VL_UNLIKELY(!fp)) {
+        VL_FATAL_MT(filenamep, 0, "", "+prof+threads+file file not writable");
+        return;
+    }
+
+    // TODO Perhaps merge with verilated_coverage output format, so can
+    // have a common merging and reporting tool, etc.
+    fprintf(fp, "VLPROFTHREAD 1.0 # Verilator thread profile dump version 1.0\n");
+    fprintf(fp, "VLPROF arg --threads %" VL_PRI64 "u\n",
+            vluint64_t(m_workers.size()+1));
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+start+%" VL_PRI64 "u\n",
+            Verilated::profThreadsStart());
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n",
+            Verilated::profThreadsWindow());
+    fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n",
+            VlNotification::yields());
+
+    vluint32_t thread_id = 0;
+    for (ProfileSet::iterator pit = m_allProfiles.begin();
+         pit != m_allProfiles.end(); ++pit) {
+        ++thread_id;
+
+        bool printing = false;  // False while in warmup phase
+        for (ProfileTrace::iterator eit = (*pit)->begin();
+             eit != (*pit)->end(); ++eit) {
+            switch (eit->m_type) {
+            case VlProfileRec::TYPE_BARRIER:
+                printing = true;
+                break;
+            case VlProfileRec::TYPE_MTASK_RUN:
+                if (!printing) break;
+                fprintf(fp, "VLPROF mtask %d"
+                        " start %" VL_PRI64"u end %" VL_PRI64"u elapsed %" VL_PRI64 "u"
+                        " predict_time %u cpu %u on thread %u\n",
+                        eit->m_mtaskId,
+                        eit->m_startTime,
+                        eit->m_endTime,
+                        (eit->m_endTime - eit->m_startTime),
+                        eit->m_predictTime,
+                        eit->m_cpu,
+                        thread_id);
+                break;
+            default: assert(false);
+                break;
+            }
+        }
+    }
+    fprintf(fp, "VLPROF stat ticks %" VL_PRI64 "u\n",
+            ticksElapsed);
+
+    fclose(fp);
+}

include/verilated_threads.h

@@ -0,0 +1,333 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2012-2018 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.
+//
+// This 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.
+//
+//=============================================================================
+///
+/// \file
+/// \brief Thread pool and profiling for Verilated modules
+///
+//=============================================================================
+
+#ifndef _VERILATED_THREADS_H_
+#define _VERILATED_THREADS_H_
+
+#include "verilatedos.h"
+
+#include <atomic>
+#include <thread>
+#include <vector>
+#include <set>
+#include <sched.h>  // For sched_getcpu()
+#if defined(__APPLE__)
+# include <cpuid.h>  // For __cpuid_count()
+#endif
+
+#include "verilated.h"  // for VerilatedMutex and clang annotations
+
+// VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
+// Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
+// as a void* here.
+typedef void* VlThrSymTab;
+
+class VlNotification {
+    // MEMBERS
+    std::atomic<bool> m_notified;  // Notification pending
+    static std::atomic<vluint64_t> s_yields;  // Statistics
+
+public:
+    // CONSTRUCTORS
+    VlNotification()
+        : m_notified(false) {
+        assert(atomic_is_lock_free(&m_notified));
+    }
+    ~VlNotification() {}
+
+    // METHODS
+    static vluint64_t yields() { return s_yields; }
+
+    // Block until notify() has occurred, then return.
+    // If notify() has already occurred, return immediately.
+    //
+    // This is logically const: the object will remain in notified state
+    // after WaitForNotification() returns, so you could notify more than
+    // one thread of the same event.
+    inline void waitForNotification() {
+        unsigned ct = 0;
+        while (VL_UNLIKELY(!notified())) {
+            VL_CPU_RELAX();
+            ct++;
+            if (VL_UNLIKELY(ct > VL_LOCK_SPINS)) {
+                ct = 0;
+                ++s_yields;  // Statistics
+                std::this_thread::yield();
+            }
+        }
+    }
+
+    // The 'inline' keyword here means nothing to the compiler, it's
+    // implicit on methods defined within the class body anyway.
+    //
+    // 'inline' is attached the this method, and others in this file,
+    // to remind humans that some routines in this file are called many
+    // times per cycle in threaded mode. Such routines should be
+    // inlinable; that's why they're declared in the .h and not the .cpp.
+    inline bool notified() {
+        return m_notified.load(std::memory_order_acquire);
+    }
+    // Set notified state. If state is already notified,
+    // it remains so.
+    inline void notify() {
+        m_notified.store(true, std::memory_order_release);
+    }
+    // Reset the state to un-notified state, which is also the
+    // state of a new Notification object.
+    inline void reset() {
+        m_notified.store(false, std::memory_order_relaxed);
+    }
+};
+
+typedef void (*VlExecFnp)(bool, VlThrSymTab);
+
+/// Track dependencies for a single MTask.
+class VlMTaskVertex {
+    // MEMBERS
+
+    // On even cycles, _upstreamDepsDone increases as upstream
+    // dependencies complete. When it reaches _upstreamDepCount,
+    // this MTaskVertex is ready.
+    //
+    // On odd cycles, _upstreamDepsDone decreases as upstream
+    // dependencies complete, and when it reaches zero this MTaskVertex
+    // is ready.
+    //
+    // An atomic is smaller than a mutex, and lock-free.
+    //
+    // (Why does the size of this class matter? If an mtask has many
+    // downstream mtasks to notify, we hope these will pack into a
+    // small number of cache lines to reduce the cost of pointer chasing
+    // during done-notification. Nobody's quantified that cost though.
+    // If we were really serious about shrinking this class, we could
+    // use 16-bit types here...)
+    std::atomic<vluint32_t> m_upstreamDepsDone;
+    const vluint32_t m_upstreamDepCount;
+
+public:
+    // CONSTRUCTORS
+
+    // 'upstreamDepCount' is the number of upstream MTaskVertex's
+    // that must notify this MTaskVertex before it will become ready
+    // to run.
+    explicit VlMTaskVertex(vluint32_t upstreamDepCount);
+    ~VlMTaskVertex() {}
+
+    // Upstream mtasks must call this when they complete.
+    // Returns true when the current MTaskVertex becomes ready to execute,
+    // false while it's still waiting on more dependencies.
+    inline bool signalUpstreamDone(bool evenCycle) {
+        if (evenCycle) {
+            vluint32_t upstreamDepsDone
+                = 1 + m_upstreamDepsDone.fetch_add(1, std::memory_order_release);
+            assert(upstreamDepsDone <= m_upstreamDepCount);
+            return (upstreamDepsDone == m_upstreamDepCount);
+        } else {
+            vluint32_t upstreamDepsDone_prev
+                = m_upstreamDepsDone.fetch_sub(1, std::memory_order_release);
+            assert(upstreamDepsDone_prev > 0);
+            return (upstreamDepsDone_prev == 1);
+        }
+    }
+    inline bool areUpstreamDepsDone(bool evenCycle) const {
+        vluint32_t target = evenCycle ? m_upstreamDepCount : 0;
+        return m_upstreamDepsDone.load(std::memory_order_acquire) == target;
+    }
+    inline void waitUntilUpstreamDone(bool evenCycle) const {
+        while (VL_UNLIKELY(!areUpstreamDepsDone(evenCycle))) {
+            VL_CPU_RELAX();
+        }
+    }
+};
+
+// Profiling support
+class VlProfileRec {
+protected:
+    friend class VlThreadPool;
+    enum VlProfileE {
+        TYPE_MTASK_RUN,
+        TYPE_BARRIER
+    };
+    VlProfileE m_type;  // Record type
+    vluint32_t m_mtaskId;  // Mtask we're logging
+    vluint32_t m_predictTime;  // How long scheduler predicted would take
+    vluint64_t m_startTime;  // Tick at start of execution
+    vluint64_t m_endTime;  // Tick at end of execution
+    unsigned m_cpu;  // Execution CPU number (at start anyways)
+public:
+    class Barrier {};
+    VlProfileRec() {}
+    explicit VlProfileRec(Barrier) {
+        m_type = TYPE_BARRIER;
+        m_mtaskId = 0;
+        m_predictTime = 0;
+        m_startTime = 0;
+        m_cpu = getcpu();
+    }
+    void startRecord(vluint64_t time, uint32_t mtask, uint32_t predict) {
+        m_type = VlProfileRec::TYPE_MTASK_RUN;
+        m_mtaskId = mtask;
+        m_predictTime = predict;
+        m_startTime = time;
+        m_cpu = getcpu();
+    }
+    void endRecord(vluint64_t time) {
+        m_endTime = time;
+    }
+    static int getcpu() {  // Return current executing CPU
+#if defined(__linux)
+        return sched_getcpu();
+#elif defined(__APPLE__)
+        vluint32_t info[4];
+        __cpuid_count(1, 0, info[0], info[1], info[2], info[3]);
+        /* info[1] is EBX, bits 24-31 are APIC ID */
+        if ((info[3] & (1 << 9)) == 0) {
+            return -1;  /* no APIC on chip */
+        } else {
+            return (unsigned)info[1] >> 24;
+        }
+#else
+        return 0;
+#endif
+    }
+
+};
+
+class VlThreadPool;
+
+class VlWorkerThread {
+private:
+    // TYPES
+    struct ExecRec {
+        VlExecFnp m_fnp;  // Function to execute
+        VlThrSymTab m_sym;  // Symbol table to execute
+        bool m_evenCycle;  // Even/odd for flag alternation
+        ExecRec() : m_fnp(NULL), m_sym(NULL), m_evenCycle(false) {}
+        ExecRec(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
+            : m_fnp(fnp), m_sym(sym), m_evenCycle(evenCycle) {}
+    };
+
+    // MEMBERS
+    VerilatedMutex m_mutex;
+
+    // Why a vector? We expect the pending list to be very short, typically
+    // 0 or 1 or 2, so popping from the front shouldn't be
+    // expensive. Revisit if we ever have longer queues...
+    std::vector<ExecRec> m_ready VL_GUARDED_BY(m_mutex);
+
+    VlThreadPool* m_poolp;  // Our associated thread pool
+
+    // If values stored are non-NULL, the thread is asleep pending new
+    // work. If the thread is not asleep, both parts of m_sleepAlarm must
+    // be NULL.
+    std::pair<VlNotification*, ExecRec*> m_sleepAlarm VL_GUARDED_BY(m_mutex);
+
+    bool m_profiling;  // Is profiling enabled?
+    std::atomic<bool> m_exiting;  // Worker thread should exit
+    std::thread m_cthread;  // Underlying C++ thread record
+
+    VL_UNCOPYABLE(VlWorkerThread);
+
+public:
+    // CONSTRUCTORS
+    explicit VlWorkerThread(VlThreadPool* poolp, bool profiling);
+    ~VlWorkerThread();
+
+    // METHODS
+    inline void dequeWork(ExecRec* workp) VL_REQUIRES(m_mutex) {
+        // As noted above this is inefficient if our ready list is ever
+        // long (but it shouldn't be)
+        *workp = m_ready.front();
+        m_ready.erase(m_ready.begin());
+    }
+    inline void wakeUp() VL_REQUIRES(m_mutex) {
+        VlNotification* notifyp = m_sleepAlarm.first;
+        m_sleepAlarm.first = NULL;  // NULL+NULL means wake
+        m_sleepAlarm.second = NULL;
+        notifyp->notify();
+    }
+    inline bool sleeping() VL_REQUIRES(m_mutex) {
+        return (m_sleepAlarm.first != NULL);
+    }
+    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym) {
+        VerilatedLockGuard lk(m_mutex);
+        m_ready.emplace_back(fnp, evenCycle, sym);
+        if (VL_LIKELY(sleeping())) {  // Generally queue is waiting for work
+            // Awaken thread
+            dequeWork(m_sleepAlarm.second);
+            wakeUp();
+        }
+    }
+    void workerLoop();
+    static void startWorker(VlWorkerThread* workerp);
+};
+
+class VlThreadPool {
+    // TYPES
+    typedef std::vector<VlProfileRec> ProfileTrace;
+    typedef std::set<ProfileTrace*> ProfileSet;
+
+    // MEMBERS
+    std::vector<VlWorkerThread*> m_workers;  // our workers
+    bool m_profiling;  // is profiling enabled?
+
+    // Support profiling -- we can append records of profiling events
+    // to this vector with very low overhead, and then dump them out
+    // later. This prevents the overhead of printf/malloc/IO from
+    // corrupting the profiling data. It's super cheap to append
+    // a VlProfileRec struct on the end of a pre-allocated vector;
+    // this is the only cost we pay in real-time during a profiling cycle.
+    static VL_THREAD_LOCAL ProfileTrace* t_profilep;
+    ProfileSet m_allProfiles VL_GUARDED_BY(m_mutex);
+    VerilatedMutex m_mutex;
+
+public:
+    // CONSTRUCTORS
+    // Construct a thread pool with 'nThreads' dedicated threads. The thread
+    // pool will create these threads and make them available to execute tasks
+    // via this->workerp(index)->addTask(...)
+    VlThreadPool(int nThreads, bool profiling);
+    ~VlThreadPool();
+
+    // METHODS
+    inline int numThreads() const {
+        return m_workers.size();
+    }
+    inline VlWorkerThread* workerp(int index) {
+        assert(index >= 0);
+        assert(index < m_workers.size());
+        return m_workers[index];
+    }
+    inline VlProfileRec* profileAppend() {
+        t_profilep->emplace_back();
+        return &(t_profilep->back());
+    }
+    void profileAppendAll(const VlProfileRec& rec);
+    void profileDump(const char* filenamep, vluint64_t ticksElapsed);
+    // In profiling mode, each executing thread must call
+    // this once to setup profiling state:
+    void setupProfilingClientThread();
+    void tearDownProfilingClientThread();
+private:
+    VL_UNCOPYABLE(VlThreadPool);
+};
+
+#endif

include/verilated_unordered_set_map.h

@@ -0,0 +1,548 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: pre-C++11 replacements for std::unordered_set
+//                         and std::unordered_map.
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2018 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.
+//
+//*************************************************************************
+
+
+//*************************************************************************
+// This file has clones of the std::unordered_set and std::unordered_map
+// hash table types. They are here so that Verilator can use hash tables
+// in pre-C++11 compilers, and the same client code can link against the
+// std:: types when they are available.
+//
+// The implementations in this file do not implement the complete APIs
+// of the std:: types. Nor are they correct in every detail,
+// notably, the const_iterators do not enforce constness. We can extend
+// these implementations to cover more of the std API as needed.
+//
+// TODO: In the future, when Verilator requires C++11 to compile,
+//       remove this entire file and switch to the std:: types.
+//
+//*************************************************************************
+
+#ifndef _V3_UNORDERED_SET_MAP_H_
+#define _V3_UNORDERED_SET_MAP_H_
+
+#include "verilated_config.h"
+#include "verilatedos.h"
+
+#include <list>
+#include <stdexcept>
+#include <string>
+
+// Abstract 'vl_hash' and 'vl_equal_to' templates.
+template <typename T> struct vl_hash {
+    size_t operator()(const T& k) const;
+};
+
+template <typename T> struct vl_equal_to {
+    bool operator()(const T& a, const T& b) const;
+};
+
+// Specializations of 'vl_hash' and 'vl_equal_to'.
+inline size_t vl_hash_bytes(const void* vbufp, size_t nbytes) {
+    const vluint8_t* bufp = static_cast<const vluint8_t*>(vbufp);
+    size_t hash = 0;
+    for (size_t i = 0; i < nbytes; i++) {
+        hash = bufp[i] + 31u * hash;  // the K&R classic!
+    }
+    return hash;
+}
+
+template <> inline size_t
+vl_hash<unsigned int>::operator()(const unsigned int& k) const {
+    return k;
+}
+
+template <> inline bool
+vl_equal_to<unsigned int>::operator()(const unsigned int& a,
+                                      const unsigned int& b) const {
+    return a == b;
+}
+
+template <> inline size_t
+vl_hash<std::string>::operator()(const std::string& k) const {
+    return vl_hash_bytes(k.data(), k.size());
+}
+
+template <> inline bool
+vl_equal_to<std::string>::operator()(const std::string& a,
+                                     const std::string& b) const {
+    // Don't scan the strings if the sizes are different.
+    if (a.size() != b.size()) {
+        return false;
+    }
+    return (0 == a.compare(b));  // Must scan.
+}
+
+template <typename T> struct vl_hash<T*> {
+    size_t operator()(T* kp) const {
+        return ((sizeof(size_t) == sizeof(kp))
+                ? reinterpret_cast<size_t>(kp)
+                : vl_hash_bytes(&kp, sizeof(kp)));
+    }
+};
+
+template <typename T> struct vl_equal_to<T*> {
+    bool operator()(T* ap, T* bp) const {
+        return ap == bp;
+    }
+};
+
+//===================================================================
+//
+/// Functional clone of the std::unordered_set hash table.
+template <class T_Key,
+          class T_Hash = vl_hash<T_Key>,
+          class T_Equal = vl_equal_to<T_Key> >
+class vl_unordered_set {
+public:
+    // TYPES
+    typedef std::list<T_Key> Bucket;
+    enum RehashType {GROW, SHRINK};
+
+    template <class KK, class VV,
+              class HH, class EQ> friend class vl_unordered_map;
+
+    class iterator {
+    protected:
+        // MEMBERS
+        size_t m_bucketIdx; //  Bucket this iterator points into.
+        typename Bucket::iterator m_bit; //  Bucket-local iterator.
+        const vl_unordered_set* m_setp;  //  The containing set.
+
+    public:
+        // CONSTRUCTORS
+        iterator(size_t bucketIdx, typename Bucket::iterator bit,
+                 const vl_unordered_set* setp)
+            : m_bucketIdx(bucketIdx), m_bit(bit), m_setp(setp) {}
+
+        // METHODS
+        const T_Key& operator*() const {
+            return *m_bit;
+        }
+        // This should really be 'const T_Key*' type for unordered_set,
+        // however this iterator is shared with unordered_map whose
+        // operator-> returns a non-const ValueType*, so keep this
+        // non-const to avoid having to define a whole separate iterator
+        // for unordered_map.
+        T_Key* operator->() const {
+            return &(*m_bit);
+        }
+        bool operator==(const iterator& other) const {
+            return ((m_bucketIdx == other.m_bucketIdx)
+                    && (m_bit == other.m_bit));
+        }
+        bool operator!=(const iterator& other) const {
+            return (!this->operator==(other));
+        }
+        void advanceUntilValid() {
+            while (1) {
+                if (m_bit != m_setp->m_bucketsp[m_bucketIdx].end()) {
+                    // Valid iterator in this bucket; we're done.
+                    return;
+                }
+
+                // Try the next bucket?
+                m_bucketIdx++;
+                if (m_bucketIdx == m_setp->numBuckets()) {
+                    // Ran past the end of buckets, set to end().
+                    *this = m_setp->end();
+                    return;
+                }
+                m_bit = m_setp->m_bucketsp[m_bucketIdx].begin();
+            }
+        }
+        void operator++() {
+            ++m_bit;
+            advanceUntilValid();
+        }
+
+        typename Bucket::iterator bit() const { return m_bit; }
+    };
+
+    // TODO: there's no real const enforcement on the 'const_iterator'.
+    typedef iterator const_iterator;
+
+private:
+    // MEMBERS
+    size_t m_numElements;       //  Number of entries present.
+    size_t m_log2Buckets;       //  Log-base-2 of the number of buckets.
+    mutable Bucket* m_bucketsp; //  Hash table buckets. May be NULL;
+    //                          //   we'll allocate it on the fly when
+    //                          //   the first entries are created.
+    Bucket m_emptyBucket;       //  A fake bucket, used to construct end().
+    T_Hash m_hash;              //  Hash function provider.
+    T_Equal m_equal;            //  Equal-to function provider.
+
+public:
+    // CONSTRUCTORS
+    vl_unordered_set()
+        : m_numElements(0)
+        , m_log2Buckets(initLog2Buckets())
+        , m_bucketsp(NULL)
+        , m_hash()
+        , m_equal() { }
+
+    vl_unordered_set(const vl_unordered_set& other)
+        : m_numElements(other.m_numElements)
+        , m_log2Buckets(other.m_log2Buckets)
+        , m_bucketsp(NULL)
+        , m_hash()
+        , m_equal() {
+        if (other.m_bucketsp) {
+            m_bucketsp = new Bucket[numBuckets()];
+            for (size_t i = 0; i < numBuckets(); i++) {
+                m_bucketsp[i] = other.m_bucketsp[i];
+            }
+        }
+    }
+    ~vl_unordered_set() {
+        delete [] m_bucketsp; VL_DANGLING(m_bucketsp);
+    }
+
+    vl_unordered_set& operator=(const vl_unordered_set& other) {
+        if (this != &other) {
+            clear();
+            delete [] m_bucketsp;
+            m_numElements = other.m_numElements;
+            m_log2Buckets = other.m_log2Buckets;
+            if (other.m_bucketsp) {
+                m_bucketsp = new Bucket[numBuckets()];
+                for (size_t i = 0; i < numBuckets(); i++) {
+                    m_bucketsp[i] = other.m_bucketsp[i];
+                }
+            } else {
+                m_bucketsp = NULL;
+            }
+        }
+        return *this;
+    }
+
+    // METHODS
+    static size_t initLog2Buckets() { return 4; }
+
+    iterator begin() {
+        if (m_numElements) {
+            initBuckets();
+            iterator result = iterator(0, m_bucketsp[0].begin(), this);
+            result.advanceUntilValid();
+            return result;
+        }
+        return end();
+    }
+    const_iterator begin() const {
+        if (m_numElements) {
+            initBuckets();
+            const_iterator result = iterator(0, m_bucketsp[0].begin(), this);
+            result.advanceUntilValid();
+            return result;
+        }
+        return end();
+    }
+    const_iterator end() const {
+        return iterator(VL_ULL(0xFFFFFFFFFFFFFFFF),
+                        const_cast<Bucket&>(m_emptyBucket).begin(), this);
+    }
+
+    bool empty() const { return m_numElements == 0; }
+
+    size_t size() const { return m_numElements; }
+
+    size_t count(const T_Key& key) const {
+        return (find(key) == end()) ? 0 : 1;
+    }
+
+    size_t hashToBucket(size_t hashVal) const {
+        return hashToBucket(hashVal, m_log2Buckets);
+    }
+    static size_t hashToBucket(size_t hashVal, unsigned log2Buckets) {
+        // Fibonacci hashing
+        // See https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization-that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
+        //
+        // * The magic numbers below are UINT_MAX/phi where phi is the
+        //   golden ratio number (1.618...)  for either 64- or 32-bit
+        //   values of UINT_MAX.
+        //
+        // * Fibonacci hashing mixes the result of the client's hash
+        //   function further. This permits the use of very fast client
+        //   hash funcs (like just returning the int or pointer value as
+        //   is!) and tolerates crappy client hash functions pretty well.
+        size_t mult = hashVal * ((sizeof(size_t) == 8)
+                                 ? VL_ULL(11400714819323198485)
+                                 : 2654435769lu);
+        size_t result = (mult >> (((sizeof(size_t) == 8)
+                                   ? 64 : 32) - log2Buckets));
+        return result;
+    }
+
+    iterator find_internal(const T_Key& key, size_t& bucketIdxOut) {
+        size_t hash = m_hash.operator()(key);
+        bucketIdxOut = hashToBucket(hash);
+        initBuckets();
+        Bucket* bucketp = &m_bucketsp[bucketIdxOut];
+
+        for (typename Bucket::iterator it = bucketp->begin();
+             it != bucketp->end(); ++it) {
+            if (m_equal.operator()(*it, key)) {
+                return iterator(bucketIdxOut, it, this);
+            }
+        }
+        return end();
+    }
+
+    const_iterator find(const T_Key& key) const {
+        size_t bucketIdx;
+        return const_cast<vl_unordered_set*>(this)->find_internal(key,
+                                                                  bucketIdx);
+    }
+
+    iterator find(const T_Key& key) {
+        size_t bucketIdx;
+        return find_internal(key, bucketIdx);
+    }
+
+    std::pair<iterator, bool> insert(const T_Key &val) {
+        size_t bucketIdx;
+        iterator existIt = find_internal(val, bucketIdx);
+        if (existIt != end()) {
+            // Collision with existing element.
+            //
+            // An element may be inserted only if it is not
+            // equal to an existing element. So fail.
+            return std::pair<iterator, bool>(end(), false);
+        }
+
+        // No collision, so insert it.
+        m_numElements++;
+
+        m_bucketsp[bucketIdx].push_front(val);
+
+        // Compute result iterator. This pointer will be valid
+        // if we don't rehash:
+        iterator result_it(bucketIdx, m_bucketsp[bucketIdx].begin(), this);
+
+        if (needToRehash(GROW)) {
+            rehash(GROW);
+            // ... since we rehashed, do a lookup to get the result iterator.
+            result_it = find(val);
+        }
+
+        return std::pair<iterator, bool>(result_it, true);
+    }
+
+    iterator erase(iterator it) {
+        iterator next_it = it;
+        ++next_it;
+        erase(*it);
+        return next_it;
+    }
+
+    size_t erase(const T_Key &key) {
+        size_t bucketIdx;
+        iterator it = find_internal(key, bucketIdx);
+        if (it != end()) {
+            m_bucketsp[bucketIdx].erase(it.bit());
+            m_numElements--;
+            // Rehashing to handle a shrinking data set is important
+            // for the Scoreboard in V3Partition, which begins tracking
+            // a huge number of vertices and then tracks a successively
+            // smaller number over time.
+            if (needToRehash(SHRINK)) {
+                rehash(SHRINK);
+            }
+            return 1;
+        }
+        return 0;
+    }
+
+    void clear() {
+        if (m_bucketsp) {
+            delete [] m_bucketsp;
+            m_bucketsp = NULL;
+        }
+        m_numElements = 0;
+        m_log2Buckets = initLog2Buckets();
+    }
+
+private:
+    size_t numBuckets() const { return (VL_ULL(1) << m_log2Buckets); }
+
+    Bucket* getBucket(size_t idx) {
+        initBuckets();
+        return &m_bucketsp[idx];
+    }
+
+    void initBuckets() const {
+        if (!m_bucketsp) m_bucketsp = new Bucket[numBuckets()];
+    }
+
+    bool needToRehash(RehashType rt) const {
+        if (rt == GROW) {
+            return ((4 * numBuckets()) < m_numElements);
+        } else {
+            return (numBuckets() > (4 * m_numElements));
+        }
+    }
+
+    void rehash(RehashType rt) {
+        size_t new_log2Buckets;
+        if (rt == GROW) {
+            new_log2Buckets = m_log2Buckets + 2;
+        } else {
+            if (m_log2Buckets <= 4) {
+                // On shrink, saturate m_log2Buckets at its
+                // initial size of 2^4 == 16 buckets. Don't risk
+                // underflowing!
+                return;
+            }
+            new_log2Buckets = m_log2Buckets - 2;
+        }
+
+        size_t new_num_buckets = VL_ULL(1) << new_log2Buckets;
+        Bucket* new_bucketsp = new Bucket[new_num_buckets];
+
+        for (size_t i=0; i<numBuckets(); i++) {
+            while (!m_bucketsp[i].empty()) {
+                typename Bucket::iterator bit = m_bucketsp[i].begin();
+                size_t hash = m_hash.operator()(*bit);
+                size_t new_idx = hashToBucket(hash, new_log2Buckets);
+                // Avoid mallocing one list elem and freeing another;
+                // splice just moves it over.
+                new_bucketsp[new_idx].splice(new_bucketsp[new_idx].begin(),
+                                             m_bucketsp[i], bit);
+            }
+        }
+
+        delete[] m_bucketsp;
+        m_bucketsp = new_bucketsp;
+        m_log2Buckets = new_log2Buckets;
+    }
+};
+
+//===================================================================
+//
+/// Functional clone of the std::unordered_map hash table.
+template <class T_Key,
+          class T_Value,
+          class T_Hash = vl_hash<T_Key>,
+          class T_Equal = vl_equal_to<T_Key> >
+class vl_unordered_map {
+private:
+    // TYPES
+    typedef std::pair<T_Key, T_Value> KeyValPair;
+
+    class KeyHash {
+    private:
+        T_Hash key_hash;
+    public:
+        KeyHash() {}
+        size_t operator()(const KeyValPair& kv_pair) const {
+            return key_hash.operator()(kv_pair.first);
+        }
+    };
+
+    class KeyEqual {
+    private:
+        T_Equal key_eq;
+    public:
+        KeyEqual() {}
+        bool operator()(const KeyValPair& kv_a, const KeyValPair& kv_b) const {
+            return key_eq.operator()(kv_a.first, kv_b.first);
+        }
+    };
+
+    // MEMBERS
+    typedef vl_unordered_set<KeyValPair, KeyHash, KeyEqual> MapSet;
+    MapSet m_set;   //  Wrap this vl_unordered_set which holds all state.
+
+public:
+    // CONSTRUCTORS
+    vl_unordered_map() {}
+    ~vl_unordered_map() {}
+
+    typedef typename MapSet::iterator iterator;
+    typedef typename MapSet::const_iterator const_iterator;
+
+    // METHODS
+    iterator begin() { return m_set.begin(); }
+    const_iterator begin() const { return m_set.begin(); }
+    const_iterator end() const { return m_set.end(); }
+    bool empty() const { return m_set.empty(); }
+    iterator find(const T_Key& k) {
+        // We can't assume that T_Value() is defined.
+        // ie, this does not work:
+        //    return m_set.find(std::make_pair(k, T_Value()));
+
+        // So, do this instead:
+        T_Hash mapHash;
+        T_Equal mapEq;
+        size_t hash = mapHash.operator()(k);
+        size_t bucketIdxOut = m_set.hashToBucket(hash);
+        typename MapSet::Bucket* bucketp = m_set.getBucket(bucketIdxOut);
+
+        for (typename MapSet::Bucket::iterator it = bucketp->begin();
+             it != bucketp->end(); ++it) {
+            if (mapEq.operator()(it->first, k)) {
+                return iterator(bucketIdxOut, it, &m_set);
+            }
+        }
+        return end();
+    }
+    const_iterator find(const T_Key& k) const {
+        return const_cast<vl_unordered_map*>(this)->find(k);
+    }
+    std::pair<iterator, bool> insert(const KeyValPair& val) {
+        return m_set.insert(val);
+    }
+    iterator erase(iterator it) { return m_set.erase(it); }
+    size_t erase(const T_Key& k) {
+        iterator it = find(k);
+        if (it == end()) { return 0; }
+        m_set.erase(it);
+        return 1;
+    }
+    T_Value& operator[](const T_Key& k) {
+        // Here we can assume T_Value() is defined, as
+        // std::unordered_map::operator[] relies on it too.
+        KeyValPair dummy = std::make_pair(k, T_Value());
+        iterator it = m_set.find(dummy);
+        if (it == m_set.end()) {
+            it = m_set.insert(dummy).first;
+        }
+        // For the 'set', it's generally not safe to modify
+        // the value after deref. For the 'map' though, we know
+        // it's safe to modify the value field and we can allow it:
+        return it->second;
+    }
+    T_Value& at(const T_Key& k) {
+        iterator it = find(k);
+        if (it == end()) { throw std::out_of_range("sorry"); }
+        return it->second;
+    }
+    const T_Value& at(const T_Key& k) const {
+        iterator it = find(k);
+        if (it == end()) { throw std::out_of_range("sorry"); }
+        return it->second;
+    }
+    void clear() { m_set.clear(); }
+    size_t size() const { return m_set.size(); }
+};
+
+#endif

include/verilated_vcd_c.cpp

@@ -24,7 +24,6 @@
 #include "verilated.h"
 #include "verilated_vcd_c.h"
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <cerrno>
@@ -39,7 +38,7 @@
 
 // SPDIFF_ON
 
-#ifndef O_LARGEFILE // For example on WIN32
+#ifndef O_LARGEFILE  // For example on WIN32
 # define O_LARGEFILE 0
 #endif
 #ifndef O_NONBLOCK
@@ -58,25 +57,25 @@ private:
         VerilatedMutex  s_vcdMutex;  ///< Protect the singleton
         VcdVec          s_vcdVecp VL_GUARDED_BY(s_vcdMutex);  ///< List of all created traces
     };
-    static Singleton& singleton() { static Singleton s;	return s; }
+    static Singleton& singleton() { static Singleton s; return s; }
 public:
     static void pushVcd(VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-	VerilatedLockGuard lock(singleton().s_vcdMutex);
-	singleton().s_vcdVecp.push_back(vcdp);
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        singleton().s_vcdVecp.push_back(vcdp);
     }
     static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-	VerilatedLockGuard lock(singleton().s_vcdMutex);
-	VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(), singleton().s_vcdVecp.end(), vcdp);
-	if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); }
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(), singleton().s_vcdVecp.end(), vcdp);
+        if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); }
     }
     static void flush_all() VL_EXCLUDES(singleton().s_vcdMutex) VL_MT_UNSAFE_ONE {
-	// Thread safety: Although this function is protected by a mutex so perhaps
-	// in the future we can allow tracing in separate threads, vcdp->flush() assumes call from single thread
-	VerilatedLockGuard lock(singleton().s_vcdMutex);
-	for (VcdVec::const_iterator it=singleton().s_vcdVecp.begin(); it!=singleton().s_vcdVecp.end(); ++it) {
-	    VerilatedVcd* vcdp = *it;
-	    vcdp->flush();
-	}
+        // Thread safety: Although this function is protected by a mutex so perhaps
+        // in the future we can allow tracing in separate threads, vcdp->flush() assumes call from single thread
+        VerilatedLockGuard lock(singleton().s_vcdMutex);
+        for (VcdVec::const_iterator it=singleton().s_vcdVecp.begin(); it!=singleton().s_vcdVecp.end(); ++it) {
+            VerilatedVcd* vcdp = *it;
+            vcdp->flush();
+        }
     }
 };
 
@@ -91,16 +90,16 @@ public:
 class VerilatedVcdCallInfo {
 protected:
     friend class VerilatedVcd;
-    VerilatedVcdCallback_t	m_initcb;	///< Initialization Callback function
-    VerilatedVcdCallback_t	m_fullcb;	///< Full Dumping Callback function
-    VerilatedVcdCallback_t	m_changecb;	///< Incremental Dumping Callback function
-    void*		m_userthis;	///< Fake "this" for caller
-    vluint32_t		m_code;		///< Starting code number
+    VerilatedVcdCallback_t      m_initcb;       ///< Initialization Callback function
+    VerilatedVcdCallback_t      m_fullcb;       ///< Full Dumping Callback function
+    VerilatedVcdCallback_t      m_changecb;     ///< Incremental Dumping Callback function
+    void*               m_userthis;     ///< Fake "this" for caller
+    vluint32_t          m_code;         ///< Starting code number
     // CONSTRUCTORS
-    VerilatedVcdCallInfo (VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
-			  VerilatedVcdCallback_t changecb,
-			  void* ut, vluint32_t code)
-	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+    VerilatedVcdCallInfo(VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
+                         VerilatedVcdCallback_t changecb,
+                         void* ut, vluint32_t code)
+        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
     ~VerilatedVcdCallInfo() {}
 };
 
@@ -146,7 +145,7 @@ VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
     m_wroteBytes = 0;
 }
 
-void VerilatedVcd::open (const char* filename) {
+void VerilatedVcd::open(const char* filename) {
     m_assertOne.check();
     if (isOpen()) return;
 
@@ -159,64 +158,64 @@ void VerilatedVcd::open (const char* filename) {
     Verilated::flushCb(&flush_all);
 
     // SPDIFF_ON
-    openNext (m_rolloverMB!=0);
+    openNext(m_rolloverMB!=0);
     if (!isOpen()) return;
 
     dumpHeader();
 
     // Allocate space now we know the number of codes
     if (!m_sigs_oldvalp) {
-	m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
+        m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
     }
 
     if (m_rolloverMB) {
-	openNext(true);
-	if (!isOpen()) return;
+        openNext(true);
+        if (!isOpen()) return;
     }
 }
 
-void VerilatedVcd::openNext (bool incFilename) {
+void VerilatedVcd::openNext(bool incFilename) {
     // Open next filename in concat sequence, mangle filename if
     // incFilename is true.
     m_assertOne.check();
-    closePrev(); // Close existing
+    closePrev();  // Close existing
     if (incFilename) {
-	// Find _0000.{ext} in filename
-	std::string name = m_filename;
-	size_t pos=name.rfind(".");
-	if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
-	    && isdigit(name.c_str()[pos-4])
-	    && isdigit(name.c_str()[pos-3])
-	    && isdigit(name.c_str()[pos-2])
-	    && isdigit(name.c_str()[pos-1])) {
-	    // Increment code.
-	    if ((++(name[pos-1])) > '9') {
-		name[pos-1] = '0';
-		if ((++(name[pos-2])) > '9') {
-		    name[pos-2] = '0';
-		    if ((++(name[pos-3])) > '9') {
-			name[pos-3] = '0';
-			if ((++(name[pos-4])) > '9') {
-			    name[pos-4] = '0';
-			}}}}
-	} else {
-	    // Append _cat0000
-	    name.insert(pos,"_cat0000");
-	}
-	m_filename = name;
+        // Find _0000.{ext} in filename
+        std::string name = m_filename;
+        size_t pos=name.rfind(".");
+        if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
+            && isdigit(name.c_str()[pos-4])
+            && isdigit(name.c_str()[pos-3])
+            && isdigit(name.c_str()[pos-2])
+            && isdigit(name.c_str()[pos-1])) {
+            // Increment code.
+            if ((++(name[pos-1])) > '9') {
+                name[pos-1] = '0';
+                if ((++(name[pos-2])) > '9') {
+                    name[pos-2] = '0';
+                    if ((++(name[pos-3])) > '9') {
+                        name[pos-3] = '0';
+                        if ((++(name[pos-4])) > '9') {
+                            name[pos-4] = '0';
+                        }}}}
+        } else {
+            // Append _cat0000
+            name.insert(pos,"_cat0000");
+        }
+        m_filename = name;
     }
     if (m_filename[0]=='|') {
-	assert(0);	// Not supported yet.
+        assert(0);  // Not supported yet.
     } else {
-	// cppcheck-suppress duplicateExpression
-	if (!m_filep->open(m_filename)) {
-	    // User code can check isOpen()
-	    m_isOpen = false;
-	    return;
-	}
+        // cppcheck-suppress duplicateExpression
+        if (!m_filep->open(m_filename)) {
+            // User code can check isOpen()
+            m_isOpen = false;
+            return;
+        }
     }
     m_isOpen = true;
-    m_fullDump = true;	// First dump must be full
+    m_fullDump = true;  // First dump must be full
     m_wroteBytes = 0;
 }
 
@@ -226,9 +225,9 @@ void VerilatedVcd::makeNameMap() {
     m_nextCode = 1;
     m_namemapp = new NameMap;
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	cip->m_code = m_nextCode;
-	(cip->m_initcb) (this, cip->m_userthis, cip->m_code);
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        cip->m_code = m_nextCode;
+        (cip->m_initcb) (this, cip->m_userthis, cip->m_code);
     }
 
     // Though not speced, it's illegal to generate a vcd with signals
@@ -237,21 +236,21 @@ void VerilatedVcd::makeNameMap() {
     // This comes from user instantiations with no name - IE Vtop("").
     bool nullScope = false;
     for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const std::string& hiername = it->first;
-	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
+        const std::string& hiername = it->first;
+        if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
     }
     if (nullScope) {
-	NameMap* newmapp = new NameMap;
-	for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	    const std::string& hiername = it->first;
-	    const std::string& decl     = it->second;
-	    std::string newname = std::string("top");
-	    if (hiername[0] != '\t') newname += ' ';
-	    newname += hiername;
-	    newmapp->insert(std::make_pair(newname,decl));
-	}
-	deleteNameMap();
-	m_namemapp = newmapp;
+        NameMap* newmapp = new NameMap;
+        for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+            const std::string& hiername = it->first;
+            const std::string& decl     = it->second;
+            std::string newname = std::string("top");
+            if (hiername[0] != '\t') newname += ' ';
+            newname += hiername;
+            newmapp->insert(std::make_pair(newname,decl));
+        }
+        deleteNameMap();
+        m_namemapp = newmapp;
     }
 }
 
@@ -266,13 +265,13 @@ VerilatedVcd::~VerilatedVcd() {
     deleteNameMap();
     if (m_filep && m_fileNewed) { delete m_filep; m_filep = NULL; }
     for (CallbackVec::const_iterator it=m_callbacks.begin(); it!=m_callbacks.end(); ++it) {
-	delete (*it);
+        delete (*it);
     }
     m_callbacks.clear();
     VerilatedVcdSingleton::removeVcd(this);
 }
 
-void VerilatedVcd::closePrev () {
+void VerilatedVcd::closePrev() {
     // This function is on the flush() call path
     if (!isOpen()) return;
 
@@ -281,7 +280,7 @@ void VerilatedVcd::closePrev () {
     m_filep->close();
 }
 
-void VerilatedVcd::closeErr () {
+void VerilatedVcd::closeErr() {
     // This function is on the flush() call path
     // Close due to an error.  We might abort before even getting here,
     // depending on the definition of vl_fatal.
@@ -297,37 +296,37 @@ void VerilatedVcd::close() {
     m_assertOne.check();
     if (!isOpen()) return;
     if (m_evcd) {
-	printStr("$vcdclose ");
-	printTime(m_timeLastDump);
-	printStr(" $end\n");
+        printStr("$vcdclose ");
+        printTime(m_timeLastDump);
+        printStr(" $end\n");
     }
     closePrev();
 }
 
-void VerilatedVcd::printStr (const char* str) {
+void VerilatedVcd::printStr(const char* str) {
     // Not fast...
     while (*str) {
-	*m_writep++ = *str++;
-	bufferCheck();
+        *m_writep++ = *str++;
+        bufferCheck();
     }
 }
 
-void VerilatedVcd::printQuad (vluint64_t n) {
+void VerilatedVcd::printQuad(vluint64_t n) {
     char buf [100];
     sprintf(buf,"%" VL_PRI64 "u", n);
     printStr(buf);
 }
 
-void VerilatedVcd::printTime (vluint64_t timeui) {
+void VerilatedVcd::printTime(vluint64_t timeui) {
     // VCD file format specification does not allow non-integers for timestamps
     // Dinotrace doesn't mind, but Cadence vvision seems to choke
     if (VL_UNLIKELY(timeui < m_timeLastDump)) {
-	timeui = m_timeLastDump;
-	static VL_THREAD_LOCAL bool backTime = false;
-	if (!backTime) {
-	    backTime = true;
-	    VL_PRINTF_MT("%%Warning: VCD time is moving backwards, wave file may be incorrect.\n");
-	}
+        timeui = m_timeLastDump;
+        static VL_THREAD_LOCAL bool backTime = false;
+        if (!backTime) {
+            backTime = true;
+            VL_PRINTF_MT("%%Warning: VCD time is moving backwards, wave file may be incorrect.\n");
+        }
     }
     m_timeLastDump = timeui;
     printQuad(timeui);
@@ -337,17 +336,17 @@ void VerilatedVcd::bufferResize(vluint64_t minsize) {
     // minsize is size of largest write.  We buffer at least 8 times as much data,
     // writing when we are 3/4 full (with thus 2*minsize remaining free)
     if (VL_UNLIKELY(minsize > m_wrChunkSize)) {
-	char* oldbufp = m_wrBufp;
-	m_wrChunkSize = minsize*2;
-	m_wrBufp = new char [m_wrChunkSize * 8];
-	memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
+        char* oldbufp = m_wrBufp;
+        m_wrChunkSize = minsize*2;
+        m_wrBufp = new char [m_wrChunkSize * 8];
+        memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
         m_writep = m_wrBufp + (m_writep - oldbufp);
-	m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
-	delete [] oldbufp; oldbufp=NULL;
+        m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
+        delete [] oldbufp; oldbufp=NULL;
     }
 }
 
-void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
+void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
     // This function is on the flush() call path
     // We add output data to m_writep.
     // When it gets nearly full we dump it using this routine which calls write()
@@ -356,22 +355,22 @@ void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(!isOpen())) return;
     char* wp = m_wrBufp;
     while (1) {
-	ssize_t remaining = (m_writep - wp);
-	if (remaining==0) break;
-	errno = 0;
-	ssize_t got = m_filep->write(wp, remaining);
-	if (got>0) {
-	    wp += got;
-	    m_wroteBytes += got;
-	} else if (got < 0) {
-	    if (errno != EAGAIN && errno != EINTR) {
-		// write failed, presume error (perhaps out of disk space)
-		std::string msg = std::string("VerilatedVcd::bufferFlush: ")+strerror(errno);
-		VL_FATAL_MT("",0,"",msg.c_str());
-		closeErr();
-		break;
-	    }
-	}
+        ssize_t remaining = (m_writep - wp);
+        if (remaining==0) break;
+        errno = 0;
+        ssize_t got = m_filep->write(wp, remaining);
+        if (got>0) {
+            wp += got;
+            m_wroteBytes += got;
+        } else if (got < 0) {
+            if (errno != EAGAIN && errno != EINTR) {
+                // write failed, presume error (perhaps out of disk space)
+                std::string msg = std::string("VerilatedVcd::bufferFlush: ")+strerror(errno);
+                VL_FATAL_MT("",0,"",msg.c_str());
+                closeErr();
+                break;
+            }
+        }
     }
 
     // Reset buffer
@@ -381,19 +380,19 @@ void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
 //=============================================================================
 // Simple methods
 
-void VerilatedVcd::set_time_unit (const char* unitp) {
-    //cout<<" set_time_unit ("<<unitp<<") == "<<timescaleToDouble(unitp)
+void VerilatedVcd::set_time_unit(const char* unitp) {
+    //cout<<" set_time_unit("<<unitp<<") == "<<timescaleToDouble(unitp)
     //    <<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeUnit = timescaleToDouble(unitp);
 }
 
-void VerilatedVcd::set_time_resolution (const char* unitp) {
-    //cout<<"set_time_resolution ("<<unitp<<") == "<<timescaleToDouble(unitp)
+void VerilatedVcd::set_time_resolution(const char* unitp) {
+    //cout<<"set_time_resolution("<<unitp<<") == "<<timescaleToDouble(unitp)
     //    <<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeRes = timescaleToDouble(unitp);
 }
 
-double VerilatedVcd::timescaleToDouble (const char* unitp) {
+double VerilatedVcd::timescaleToDouble(const char* unitp) {
     char* endp;
     double value = strtod(unitp, &endp);
     if (value==0.0 && endp==unitp) value=1;  // On error so we allow just "ns" to return 1e-9.
@@ -411,9 +410,9 @@ double VerilatedVcd::timescaleToDouble (const char* unitp) {
     return value;
 }
 
-std::string VerilatedVcd::doubleToTimescale (double value) {
+std::string VerilatedVcd::doubleToTimescale(double value) {
     const char* suffixp = "s";
-    if	    (value>=1e0)   { suffixp="s"; value *= 1e0; }
+    if      (value>=1e0)   { suffixp="s"; value *= 1e0; }
     else if (value>=1e-3 ) { suffixp="ms"; value *= 1e3; }
     else if (value>=1e-6 ) { suffixp="us"; value *= 1e6; }
     else if (value>=1e-9 ) { suffixp="ns"; value *= 1e9; }
@@ -427,14 +426,14 @@ std::string VerilatedVcd::doubleToTimescale (double value) {
 //=============================================================================
 // Definitions
 
-void VerilatedVcd::printIndent (int level_change) {
+void VerilatedVcd::printIndent(int level_change) {
     if (level_change<0) m_modDepth += level_change;
     assert(m_modDepth>=0);
     for (int i=0; i<m_modDepth; i++) printStr(" ");
     if (level_change>0) m_modDepth += level_change;
 }
 
-void VerilatedVcd::dumpHeader () {
+void VerilatedVcd::dumpHeader() {
     printStr("$version Generated by VerilatedVcd $end\n");
     time_t time_str = time(NULL);
     printStr("$date "); printStr(ctime(&time_str)); printStr(" $end\n");
@@ -447,7 +446,7 @@ void VerilatedVcd::dumpHeader () {
     makeNameMap();
 
     // Signal header
-    assert (m_modDepth==0);
+    assert(m_modDepth==0);
     printIndent(1);
     printStr("\n");
 
@@ -459,78 +458,78 @@ void VerilatedVcd::dumpHeader () {
     // Print the signal names
     const char* lastName = "";
     for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const std::string& hiernamestr = it->first;
-	const std::string& decl = it->second;
+        const std::string& hiernamestr = it->first;
+        const std::string& decl = it->second;
 
-	// Determine difference between the old and new names
-	const char* hiername = hiernamestr.c_str();
-	const char* lp = lastName;
-	const char* np = hiername;
-	lastName = hiername;
+        // Determine difference between the old and new names
+        const char* hiername = hiernamestr.c_str();
+        const char* lp = lastName;
+        const char* np = hiername;
+        lastName = hiername;
 
-	// Skip common prefix, it must break at a space or tab
-	for (; *np && (*np == *lp); np++, lp++) {}
-	while (np!=hiername && *np && *np!=' ' && *np!='\t') { np--; lp--; }
-	//printf("hier %s\n  lp=%s\n  np=%s\n",hiername,lp,np);
+        // Skip common prefix, it must break at a space or tab
+        for (; *np && (*np == *lp); np++, lp++) {}
+        while (np!=hiername && *np && *np!=' ' && *np!='\t') { np--; lp--; }
+        //printf("hier %s\n  lp=%s\n  np=%s\n",hiername,lp,np);
 
-	// Any extra spaces in last name are scope ups we need to do
-	bool first = true;
-	for (; *lp; lp++) {
-	    if (*lp==' ' || (first && *lp!='\t')) {
-		printIndent(-1);
-		printStr("$upscope $end\n");
-	    }
-	    first = false;
-	}
+        // Any extra spaces in last name are scope ups we need to do
+        bool first = true;
+        for (; *lp; lp++) {
+            if (*lp==' ' || (first && *lp!='\t')) {
+                printIndent(-1);
+                printStr("$upscope $end\n");
+            }
+            first = false;
+        }
 
-	// Any new spaces are scope downs we need to do
-	while (*np) {
-	    if (*np==' ') np++;
-	    if (*np=='\t') break; // tab means signal name starts
-	    printIndent(1);
-	    printStr("$scope module ");
-	    for (; *np && *np!=' ' && *np!='\t'; np++) {
-		if (*np=='[') printStr("(");
-		else if (*np==']') printStr(")");
-		else *m_writep++=*np;
-	    }
-	    printStr(" $end\n");
-	}
+        // Any new spaces are scope downs we need to do
+        while (*np) {
+            if (*np==' ') np++;
+            if (*np=='\t') break;  // tab means signal name starts
+            printIndent(1);
+            printStr("$scope module ");
+            for (; *np && *np!=' ' && *np!='\t'; np++) {
+                if (*np=='[') printStr("(");
+                else if (*np==']') printStr(")");
+                else *m_writep++=*np;
+            }
+            printStr(" $end\n");
+        }
 
-	printIndent(0);
-	printStr(decl.c_str());
+        printIndent(0);
+        printStr(decl.c_str());
     }
 
     while (m_modDepth>1) {
-	printIndent(-1);
-	printStr("$upscope $end\n");
+        printIndent(-1);
+        printStr("$upscope $end\n");
     }
 
     printIndent(-1);
     printStr("$enddefinitions $end\n\n\n");
-    assert (m_modDepth==0);
+    assert(m_modDepth==0);
 
     // Reclaim storage
     deleteNameMap();
 }
 
-void VerilatedVcd::module (const std::string& name) {
+void VerilatedVcd::module(const std::string& name) {
     m_assertOne.check();
     m_modName = name;
 }
 
-void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep,
-			    int arraynum, bool tri, bool bussed, int msb, int lsb) {
+void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
+                           int arraynum, bool tri, bool bussed, int msb, int lsb) {
     if (!code) { VL_FATAL_MT(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); }
 
     int bits = ((msb>lsb)?(msb-lsb):(lsb-msb))+1;
     int codesNeeded = 1+int(bits/32);
-    if (tri) codesNeeded *= 2;   // Space in change array for __en signals
+    if (tri) codesNeeded *= 2;  // Space in change array for __en signals
 
     // Make sure array is large enough
     m_nextCode = std::max(m_nextCode, code+codesNeeded);
     if (m_sigs.capacity() <= m_nextCode) {
-	m_sigs.reserve(m_nextCode*2);	// Power-of-2 allocation speeds things up
+        m_sigs.reserve(m_nextCode*2);  // Power-of-2 allocation speeds things up
     }
 
     // Make sure write buffer is large enough (one character per bit), plus header
@@ -551,14 +550,14 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
     std::string hiername;
     std::string basename;
     for (const char* cp=nameasstr.c_str(); *cp; cp++) {
-	if (isScopeEscape(*cp)) {
-	    // Ahh, we've just read a scope, not a basename
-	    if (hiername!="") hiername += " ";
-	    hiername += basename;
-	    basename = "";
-	} else {
-	    basename += *cp;
-	}
+        if (isScopeEscape(*cp)) {
+            // Ahh, we've just read a scope, not a basename
+            if (hiername!="") hiername += " ";
+            hiername += basename;
+            basename = "";
+        } else {
+            basename += *cp;
+        }
     }
     hiername += "\t"+basename;
 
@@ -569,50 +568,50 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
     sprintf(buf, " %2d ", bits);
     decl += buf;
     if (m_evcd) {
-	sprintf(buf, "<%d", code);
-	decl += buf;
+        sprintf(buf, "<%u", code);
+        decl += buf;
     } else {
-	decl += stringCode(code);
+        decl += stringCode(code);
     }
     decl += " ";
     decl += basename;
     if (arraynum>=0) {
-	sprintf(buf, "(%d)", arraynum);
-	decl += buf;
-	hiername += buf;
+        sprintf(buf, "(%d)", arraynum);
+        decl += buf;
+        hiername += buf;
     }
     if (bussed) {
-	sprintf(buf, " [%d:%d]", msb, lsb);
-	decl += buf;
+        sprintf(buf, " [%d:%d]", msb, lsb);
+        decl += buf;
     }
     decl += " $end\n";
     m_namemapp->insert(std::make_pair(hiername,decl));
 }
 
 void VerilatedVcd::declBit      (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "wire", arraynum, false, false, 0, 0); }
+{  declare(code, name, "wire", arraynum, false, false, 0, 0); }
 void VerilatedVcd::declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declQuad     (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declArray    (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, false, true, msb, lsb); }
 void VerilatedVcd::declTriBit   (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "wire", arraynum, true, false, 0, 0); }
+{  declare(code, name, "wire", arraynum, true, false, 0, 0); }
 void VerilatedVcd::declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
-{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+{  declare(code, name, "wire", arraynum, true, true, msb, lsb); }
 void VerilatedVcd::declFloat    (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "real", arraynum, false, false, 31, 0); }
+{  declare(code, name, "real", arraynum, false, false, 31, 0); }
 void VerilatedVcd::declDouble   (vluint32_t code, const char* name, int arraynum)
-{  declare (code, name, "real", arraynum, false, false, 63, 0); }
+{  declare(code, name, "real", arraynum, false, false, 63, 0); }
 
 //=============================================================================
 
-void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
+void VerilatedVcd::fullDouble(vluint32_t code, const double newval) {
     // cppcheck-suppress invalidPointerCast
     (*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
@@ -621,7 +620,7 @@ void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
     *m_writep++=' '; printCode(code); *m_writep++='\n';
     bufferCheck();
 }
-void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
+void VerilatedVcd::fullFloat(vluint32_t code, const float newval) {
     // cppcheck-suppress invalidPointerCast
     (*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
@@ -634,14 +633,14 @@ void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
 //=============================================================================
 // Callbacks
 
-void VerilatedVcd::addCallback VL_MT_UNSAFE_ONE (
+void VerilatedVcd::addCallback(
     VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb, VerilatedVcdCallback_t changecb,
-    void* userthis)
+    void* userthis) VL_MT_UNSAFE_ONE
 {
     m_assertOne.check();
     if (VL_UNLIKELY(isOpen())) {
-	std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
-	VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
+        std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
+        VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
     }
     VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode);
     m_callbacks.push_back(vci);
@@ -650,37 +649,37 @@ void VerilatedVcd::addCallback VL_MT_UNSAFE_ONE (
 //=============================================================================
 // Dumping
 
-void VerilatedVcd::dumpFull (vluint64_t timeui) {
+void VerilatedVcd::dumpFull(vluint64_t timeui) {
     m_assertOne.check();
-    dumpPrep (timeui);
+    dumpPrep(timeui);
     Verilated::quiesce();
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	(cip->m_fullcb) (this, cip->m_userthis, cip->m_code);
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
     }
 }
 
-void VerilatedVcd::dump (vluint64_t timeui) {
+void VerilatedVcd::dump(vluint64_t timeui) {
     m_assertOne.check();
     if (!isOpen()) return;
     if (VL_UNLIKELY(m_fullDump)) {
-	m_fullDump = false;	// No need for more full dumps
-	dumpFull(timeui);
-	return;
+        m_fullDump = false;  // No need for more full dumps
+        dumpFull(timeui);
+        return;
     }
     if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > this->m_rolloverMB)) {
-	openNext(true);
-	if (!isOpen()) return;
+        openNext(true);
+        if (!isOpen()) return;
     }
-    dumpPrep (timeui);
+    dumpPrep(timeui);
     Verilated::quiesce();
-    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
-	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	(cip->m_changecb) (this, cip->m_userthis, cip->m_code);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
+        VerilatedVcdCallInfo* cip = m_callbacks[ent];
+        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
     }
 }
 
-void VerilatedVcd::dumpPrep (vluint64_t timeui) {
+void VerilatedVcd::dumpPrep(vluint64_t timeui) {
     printStr("#");
     printTime(timeui);
     printStr("\n");
@@ -705,40 +704,40 @@ vluint8_t ch;
 vluint64_t timestamp = 1;
 double doub = 0;
 
-void vcdInit (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdInit(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->scopeEscape('.');
-    vcdp->module ("top");
-     vcdp->declBus (0x2, "v1",-1,5,1);
-     vcdp->declBus (0x3, "v2",-1,6,0);
-     vcdp->module ("top.sub1");
-      vcdp->declBit (0x4, "s1",-1);
-      vcdp->declBit (0x5, "ch",-1);
-     vcdp->module ("top.sub2");
-      vcdp->declArray (0x6, "s2",-1, 40,3);
+    vcdp->module("top");
+     vcdp->declBus(0x2, "v1",-1,5,1);
+     vcdp->declBus(0x3, "v2",-1,6,0);
+     vcdp->module("top.sub1");
+      vcdp->declBit(0x4, "s1",-1);
+      vcdp->declBit(0x5, "ch",-1);
+     vcdp->module("top.sub2");
+      vcdp->declArray(0x6, "s2",-1, 40,3);
     // Note need to add 3 for next code.
-    vcdp->module ("top2");
-     vcdp->declBus (0x2, "t2v1",-1,4,1);
-     vcdp->declTriBit   (0x10, "io1", -1);
-     vcdp->declTriBus   (0x12, "io5", -1,4,0);
-     vcdp->declTriArray (0x16, "io96",-1,95,0);
+    vcdp->module("top2");
+     vcdp->declBus(0x2, "t2v1",-1,4,1);
+     vcdp->declTriBit  (0x10, "io1", -1);
+     vcdp->declTriBus  (0x12, "io5", -1,4,0);
+     vcdp->declTriArray(0x16, "io96",-1,95,0);
     // Note need to add 6 for next code.
-     vcdp->declDouble   (0x1c, "doub",-1);
+     vcdp->declDouble  (0x1c, "doub",-1);
     // Note need to add 2 for next code.
 }
 
-void vcdFull (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdFull(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->fullBus  (0x2, v1,5);
     vcdp->fullBus  (0x3, v2,7);
     vcdp->fullBit  (0x4, s1);
     vcdp->fullBus  (0x5, ch,2);
     vcdp->fullArray(0x6, &s2[0], 38);
-    vcdp->fullTriBit   (0x10, tri96[0]&1,    tri96__tri[0]&1);
-    vcdp->fullTriBus   (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f,  5);
-    vcdp->fullTriArray (0x16, tri96,         tri96__tri,          96);
+    vcdp->fullTriBit  (0x10, tri96[0]&1,    tri96__tri[0]&1);
+    vcdp->fullTriBus  (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f,  5);
+    vcdp->fullTriArray(0x16, tri96,         tri96__tri,          96);
     vcdp->fullDouble(0x1c, doub);
 }
 
-void vcdChange (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdChange(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
     vcdp->chgBus  (0x2, v1,5);
     vcdp->chgBus  (0x3, v2,7);
     vcdp->chgBit  (0x4, s1);
@@ -760,34 +759,34 @@ main() {
     ch = 0;
     doub = 0;
     {
-	VerilatedVcdC* vcdp = new VerilatedVcdC;
-	vcdp->spTrace()->addCallback (&vcdInit, &vcdFull, &vcdChange, 0);
-	vcdp->open ("test.vcd");
-	// Dumping
-	vcdp->dump(timestamp++);
-	v1 = 0xfff;
-	tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
-	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
-	doub = 1.5;
-	vcdp->dump(timestamp++);
-	v2 = 0x1;
-	s2[1] = 2;
-	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0; // enable w/o data change
-	doub = -1.66e13;
-	vcdp->dump(timestamp++);
-	ch = 2;
-	tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
-	doub = -3.33e-13;
-	vcdp->dump(timestamp++);
-	vcdp->dump(timestamp++);
+        VerilatedVcdC* vcdp = new VerilatedVcdC;
+        vcdp->spTrace()->addCallback(&vcdInit, &vcdFull, &vcdChange, 0);
+        vcdp->open("test.vcd");
+        // Dumping
+        vcdp->dump(timestamp++);
+        v1 = 0xfff;
+        tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
+        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
+        doub = 1.5;
+        vcdp->dump(timestamp++);
+        v2 = 0x1;
+        s2[1] = 2;
+        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0;  // enable w/o data change
+        doub = -1.66e13;
+        vcdp->dump(timestamp++);
+        ch = 2;
+        tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
+        doub = -3.33e-13;
+        vcdp->dump(timestamp++);
+        vcdp->dump(timestamp++);
 # ifdef VERILATED_VCD_TEST_64BIT
-	vluint64_t bytesPerDump = 15ULL;
-	for (vluint64_t i=0; i<((1ULL<<32) / bytesPerDump); i++) {
-	    v1 = i;
-	    vcdp->dump(timestamp++);
-	}
+        vluint64_t bytesPerDump = 15ULL;
+        for (vluint64_t i=0; i<((1ULL<<32) / bytesPerDump); i++) {
+            v1 = i;
+            vcdp->dump(timestamp++);
+        }
 # endif
-	vcdp->close();
+        vcdp->close();
     }
 }
 #endif

include/verilated_vcd_c.h

@@ -40,7 +40,7 @@ class VerilatedVcdCallInfo;
 
 class VerilatedVcdFile {
 private:
-    int			m_fd;		///< File descriptor we're writing to
+    int                 m_fd;           ///< File descriptor we're writing to
 public:
     // METHODS
     VerilatedVcdFile() : m_fd(0) {}
@@ -57,10 +57,10 @@ public:
 class VerilatedVcdSig {
 protected:
     friend class VerilatedVcd;
-    vluint32_t		m_code;		///< VCD file code number
-    int			m_bits;		///< Size of value in bits
-    VerilatedVcdSig (vluint32_t code, int bits)
-	: m_code(code), m_bits(bits) {}
+    vluint32_t          m_code;         ///< VCD file code number
+    int                 m_bits;         ///< Size of value in bits
+    VerilatedVcdSig(vluint32_t code, int bits)
+        : m_code(code), m_bits(bits) {}
 public:
     ~VerilatedVcdSig() {}
 };
@@ -76,75 +76,75 @@ typedef void (*VerilatedVcdCallback_t)(VerilatedVcd* vcdp, void* userthis, vluin
 
 class VerilatedVcd {
 private:
-    VerilatedVcdFile*	m_filep;	///< File we're writing to
-    bool		m_fileNewed;	///< m_filep needs destruction
-    bool 		m_isOpen;	///< True indicates open file
-    bool		m_evcd;		///< True for evcd format
-    std::string		m_filename;	///< Filename we're writing to (if open)
-    vluint64_t		m_rolloverMB;	///< MB of file size to rollover at
-    char		m_scopeEscape;	///< Character to separate scope components
-    int			m_modDepth;	///< Depth of module hierarchy
-    bool		m_fullDump;	///< True indicates dump ignoring if changed
-    vluint32_t		m_nextCode;	///< Next code number to assign
-    std::string		m_modName;	///< Module name being traced now
-    double		m_timeRes;	///< Time resolution (ns/ms etc)
-    double		m_timeUnit;	///< Time units (ns/ms etc)
-    vluint64_t		m_timeLastDump;	///< Last time we did a dump
+    VerilatedVcdFile*   m_filep;        ///< File we're writing to
+    bool                m_fileNewed;    ///< m_filep needs destruction
+    bool                m_isOpen;       ///< True indicates open file
+    bool                m_evcd;         ///< True for evcd format
+    std::string         m_filename;     ///< Filename we're writing to (if open)
+    vluint64_t          m_rolloverMB;   ///< MB of file size to rollover at
+    char                m_scopeEscape;  ///< Character to separate scope components
+    int                 m_modDepth;     ///< Depth of module hierarchy
+    bool                m_fullDump;     ///< True indicates dump ignoring if changed
+    vluint32_t          m_nextCode;     ///< Next code number to assign
+    std::string         m_modName;      ///< Module name being traced now
+    double              m_timeRes;      ///< Time resolution (ns/ms etc)
+    double              m_timeUnit;     ///< Time units (ns/ms etc)
+    vluint64_t          m_timeLastDump; ///< Last time we did a dump
 
-    char*		m_wrBufp;	///< Output buffer
-    char*		m_wrFlushp;	///< Output buffer flush trigger location
-    char*		m_writep;	///< Write pointer into output buffer
-    vluint64_t		m_wrChunkSize;	///< Output buffer size
-    vluint64_t		m_wroteBytes;	///< Number of bytes written to this file
+    char*               m_wrBufp;       ///< Output buffer
+    char*               m_wrFlushp;     ///< Output buffer flush trigger location
+    char*               m_writep;       ///< Write pointer into output buffer
+    vluint64_t          m_wrChunkSize;  ///< Output buffer size
+    vluint64_t          m_wroteBytes;   ///< Number of bytes written to this file
 
-    vluint32_t*		m_sigs_oldvalp;	///< Pointer to old signal values
+    vluint32_t*         m_sigs_oldvalp; ///< Pointer to old signal values
     typedef std::vector<VerilatedVcdSig>  SigVec;
-    SigVec		m_sigs;		///< Pointer to signal information
+    SigVec              m_sigs;         ///< Pointer to signal information
     typedef std::vector<VerilatedVcdCallInfo*>  CallbackVec;
-    CallbackVec		m_callbacks;	///< Routines to perform dumping
+    CallbackVec         m_callbacks;    ///< Routines to perform dumping
     typedef std::map<std::string,std::string>  NameMap;
-    NameMap*		m_namemapp;	///< List of names for the header
+    NameMap*            m_namemapp;     ///< List of names for the header
 
     VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
 
     void bufferResize(vluint64_t minsize);
     void bufferFlush() VL_MT_UNSAFE_ONE;
     inline void bufferCheck() {
-	// Flush the write buffer if there's not enough space left for new information
-	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
-	    bufferFlush();
-	}
+        // Flush the write buffer if there's not enough space left for new information
+        // We only call this once per vector, so we need enough slop for a very wide "b###" line
+        if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
+            bufferFlush();
+        }
     }
     void closePrev();
     void closeErr();
     void openNext();
     void makeNameMap();
     void deleteNameMap();
-    void printIndent (int levelchange);
-    void printStr (const char* str);
-    void printQuad (vluint64_t n);
-    void printTime (vluint64_t timeui);
-    void declare (vluint32_t code, const char* name, const char* wirep,
-		  int arraynum, bool tri, bool bussed, int msb, int lsb);
+    void printIndent(int levelchange);
+    void printStr(const char* str);
+    void printQuad(vluint64_t n);
+    void printTime(vluint64_t timeui);
+    void declare(vluint32_t code, const char* name, const char* wirep,
+                 int arraynum, bool tri, bool bussed, int msb, int lsb);
 
     void dumpHeader();
-    void dumpPrep (vluint64_t timeui);
-    void dumpFull (vluint64_t timeui);
+    void dumpPrep(vluint64_t timeui);
+    void dumpFull(vluint64_t timeui);
     // cppcheck-suppress functionConst
-    void dumpDone ();
-    inline void printCode (vluint32_t code) {
-	if (code>=(94*94*94)) *m_writep++ = static_cast<char>((code/94/94/94)%94+33);
-	if (code>=(94*94))    *m_writep++ = static_cast<char>((code/94/94)%94+33);
-	if (code>=(94))       *m_writep++ = static_cast<char>((code/94)%94+33);
-	*m_writep++ = static_cast<char>((code)%94+33);
+    void dumpDone();
+    inline void printCode(vluint32_t code) {
+        if (code>=(94*94*94)) *m_writep++ = static_cast<char>((code/94/94/94)%94+33);
+        if (code>=(94*94))    *m_writep++ = static_cast<char>((code/94/94)%94+33);
+        if (code>=(94))       *m_writep++ = static_cast<char>((code/94)%94+33);
+        *m_writep++ = static_cast<char>((code)%94+33);
     }
-    static std::string stringCode (vluint32_t code) VL_PURE {
-	std::string out;
-	if (code>=(94*94*94)) out += static_cast<char>((code/94/94/94)%94+33);
-	if (code>=(94*94))    out += static_cast<char>((code/94/94)%94+33);
-	if (code>=(94))       out += static_cast<char>((code/94)%94+33);
-	return out + static_cast<char>((code)%94+33);
+    static std::string stringCode(vluint32_t code) VL_PURE {
+        std::string out;
+        if (code>=(94*94*94)) out += static_cast<char>((code/94/94/94)%94+33);
+        if (code>=(94*94))    out += static_cast<char>((code/94/94)%94+33);
+        if (code>=(94))       out += static_cast<char>((code/94)%94+33);
+        return out + static_cast<char>((code)%94+33);
     }
 
     // CONSTRUCTORS
@@ -165,34 +165,34 @@ public:
 
     // METHODS
     void open(const char* filename) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
-    void openNext (bool incFilename);	///< Open next data-only file
+    void openNext(bool incFilename);  ///< Open next data-only file
     void close() VL_MT_UNSAFE_ONE;  ///< Close the file
     /// Flush any remaining data to this file
     void flush() VL_MT_UNSAFE_ONE { bufferFlush(); }
     /// Flush any remaining data from all files
     static void flush_all() VL_MT_UNSAFE_ONE;
 
-    void set_time_unit (const char* unit); ///< Set time units (s/ms, defaults to ns)
-    void set_time_unit (const std::string& unit) { set_time_unit(unit.c_str()); }
+    void set_time_unit(const char* unit);  ///< Set time units (s/ms, defaults to ns)
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
 
-    void set_time_resolution (const char* unit); ///< Set time resolution (s/ms, defaults to ns)
-    void set_time_resolution (const std::string& unit) { set_time_resolution(unit.c_str()); }
+    void set_time_resolution(const char* unit);  ///< Set time resolution (s/ms, defaults to ns)
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
-    double timescaleToDouble (const char* unitp);
-    std::string doubleToTimescale (double value);
+    double timescaleToDouble(const char* unitp);
+    std::string doubleToTimescale(double value);
 
     /// Inside dumping routines, called each cycle to make the dump
-    void dump     (vluint64_t timeui);
+    void dump(vluint64_t timeui);
     /// Call dump with a absolute unscaled time in seconds
-    void dumpSeconds (double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }
+    void dumpSeconds(double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }
 
     /// Inside dumping routines, declare callbacks for tracings
-    void addCallback (VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
-		      VerilatedVcdCallback_t change,
-		      void* userthis) VL_MT_UNSAFE_ONE;
+    void addCallback(VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
+                     VerilatedVcdCallback_t change,
+                     void* userthis) VL_MT_UNSAFE_ONE;
 
     /// Inside dumping routines, declare a module
-    void module (const std::string& name);
+    void module(const std::string& name);
     /// Inside dumping routines, declare a signal
     void declBit      (vluint32_t code, const char* name, int arraynum);
     void declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
@@ -204,192 +204,192 @@ public:
     void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
     void declDouble   (vluint32_t code, const char* name, int arraynum);
     void declFloat    (vluint32_t code, const char* name, int arraynum);
-    //	... other module_start for submodules (based on cell name)
+    //  ... other module_start for submodules (based on cell name)
 
     /// Inside dumping routines, dump one signal
-    void fullBit (vluint32_t code, const vluint32_t newval) {
-	// Note the &1, so we don't require clean input -- makes more common no change case faster
-	m_sigs_oldvalp[code] = newval;
-	*m_writep++=('0'+static_cast<char>(newval&1)); printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullBit(vluint32_t code, const vluint32_t newval) {
+        // Note the &1, so we don't require clean input -- makes more common no change case faster
+        m_sigs_oldvalp[code] = newval;
+        *m_writep++=('0'+static_cast<char>(newval&1)); printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullBus (vluint32_t code, const vluint32_t newval, int bits) {
-	m_sigs_oldvalp[code] = newval;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval&(1L<<bit))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullBus(vluint32_t code, const vluint32_t newval, int bits) {
+        m_sigs_oldvalp[code] = newval;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval&(1L<<bit))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval&(1ULL<<bit))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval&(1ULL<<bit))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullArray (vluint32_t code, const vluint32_t* newval, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    m_sigs_oldvalp[code+word] = newval[word];
-	}
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++=((newval[(bit/32)]&(1L<<(bit&0x1f)))?'1':'0');
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            m_sigs_oldvalp[code+word] = newval[word];
+        }
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++=((newval[(bit/32)]&(1L<<(bit&0x1f)))?'1':'0');
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
-	m_sigs_oldvalp[code]   = newval;
-	m_sigs_oldvalp[code+1] = newtri;
-	*m_writep++ = "01zz"[m_sigs_oldvalp[code]
-			     | (m_sigs_oldvalp[code+1]<<1)];
-	printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
+        m_sigs_oldvalp[code]   = newval;
+        m_sigs_oldvalp[code+1] = newtri;
+        *m_writep++ = "01zz"[m_sigs_oldvalp[code]
+                             | (m_sigs_oldvalp[code+1]<<1)];
+        printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
-	m_sigs_oldvalp[code] = newval;
-	m_sigs_oldvalp[code+1] = newtri;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++ = "01zz"[((newval >> bit)&1)
-				 | (((newtri >> bit)&1)<<1)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
+        m_sigs_oldvalp[code] = newval;
+        m_sigs_oldvalp[code+1] = newtri;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++ = "01zz"[((newval >> bit)&1)
+                                 | (((newtri >> bit)&1)<<1)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
-	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) = newtri;
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++ = "01zz"[((newval >> bit)&1ULL)
-				 | (((newtri >> bit)&1ULL)<<1ULL)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
+        (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) = newtri;
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++ = "01zz"[((newval >> bit)&1ULL)
+                                 | (((newtri >> bit)&1ULL)<<1ULL)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    m_sigs_oldvalp[code+word*2]   = newvalp[word];
-	    m_sigs_oldvalp[code+word*2+1] = newtrip[word];
-	}
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    vluint32_t valbit = (newvalp[(bit/32)]>>(bit&0x1f)) & 1;
-	    vluint32_t tribit = (newtrip[(bit/32)]>>(bit&0x1f)) & 1;
-	    *m_writep++ = "01zz"[valbit | (tribit<<1)];
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            m_sigs_oldvalp[code+word*2]   = newvalp[word];
+            m_sigs_oldvalp[code+word*2+1] = newtrip[word];
+        }
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            vluint32_t valbit = (newvalp[(bit/32)]>>(bit&0x1f)) & 1;
+            vluint32_t tribit = (newtrip[(bit/32)]>>(bit&0x1f)) & 1;
+            *m_writep++ = "01zz"[valbit | (tribit<<1)];
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    void fullDouble (vluint32_t code, const double newval);
-    void fullFloat (vluint32_t code, const float newval);
+    void fullDouble(vluint32_t code, const double newval);
+    void fullFloat(vluint32_t code, const float newval);
 
     /// Inside dumping routines, dump one signal as unknowns
     /// Presently this code doesn't change the oldval vector.
     /// Thus this is for special standalone applications that after calling
     /// fullBitX, must when then value goes non-X call fullBit.
-    inline void fullBitX (vluint32_t code) {
-	*m_writep++='x'; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    inline void fullBitX(vluint32_t code) {
+        *m_writep++='x'; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    inline void fullBusX (vluint32_t code, int bits) {
-	*m_writep++='b';
-	for (int bit=bits-1; bit>=0; --bit) {
-	    *m_writep++='x';
-	}
-	*m_writep++=' '; printCode(code); *m_writep++='\n';
-	bufferCheck();
+    inline void fullBusX(vluint32_t code, int bits) {
+        *m_writep++='b';
+        for (int bit=bits-1; bit>=0; --bit) {
+            *m_writep++='x';
+        }
+        *m_writep++=' '; printCode(code); *m_writep++='\n';
+        bufferCheck();
     }
-    inline void fullQuadX (vluint32_t code, int bits) { fullBusX (code, bits); }
-    inline void fullArrayX (vluint32_t code, int bits) { fullBusX (code, bits); }
+    inline void fullQuadX(vluint32_t code, int bits) { fullBusX(code, bits); }
+    inline void fullArrayX(vluint32_t code, int bits) { fullBusX(code, bits); }
 
     /// Inside dumping routines, dump one signal if it has changed
-    inline void chgBit (vluint32_t code, const vluint32_t newval) {
-	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
-	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
-		fullBit (code, newval);
-	    }
-	}
+    inline void chgBit(vluint32_t code, const vluint32_t newval) {
+        vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
+            if (VL_UNLIKELY(diff & 1)) {  // Change after clean?
+                fullBit(code, newval);
+            }
+        }
     }
-    inline void chgBus (vluint32_t code, const vluint32_t newval, int bits) {
-	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
-		fullBus (code, newval, bits);
-	    }
-	}
+    inline void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
+        vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+                fullBus(code, newval, bits);
+            }
+        }
     }
-    inline void chgQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval;
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
-		fullQuad(code, newval, bits);
-	    }
-	}
+    inline void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
+        vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval;
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+                fullQuad(code, newval, bits);
+            }
+        }
     }
-    inline void chgArray (vluint32_t code, const vluint32_t* newval, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    if (VL_UNLIKELY(m_sigs_oldvalp[code+word] ^ newval[word])) {
-		fullArray (code,newval,bits);
-		return;
-	    }
-	}
+    inline void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            if (VL_UNLIKELY(m_sigs_oldvalp[code+word] ^ newval[word])) {
+                fullArray(code,newval,bits);
+                return;
+            }
+        }
     }
-    inline void chgTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
-	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
-			 | (m_sigs_oldvalp[code+1] ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
-	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
-		fullTriBit (code, newval, newtri);
-	    }
-	}
+    inline void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
+        vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+                         | (m_sigs_oldvalp[code+1] ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
+            if (VL_UNLIKELY(diff & 1)) {  // Change after clean?
+                fullTriBit(code, newval, newtri);
+            }
+        }
     }
-    inline void chgTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
-	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
-			 | (m_sigs_oldvalp[code+1] ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
-		fullTriBus (code, newval, newtri, bits);
-	    }
-	}
+    inline void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
+        vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+                         | (m_sigs_oldvalp[code+1] ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+                fullTriBus(code, newval, newtri, bits);
+            }
+        }
     }
-    inline void chgTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	vluint64_t diff = ( ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval)
-			    | ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) ^ newtri));
-	if (VL_UNLIKELY(diff)) {
-	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
-		fullTriQuad(code, newval, newtri, bits);
-	    }
-	}
+    inline void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
+        vluint64_t diff = ( ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval)
+                            | ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) ^ newtri));
+        if (VL_UNLIKELY(diff)) {
+            if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+                fullTriQuad(code, newval, newtri, bits);
+            }
+        }
     }
-    inline void chgTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
-	for (int word=0; word<(((bits-1)/32)+1); ++word) {
-	    if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word])
-			    | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) {
-		fullTriArray (code,newvalp,newtrip,bits);
-		return;
-	    }
-	}
+    inline void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
+        for (int word=0; word<(((bits-1)/32)+1); ++word) {
+            if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word])
+                            | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) {
+                fullTriArray(code,newvalp,newtrip,bits);
+                return;
+            }
+        }
     }
-    inline void chgDouble (vluint32_t code, const double newval) {
-	// cppcheck-suppress invalidPointerCast
-	if (VL_UNLIKELY((*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) != newval)) {
-	    fullDouble (code, newval);
-	}
+    inline void chgDouble(vluint32_t code, const double newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY((*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) != newval)) {
+            fullDouble(code, newval);
+        }
     }
-    inline void chgFloat (vluint32_t code, const float newval) {
-	// cppcheck-suppress invalidPointerCast
-	if (VL_UNLIKELY((*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) != newval)) {
-	    fullFloat (code, newval);
-	}
+    inline void chgFloat(vluint32_t code, const float newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY((*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) != newval)) {
+            fullFloat(code, newval);
+        }
     }
 
 protected:
@@ -404,7 +404,7 @@ protected:
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE
 
 class VerilatedVcdC {
-    VerilatedVcd		m_sptrace;	///< Trace file being created
+    VerilatedVcd m_sptrace;  ///< Trace file being created
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedVcdC);
@@ -431,23 +431,23 @@ public:
     /// Flush dump
     void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
     /// Write one cycle of dump data
-    void dump (vluint64_t timeui) { m_sptrace.dump(timeui); }
+    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
     /// Write one cycle of dump data - backward compatible and to reduce
     /// conversion warnings.  It's better to use a vluint64_t time instead.
-    void dump (double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
-    void dump (vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
-    void dump (int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     /// Set time units (s/ms, defaults to ns)
     /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
-    void set_time_unit (const char* unit) { m_sptrace.set_time_unit(unit); }
-    void set_time_unit (const std::string& unit) { set_time_unit(unit.c_str()); }
+    void set_time_unit(const char* unit) { m_sptrace.set_time_unit(unit); }
+    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
     /// Set time resolution (s/ms, defaults to ns)
     /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
-    void set_time_resolution (const char* unit) { m_sptrace.set_time_resolution(unit); }
-    void set_time_resolution (const std::string& unit) { set_time_resolution(unit.c_str()); }
+    void set_time_resolution(const char* unit) { m_sptrace.set_time_resolution(unit); }
+    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
 
     /// Internal class access
-    inline VerilatedVcd* spTrace () { return &m_sptrace; };
+    inline VerilatedVcd* spTrace() { return &m_sptrace; };
 };
 
-#endif // guard
+#endif  // guard

include/verilated_vcd_sc.cpp

@@ -31,8 +31,8 @@
 #if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const std::string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const char **) {}
+void VerilatedVcdSc::write_comment(const std::string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const std::string &, const char **) {}
 
 # define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const std::string& name ) {}
@@ -81,8 +81,8 @@ void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const cha
 #elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+void VerilatedVcdSc::write_comment(const sc_string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const sc_string &, const char **) {}
 
 #define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}
@@ -124,8 +124,8 @@ void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char
 #else
     // SystemC 1.2.1beta
 // cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment (const sc_string &) {}
-void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
+void VerilatedVcdSc::write_comment(const sc_string &) {}
+void VerilatedVcdSc::trace(const unsigned int &, const sc_string &, const char **) {}
 
 #define DECL_TRACE_METHOD_A(tp) \
     void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}

include/verilated_vcd_sc.h

@@ -43,33 +43,33 @@ class VerilatedVcdSc
     VL_UNCOPYABLE(VerilatedVcdSc);
 public:
     VerilatedVcdSc() {
-	sc_get_curr_simcontext()->add_trace_file(this);
+        sc_get_curr_simcontext()->add_trace_file(this);
 # if (SYSTEMC_VERSION>=20060505)
-	// We want to avoid a depreciated warning, but still be back compatible.
-	// Turning off the message just for this still results in an annoying "to turn off" message.
-	sc_time t1sec(1,SC_SEC);
-	if (t1sec.to_default_time_units()!=0) {
-	    sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC);
-	    spTrace()->set_time_unit(tunits.to_string());
-	}
-	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+        // We want to avoid a depreciated warning, but still be back compatible.
+        // Turning off the message just for this still results in an annoying "to turn off" message.
+        sc_time t1sec(1,SC_SEC);
+        if (t1sec.to_default_time_units()!=0) {
+            sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC);
+            spTrace()->set_time_unit(tunits.to_string());
+        }
+        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
 # elif (SYSTEMC_VERSION>20011000)
-	// To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
-	// we allow both flavors with overloaded set_time_* functions.
-	spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
-	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+        // To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
+        // we allow both flavors with overloaded set_time_* functions.
+        spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
+        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
 # endif
     }
     virtual ~VerilatedVcdSc() {}
 
     // METHODS
     /// Called by SystemC simulate()
-    virtual void cycle (bool delta_cycle) {
+    virtual void cycle(bool delta_cycle) {
 # if (SYSTEMC_VERSION>20011000)
-	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
 # else
-	// VCD files must have integer timestamps, so we write all times in increments of time_resolution
-	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+        // VCD files must have integer timestamps, so we write all times in increments of time_resolution
+        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
 # endif
     }
 
@@ -78,10 +78,10 @@ private:
 
 #ifdef NC_SYSTEMC
     // Cadence Incisive has these as abstract functions so we must create them
-    virtual void set_time_unit( int exponent10_seconds ) {} // deprecated
+    virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
 #endif
 #if defined(NC_SYSTEMC) || (SYSTEMC_VERSION>=20111100)
-    virtual void set_time_unit( double v, sc_time_unit tu ) {}
+    virtual void set_time_unit(double v, sc_time_unit tu) {}
 #endif
 
 
@@ -89,12 +89,12 @@ private:
 # if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const std::string& name );
+    virtual void trace(const tp& object, const std::string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const std::string& name, int width );
+    virtual void trace(const tp& object, const std::string& name, int width);
 
-    virtual void write_comment (const std::string &);
-    virtual void trace (const unsigned int &, const std::string &, const char **);
+    virtual void write_comment(const std::string &);
+    virtual void trace(const unsigned int &, const std::string &, const char **);
 
 #if (SYSTEMC_VERSION>=20171012)
     DECL_TRACE_METHOD_A( sc_event )
@@ -138,14 +138,14 @@ private:
 # elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const sc_string& name );
+    virtual void trace(const tp& object, const sc_string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const sc_string& name, int width );
+    virtual void trace(const tp& object, const sc_string& name, int width);
 
-    virtual void write_comment (const sc_string &);
-    virtual void trace (const unsigned int &, const sc_string &, const char **);
-    virtual void delta_cycles (bool) {}
-    virtual void space( int n ) {}
+    virtual void write_comment(const sc_string &);
+    virtual void trace(const unsigned int &, const sc_string &, const char **);
+    virtual void delta_cycles(bool) {}
+    virtual void space(int n) {}
 
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_A( sc_bit )
@@ -182,12 +182,12 @@ private:
 # else
     // SystemC 1.2.1beta
 # define DECL_TRACE_METHOD_A(tp) \
-    virtual void trace( const tp& object, const sc_string& name );
+    virtual void trace(const tp& object, const sc_string& name);
 # define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace( const tp& object, const sc_string& name, int width );
+    virtual void trace(const tp& object, const sc_string& name, int width);
 
-    virtual void write_comment (const sc_string &);
-    virtual void trace (const unsigned int &, const sc_string &, const char **);
+    virtual void write_comment(const sc_string &);
+    virtual void trace(const unsigned int &, const sc_string &, const char **);
 
     DECL_TRACE_METHOD_A( bool )
     DECL_TRACE_METHOD_B( unsigned char )
@@ -220,4 +220,4 @@ private:
 # undef DECL_TRACE_METHOD_B
 };
 
-#endif // guard
+#endif  // Guard

include/verilated_vpi.cpp

@@ -1884,7 +1884,7 @@ PLI_INT32 vpi_free_object(vpiHandle object) {
     return vpi_release_handle(object);  // Deprecated
 }
 
-PLI_INT32 vpi_release_handle (vpiHandle object) {
+PLI_INT32 vpi_release_handle(vpiHandle object) {
     VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_release_handle %p\n",object););
     VerilatedVpiImp::assertOneCheck();
     VerilatedVpio* vop = VerilatedVpio::castp(object);

include/verilatedos.h

@@ -157,21 +157,23 @@
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
 # define VL_EQ_DELETE = delete
-# define VL_HAS_UNIQUE_PTR
-# define VL_HAS_UNORDERED_MAP
-# define VL_HAS_UNORDERED_SET
 # define vl_unique_ptr std::unique_ptr
-# define vl_unordered_map std::unordered_map
-# define vl_unordered_set std::unordered_set
-# define VL_INCLUDE_UNORDERED_MAP <unordered_map>
-# define VL_INCLUDE_UNORDERED_SET <unordered_set>
+// By default we use std:: types in C++11.
+// Define VL_USE_UNORDERED_TYPES to test these pre-C++11 classes
+# ifdef VL_USE_UNORDERED_TYPES
+#  define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
+#  define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
+# else
+#  define vl_unordered_map std::unordered_map
+#  define vl_unordered_set std::unordered_set
+#  define VL_INCLUDE_UNORDERED_MAP <unordered_map>
+#  define VL_INCLUDE_UNORDERED_SET <unordered_set>
+# endif
 #else
 # define VL_EQ_DELETE
 # define vl_unique_ptr std::auto_ptr
-# define vl_unordered_map std::map
-# define vl_unordered_set std::set
-# define VL_INCLUDE_UNORDERED_MAP <map>
-# define VL_INCLUDE_UNORDERED_SET <set>
+# define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
+# define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
 #endif
 
 //=========================================================================
@@ -204,6 +206,7 @@
 #elif defined(__CYGWIN__)
 
 # include <stdint.h>
+# include <sys/types.h>  // __WORDSIZE
 typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward compatibility)
 typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
@@ -249,6 +252,7 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 # include <stdint.h>	// Linux and most flavors
 # include <unistd.h>	// Linux ssize_t
 # include <inttypes.h>	// Solaris
+# include <sys/types.h>  // __WORDSIZE
 typedef uint8_t			vluint8_t;	///< 32-bit unsigned type
 typedef uint16_t		vluint16_t;	///< 32-bit unsigned type
 typedef int			vlsint32_t;	///< 32-bit signed type
@@ -356,21 +360,19 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 //=========================================================================
 // Performance counters
 
-#if VL_THREADED
 /// The vluint64_t argument is loaded with a high-performance counter for profiling
 /// or 0x0 if not implemeted on this platform
-# if defined(__i386__) || defined(__x86_64__)
-#  define VL_RDTSC(val) {  \
+#if defined(__i386__) || defined(__x86_64__)
+# define VL_RDTSC(val) {  \
     vluint32_t hi, lo;  \
     asm volatile("rdtsc" : "=a" (lo), "=d" (hi));  \
     (val) = ((vluint64_t)lo) | (((vluint64_t)hi)<<32);  \
 }
-# elif defined(__aarch64__)
-#  define VL_RDTSC(val) asm volatile("mrs %[rt],PMCCNTR_EL0" : [rt] "=r" (val));
-# else
+#elif defined(__aarch64__)
+# define VL_RDTSC(val) asm volatile("mrs %[rt],PMCCNTR_EL0" : [rt] "=r" (val));
+#else
 // We just silently ignore unknown OSes, as only leads to missing statistics
-#  define VL_RDTSC(val) (val) = 0;
-# endif
+# define VL_RDTSC(val) (val) = 0;
 #endif
 
 //=========================================================================

internals.pod

@@ -155,6 +155,221 @@ provided and documented in C<V3GraphAlg.cpp>.
 
 =back
 
+=head2 Multithreaded Mode
+
+In --threads mode, the frontend of the Verilator pipeline is the same as
+serial mode, up until V3Order.
+
+V3Order builds a fine-grained, statement-level dependency graph that governs
+the ordering of code within a single eval() call. In serial mode, that
+dependency graph is used to order all statements into a total serial order.
+In parallel mode, the same dependency graph is the starting point for a
+partitioner (V3Partition).
+
+The partitioner's goal is to coarsen the fine-grained DAG into a coarser
+DAG, while maintaining as much available parallelism as possible. Often the
+partitioner can transform an input graph with millions of nodes into a
+coarsened execution graph with a few dozen nodes, while maintaining enough
+parallelism to take advantage of a modern multicore CPU. Runtime
+synchronization cost is not prohibitive with so few nodes.
+
+=head3 Partitioning
+
+Our partitioner is similar to the one Vivek Sarkar described in his 1989
+paper "Partitioning and Scheduling Parallel Programs for Multiprocessors".
+
+Let's define some terms:
+
+=over 4
+
+=item C<Par Factor>
+
+The available parallelism or "par-factor" of a DAG is the total cost to
+execute all nodes, divided by the cost to execute the longest critical path
+through the graph. This is the speedup you would get from running the graph
+in parallel, if given infinite CPU cores available and communication and
+synchronization are zero.
+
+=item C<Macro Task>
+
+When the partitioner coarsens the graph, it combines nodes together. Each
+fine-grained node represents an atomic "task"; combined nodes in the
+coarsened graph are "macro-tasks". This term comes from Sarkar. Each
+macro-task executes from start to end on one processor, without any
+synchronization to any other macro-task during its
+execution. (Synchronization only happens before the macro-task begins or
+after it ends.)
+
+=item C<Edge Contraction>
+
+Our partitioner, like Sarkar's, primarily relies on "edge contraction" to
+coarsen the graph. It starts with one macro-task per atomic task and
+iteratively combines pairs of edge-connected macro-tasks.
+
+=item C<Local Critical Path>
+
+Each node in the graph has a "local" critical path. That's the critical
+path from the start of the graph to the start of the node, plus the node's
+cost, plus the critical path from the end of the node to the end of the
+graph.
+
+=back
+
+Sarkar calls out an important trade-off: coarsening the graph reduces
+runtime synchronization overhead among the macro-tasks, but it tends to
+increase the critical path through the graph and thus reduces par-factor.
+
+Sarkar's partitioner, and ours, chooses pairs of macro-tasks to merge such
+that the growth in critical path is minimized. Each candidate merge would
+result in a new node, which would have some local critical path. We choose
+the candidate that would produce the shortest local critical path. Repeat
+until par-factor falls to a target threshold. It's a greedy algorithm, and
+it's not guaranteed to produce the best partition (which Sarkar proves is
+NP-hard).
+
+=head3 Estimating Logic Costs
+
+To compute the cost of any given path through the graph, Verilator
+estimates an execution cost for each task. Each macro-task has an execution
+cost which is simply the sum of its tasks' costs. We assume that
+communication overhead and synchronization overhead are zero, so the cost
+of any given path through the graph is simply the sum of macro-task
+execution costs. Sarkar does almost the same thing, except that he has
+nonzero estimates for synchronization costs.
+
+Verilator's cost estimates are assigned by the InstrCountCostVisitor.  This
+class is perhaps the most fragile piece of the multithread implementation.
+It's easy to have a bug where you count something cheap (eg. accessing one
+element of a huge array) as if it were expensive (eg. by counting it as if
+it were an access to the entire array.) Even without such gross bugs, the
+estimates this produce are only loosely predictive of actual runtime cost.
+Multithread performance would be better with better runtime costs
+estimates.  This is an area to improve.
+
+=head3 Scheduling Macro-Tasks at Runtime
+
+After coarsening the graph, we must schedule the macro-tasks for runtime.
+Sarkar describes two options: you can dynamically schedule tasks at
+runtime, with a runtime graph follower. Sarkar calls this the
+"macro-dataflow model."  Verilator does not support this; early experiments
+with this approach had poor performance.
+
+The other option is to statically assign macro-tasks to threads, with each
+thread running its macro-tasks in a static order. Sarkar describes this in
+Chapter 5. Verilator takes this static approach. The only dynamic aspect is
+that each macro task may block before starting, to wait until its
+prerequisites on other threads have finished.
+
+The synchronization cost is cheap if the prereqs are done. If they're not,
+fragmentation (idle CPU cores waiting) is possible. This is the major
+source of overhead in this approach. The --prof-threads switch and the
+C<verilator_gantt> script can visualize the time lost to such
+fragmentation.
+
+=head3 Locating Variables for Best Spatial Locality
+
+After scheduling all code, we attempt to locate variables in memory such
+that variables accessed by a single macro-task are close together in
+memory.  This provides "spatial locality" -- when we pull in a 64-byte
+cache line to access a 2-byte variable, we want the other 62 bytes to be
+ones we'll also likely access soon, for best cache performance.
+
+This turns out to be critical for performance. It should allow Verilator
+to scale to very large models. We don't rely on our working set fitting
+in any CPU cache; instead we essentially "stream" data into caches from
+memory. It's not literally streaming, where the address increases
+monotonically, but it should have similar performance characteristics,
+so long as each macro-task's dataset fits in one core's local caches.
+
+To achieve spatial locality, we tag each variable with the set of
+macro-tasks that access it. Let's call this set the "footprint" of that
+variable. The variables in a given module have a set of footprints. We can
+order those footprints to minimize the distance between them (distance is
+the number of macro-tasks that are different across any two footprints) and
+then emit all variables into the struct in ordered-footprint order.
+
+The footprint ordering is literally the traveling salesman problem, and we
+use a TSP-approximation algorithm to get close to an optimal sort.
+
+This is an old idea. Simulators designed at DEC in the early 1990s used
+similar techniques to optimize both single-thread and multi-thread modes.
+(Verilator does not optimize variable placement for spatial locality in
+serial mode; that is a possible area for improvement.)
+
+=head3 Improving Multithreaded Performance Further (a TODO list)
+
+=over 4
+
+=item C<Wave Scheduling>
+
+To allow the verilated model to run in parallel with the testbench, it
+might be nice to support "wave" scheduling, in which work on a cycle begins
+before eval() is called or continues after eval() returns.  For now all
+work on a cycle happens during the eval() call, leaving Verilator's threads
+idle while the testbench (everything outside eval()) is working. This would
+involve fundamental changes within the partitioner, however, it's probably
+the best bet for hiding testbench latency.
+
+=item C<Efficient Dynamic Scheduling>
+
+To scale to more than a few threads, we may revisit a fully dynamic
+scheduler. For large (>16 core) systems it might make sense to dedicate an
+entire core to scheduling, so that scheduler data structures would fit in
+its L1 cache and thus the cost of traversing priority-ordered ready lists
+would not be prohibitive.
+
+=item C<Static Scheduling with Runtime Repack>
+
+We could modify the static scheduling approach by gathering actual
+macro-task execution times at run time, and dynamically re-packing the
+macro-tasks into the threads also at run time. Say, re-pack once every
+10,000 cycles or something. This has the potential to do better than our
+static estimates about macro-task run times. It could potentially react to
+CPU cores that aren't performing equally, due to NUMA or thermal throttling
+or nonuniform competing memory traffic or whatever.
+
+=item C<Clock Domain Balancing>
+
+Right now Verilator makes no attempt to balance clock domains across
+macro-tasks. For a multi-domain model, that could lead to bad gantt chart
+fragmentation. This could be improved if it's a real problem in practice.
+
+=item C<Other Forms of MTask Balancing>
+
+The largest source of runtime overhead is idle CPUs, which happens due to
+variance between our predicted runtime for each MTask and its actual
+runtime. That variance is magnified if MTasks are homogeneous, containing
+similar repeating logic which was generally close together in source code
+and which is still packed together even after going through Verilator's
+digestive tract.
+
+If Verilator could avoid doing that, and instead would take source logic
+that was close together and distribute it across MTasks, that would
+increase the diversity of any given MTask, and this should reduce variance
+in the cost estimates.
+
+One way to do that might be to make various "tie breaker" comparison
+routines in the sources to rely more heavily on randomness, and generally
+try harder not to keep input nodes together when we have the option to
+scramble things.
+
+=item C<Performance Regression>
+
+It would be nice if we had a regression of large designs, with some
+diversity of design styles, to test on both single- and multi-threaded
+modes. This would help to avoid performance regressions, and also to
+evaluate the optimizations while minimizing the impact of parasitic noise.
+
+=item C<Per-Instance Classes>
+
+If we have multiple instances of the same module, and they partition
+differently (likely; we make no attempt to partition them the same) then
+the variable sort will be suboptimal for either instance.  A possible
+improvement would be to emit a unique class for each instance of a module,
+and sort its variables optimally for that instance's code stream.
+
+=back
+
 =head2 Verilated Flow
 
 The evaluation loop outputted by Verilator is designed to allow a single
@@ -268,8 +483,8 @@ technique lifted from graph traversal packages).
 A visitor first clears the one it wants to use by calling
 C<AstNode::user#ClearTree()>, then it can mark any node's user() with whatever
 data it wants.  Readers just call C<< nodep->user() >>, but may need to cast
-appropriately, so you'll often see C<< nodep->userp()->castSOMETYPE() >>.  At
-the top of each visitor are comments describing how the C<user()> stuff
+appropriately, so you'll often see C<< VN_CAST(nodep->userp(), SOMETYPE) >>.
+At the top of each visitor are comments describing how the C<user()> stuff
 applies to that visitor class.  For example:
 
     // NODE STATE
@@ -299,16 +514,13 @@ as it slows the program down to have to pass vup everywhere.)
 
 =head2 Iterators
 
-C<AstNode> provides a set of iterators to facilitate walking over the
-tree. Each takes two arguments, a visitor, C<v>, of type C<AstNVisitor> and
-an optional pointer user data, C<vup>, of type C<AstNUser*>. The second is
-one of the ways to pass parameters to visitors described in L</Visitor
-Functions>, but its use is now deprecated and should I<not> be used for new
-visitor classes.
+C<AstNVisitor> provides a set of iterators to facilitate walking over the
+tree. Each operates on the current C<AstNVisitor> class (as this) and takes
+an argument type C<AstNode*>.
 
 =over 4
 
-=item C<iterate()>
+=item C<iterate>
 
 This just applies the C<accept> method of the C<AstNode> to the visitor
 function.
@@ -349,9 +561,9 @@ to be aware that calling iteration may cause the children to change.  For
 example:
 
     // nodep->lhsp() is 0x1234000
-    nodep->lhsp()->iterateAndNext(...);  // and under covers nodep->lhsp() changes
+    iterateAndNextNull(nodep->lhsp());  // and under covers nodep->lhsp() changes
     // nodep->lhsp() is 0x5678400
-    nodep->lhsp()->iterateAndNext(...);
+    iterateAndNextNull(nodep->lhsp());
 
 Will work fine, as even if the first iterate causes a new node to take the
 place of the lhsp(), that edit will update nodep->lhsp() and the second
@@ -359,9 +571,9 @@ call will correctly see the change. Alternatively:
 
     lp = nodep->lhsp();
     // nodep->lhsp() is 0x1234000, lp is 0x1234000
-    lp->iterateAndNext(...); **lhsp=NULL;** // and under covers nodep->lhsp() changes
+    iterateAndNextNull(lp); **lhsp=NULL;**  // and under covers nodep->lhsp() changes
     // nodep->lhsp() is 0x5678400, lp is 0x1234000
-    lp->iterateAndNext(...);
+    iterateAndNextNull(lp);
 
 This will cause bugs or a core dump, as lp is a dangling pointer.  Thus it
 is advisable to set lhsp=NULL shown in the *'s above to make sure these
@@ -370,7 +582,7 @@ V3Width is to use acceptSubtreeReturnEdits, which operates on a single node
 and returns the new pointer if any.  Note acceptSubtreeReturnEdits does not
 follow nextp() links.
 
-    lp = lp->acceptSubtreeReturnEdits()
+    lp = acceptSubtreeReturnEdits(lp)
 
 =head2 Identifying derived classes
 
@@ -379,16 +591,16 @@ dealing with. For example a visitor might not implement separate C<visit>
 methods for C<AstIf> and C<AstGenIf>, but just a single method for the base
 class:
 
-  void visit (AstNodeIf* nodep, AstNUser* vup)
+  void visit (AstNodeIf* nodep)
 
 However that method might want to specify additional code if it is called
-for C<AstGenIf>. Verilator does this by providing a C<castSOMETYPE()>
+for C<AstGenIf>. Verilator does this by providing a C<VN_CAST>
 method for each possible node type, using C++ C<dynamic_cast>. This either
 returns a pointer to the object cast to that type (if it is of class
 C<SOMETYPE>, or a derived class of C<SOMETYPE>) or else NULL. So our
 C<visit> method could use:
 
-  if (nodep->castAstGenIf()) {
+  if (VN_CAST(nodep, AstGenIf) {
       <code specific to AstGenIf>
   }
 

nodist/dot_importer

@@ -33,7 +33,7 @@ if (! GetOptions (
 }
 
 dotread ($opt_filename);
-cwrite ("graph_export.cpp");
+cwrite("graph_export.cpp");
 
 #----------------------------------------------------------------------
 

nodist/git_untabify

@@ -0,0 +1,177 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+use Getopt::Long;
+#use Data::Dumper; $Data::Dumper::Indent=1; $Data::Dumper::Sortkeys=1; #Debug
+use IO::File;
+use IO::Dir;
+use Pod::Usage;
+use strict;
+use vars qw ($Debug);
+
+our $VERSION = '0.001';
+
+#======================================================================
+# main
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config ("no_auto_abbrev");
+if (! GetOptions (
+          "debug"       => sub { $Debug = 1; },
+          "help"        => sub { print "Version $VERSION\n";
+                                 pod2usage(-verbose=>2, -exitval => 2, output=>\*STDOUT, -noperldoc=>1); },
+          "version"     => sub { print "Version $VERSION\n"; exit(0); },
+          "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
+    )) {
+    die "%Error: Bad usage, try 'git_untabify --help'\n";
+}
+
+read_patch();
+
+#######################################################################
+
+sub read_patch {
+    my $filename = undef;
+    my $lineno = 0;
+    my $editlines = {};
+    while (defined(my $line = <STDIN>)) {
+        if ($line =~ m!^\+\+\+ b/(.*)!) {
+            edit_file($filename, $editlines);
+            $filename = $1;
+            $lineno = 0;
+            $editlines = {};
+            print "FILE $filename\n" if $Debug;
+        }
+        elsif ($line  =~ m!^@@ -?[0-9]+,?[0-9]* \+?([0-9]+)!) {
+            $lineno = $1 - 1;
+            print "  LINE $1  $line" if $Debug;
+        }
+        elsif ($line  =~ m!^ !) {
+            ++$lineno;
+        }
+        elsif ($line  =~ m!^\+!) {
+            ++$lineno;
+            if ($line  =~ m!\t!) {
+                print "  $lineno: $line" if $Debug;
+                $editlines->{$lineno} = 1;
+            }
+        }
+    }
+    edit_file($filename, $editlines);
+}
+
+sub edit_file {
+    my $filename = shift;
+    my $editlines = shift;
+
+    return if (scalar keys(%$editlines) < 1);
+    if (ignore($filename)) {
+        print "%Warning: Ignoring $filename\n";
+        return;
+    }
+    print "Edit $filename ",join(",",sort(keys %$editlines)),"\n";
+
+    my $lineno = 0;
+    my @out;
+    {
+        my $fh = IO::File->new("<$filename") or die "%Error: $! $filename\n";
+        while (defined(my $line = $fh->getline)) {
+            ++$lineno;
+            if ($editlines->{$lineno}) {
+                print $line;
+                push @out, untabify($line);
+            } else {
+                push @out, $line;
+            }
+        }
+        $fh->close;
+    }
+    {
+        my $fh = IO::File->new(">${filename}.untab") or die "%Error: $! ${filename}.untab,";
+        $fh->print(join('',@out));
+        $fh->close;
+
+        my ($dev,$ino,$mode) = stat($filename);
+        chmod $mode, "${filename}.untab";
+    }
+
+    rename("${filename}.untab", $filename) or die "%Error: $! ${filename}.untab,";
+}
+
+sub ignore {
+    my $filename = shift;
+    return 1 if ($filename =~ /(Makefile|\.mk)/);
+    return 1 if ($filename =~ /\.(y|l|out|vcd)$/);
+    #
+    return 0 if ($filename =~ /\.(sv|v|vh|svh|h|vc|cpp|pl)$/);
+    return 0;
+}
+
+sub untabify {
+    my $line = shift;
+    my $out = "";
+    my $col = 0;
+    foreach my $c (split //, $line) {
+        if ($c eq "\t") {
+            my $destcol = int(($col+8)/8)*8;
+            while ($col < $destcol) { ++$col; $out .= " "; }
+        } else {
+            $out .= $c;
+            $col++;
+        }
+    }
+    return $out;
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+git_untabify - Pipe a git diff report and untabify differences
+
+=head1 SYNOPSIS
+
+  git diff a..b | git_untabify
+
+=head1 DESCRIPTION
+
+Take a patch file, and edit the files in the destination patch list to
+untabify the related patch lines.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item --version
+
+Displays program version and exits.
+
+=back
+
+=head1 DISTRIBUTION
+
+Copyright 2005-2018 by Wilson Snyder.  Verilator 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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./git_untabify "
+### End:

nodist/install_test

@@ -36,7 +36,6 @@ sub test {
     -r "nodist/install_test" or die "%Error: Run from the top of the verilator kit,";
 
     cleanenv();
-    $ENV{VERILATOR_NO_OPT_BUILD} = 1;   # Don't build optimized executables; just slows this down
     run("make distclean") if -r "Makefile";
 
     # Try building from a scratch area
@@ -59,11 +58,12 @@ sub test {
 	run("/bin/mkdir -p $prefix");
 	run("cd $blddir && make install");
 	run("test -e $prefix/share/man/man1/verilator.1");
-	run("test -e $prefix/share/verilator/examples/test_c/Makefile");
+        run("test -e $prefix/share/verilator/examples/tracing_c/Makefile");
 	run("test -e $prefix/share/verilator/include/verilated.h");
 	run("test -e $prefix/bin/verilator");
 	run("test -e $prefix/bin/verilator_bin");
 	run("test -e $prefix/bin/verilator_bin_dbg");
+        run("test -e $prefix/bin/verilator_gantt");
 	run("test -e $prefix/bin/verilator_profcfunc");
     }
 
@@ -92,6 +92,10 @@ sub test {
 	run("cd $dir/obj_dir && make -f Vfoo.mk");
 	run("cd $dir/obj_dir && ./Vfoo");
     }
+
+    if ($Opt_Stage <= 9) {
+        print "*-* All Finished *-*\n";
+    }
 }
 
 sub write_verilog {
@@ -100,14 +104,14 @@ sub write_verilog {
     my $fh = IO::File->new(">$dir/foo.cpp");
     $fh->print('#include "Vfoo.h"'		,"\n");
     $fh->print('unsigned int main_time = 0;'	,"\n");
-    $fh->print('double sc_time_stamp () {'	,"\n");
+    $fh->print('double sc_time_stamp() {'       ,"\n");
     $fh->print('    return main_time;'		,"\n");
     $fh->print('}'				,"\n");
     $fh->print('int main() {'			,"\n");
     $fh->print('    Vfoo *top = new Vfoo;'	,"\n");
     $fh->print('    while (!Verilated::gotFinish()) {',"\n");
-    $fh->print('	top->eval();'		,"\n");
-    $fh->print('	main_time++;'		,"\n");
+    $fh->print('        top->eval();'           ,"\n");
+    $fh->print('        main_time++;'           ,"\n");
     $fh->print('    }'				,"\n");
     $fh->print('    top->final();'		,"\n");
     $fh->print('}'				,"\n");
@@ -116,7 +120,8 @@ sub write_verilog {
 sub cleanenv {
     foreach my $var (keys %ENV) {
 	if ($var eq "VERILATOR_ROOT"
-	    || $var eq "VERILATOR_INCLUDE") {
+            || $var eq "VERILATOR_INCLUDE"
+            || $var eq "VERILATOR_NO_OPT_BUILD") {
 	    print "unset $var # Was '$ENV{$var}'\n";
 	    delete $ENV{$var}
 	}

src/Makefile.in

@@ -22,9 +22,10 @@
 #### Start of system configuration section. ####
 
 srcdir = @srcdir@
-VPATH = @srcdir@
 PERL = @PERL@
 EXEEXT = @EXEEXT@
+# VPATH only does sources; fix install_test's not creating ../bin
+vpath %.h @srcdir@
 
 #### End of system configuration section. ####
 
@@ -42,9 +43,11 @@ UNDER_GIT = $(wildcard ${srcdir}/../.git/logs/HEAD)
 #*********************************************************************
 
 obj_opt:
-	mkdir $@
+	mkdir -p $@
 obj_dbg:
-	mkdir $@
+	mkdir -p $@
+../bin:
+	mkdir -p $@
 
 .SUFFIXES:
 
@@ -56,19 +59,19 @@ ifeq ($(VERILATOR_NO_OPT_BUILD),1)	# Faster laptop development... One build
 	-rm -rf $@ $@.exe
 	-cp -p $<$(EXEEXT) $@$(EXEEXT)
 else
-../bin/verilator_bin: obj_opt prefiles
-	cd obj_opt && $(MAKE) -j 1  TGT=../$@ -f ../Makefile_obj serial
-	cd obj_opt && $(MAKE)       TGT=../$@ -f ../Makefile_obj
+../bin/verilator_bin: obj_opt ../bin prefiles
+	$(MAKE) -C obj_opt -j 1  TGT=../$@ -f ../Makefile_obj serial
+	$(MAKE) -C obj_opt       TGT=../$@ -f ../Makefile_obj
 endif
 
 dbg: ../bin/verilator_bin_dbg ../bin/verilator_coverage_bin_dbg
-../bin/verilator_bin_dbg: obj_dbg prefiles
-	cd obj_dbg && $(MAKE) -j 1  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj
+../bin/verilator_bin_dbg: obj_dbg ../bin prefiles
+	$(MAKE) -C obj_dbg -j 1  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj
 
-../bin/verilator_coverage_bin_dbg: obj_dbg prefiles
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov
-	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj
+../bin/verilator_coverage_bin_dbg: obj_dbg ../bin prefiles
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov
+	$(MAKE) -C obj_dbg       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj
 
 prefiles::
 prefiles:: config_rev.h

src/Makefile_obj.in

@@ -78,7 +78,7 @@ ifeq ($(VL_DEBUG),)
 COPT = -O2
 else
 # Debug
-COPT = -ggdb -DVL_DEBUG
+COPT = -ggdb -DVL_DEBUG -D_GLIBCXX_DEBUG
 # Debug & Profile:
 #LDFLAGS += -pg -g
 #COPT = -ggdb -pg -g
@@ -93,7 +93,7 @@ endif
 LIBS = -lm -lstdc++
 
 CPPFLAGS += -MMD
-CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir)
+CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir) -I../../include
 CPPFLAGS += -DYYDEBUG 	# Required to get nice error messages
 #CPPFLAGS += -DVL_LEAK_CHECKS 	# If running valgrind or other hunting tool
 CPPFLAGS += $(COPT)
@@ -195,10 +195,12 @@ RAW_OBJS = \
 	V3GraphAlg.o \
 	V3GraphAcyc.o \
 	V3GraphDfa.o \
+	V3GraphPathChecker.o \
 	V3GraphTest.o \
 	V3Hashed.o \
 	V3Inline.o \
 	V3Inst.o \
+	V3InstrCount.o \
 	V3Life.o \
 	V3LifePost.o \
 	V3LinkCells.o \
@@ -215,9 +217,12 @@ RAW_OBJS = \
 	V3Order.o \
 	V3Os.o \
 	V3Param.o \
+	V3Partition.o \
 	V3PreShell.o \
 	V3Premit.o \
+	V3Reloop.o \
 	V3Scope.o \
+	V3Scoreboard.o \
 	V3Slice.o \
 	V3Split.o \
 	V3SplitAs.o \
@@ -230,6 +235,7 @@ RAW_OBJS = \
 	V3Trace.o \
 	V3TraceDecl.o \
 	V3Tristate.o \
+	V3TSP.o \
 	V3Undriven.o \
 	V3Unknown.o \
 	V3Unroll.o \

src/V3Active.cpp

@@ -44,6 +44,8 @@
 #include "V3Ast.h"
 #include "V3EmitCBase.h"
 #include "V3Const.h"
+#include "V3SenTree.h"  // for SenTreeSet
+#include VL_INCLUDE_UNORDERED_MAP
 
 //***** See below for main transformation engine
 
@@ -52,11 +54,7 @@
 
 class ActiveBaseVisitor : public AstNVisitor {
 protected:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 class ActiveNamer : public ActiveBaseVisitor {
@@ -66,7 +64,11 @@ private:
     AstScope*	m_scopep;		// Current scope to add statement to
     AstActive*	m_iActivep;		// For current scope, the IActive we're building
     AstActive*	m_cActivep;		// For current scope, the SActive(combo) we're building
-    vector<AstActive*>	m_activeVec;	// List of sensitive actives, for folding
+
+    SenTreeSet  m_activeSens;  // Sen lists for each active we've made
+    typedef vl_unordered_map<AstSenTree*, AstActive*> ActiveMap;
+    ActiveMap m_activeMap;  // Map sentree to active, for folding.
+
     // METHODS
     void addActive(AstActive* nodep) {
 	if (!m_scopep) nodep->v3fatalSrc("NULL scope");
@@ -77,8 +79,9 @@ private:
 	m_scopep = nodep;
 	m_iActivep = NULL;
 	m_cActivep = NULL;
-	m_activeVec.clear();
-	nodep->iterateChildren(*this);
+        m_activeSens.clear();
+        m_activeMap.clear();
+        iterateChildren(nodep);
 	// Don't clear scopep, the namer persists beyond this visit
     }
     virtual void visit(AstSenTree* nodep) {
@@ -91,7 +94,7 @@ private:
     // Default
     virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     // METHODS
 public:
@@ -116,22 +119,15 @@ public:
     }
     AstActive* getActive(FileLine* fl, AstSenTree* sensesp) {
 	// Return a sentree in this scope that matches given sense list.
-	// Not the fastest, but scopes tend to have few clocks
+
 	AstActive* activep = NULL;
-	//sitemsp->dumpTree(cout,"  Lookingfor: ");
-	for (vector<AstActive*>::iterator it = m_activeVec.begin(); it!=m_activeVec.end(); ++it) {
-	    activep = *it;
-	    if (activep) {  // Not deleted
-		// Compare the list
-		AstSenTree* asenp = activep->sensesp();
-		if (asenp->sameTree(sensesp)) {
-		    UINFO(8,"    Found ACTIVE "<<activep<<endl);
-		    goto found;
-		}
-	    }
-	    activep = NULL;
-	}
-      found:
+        AstSenTree* activeSenp = m_activeSens.find(sensesp);
+        if (activeSenp) {
+            ActiveMap::iterator it = m_activeMap.find(activeSenp);
+            UASSERT(it != m_activeMap.end(), "Corrupt active map");
+            activep = it->second;
+        }
+
 	// Not found, form a new one
 	if (!activep) {
 	    AstSenTree* newsenp = sensesp->cloneTree(false);
@@ -140,7 +136,8 @@ public:
 	    UINFO(8,"    New ACTIVE "<<activep<<endl);
 	    // Form the sensitivity list
 	    addActive(activep);
-	    m_activeVec.push_back(activep);
+            m_activeMap[newsenp] = activep;
+            m_activeSens.add(newsenp);
 	    // Note actives may have also been added above in the Active visitor
 	}
 	return activep;
@@ -154,7 +151,7 @@ public:
     }
     virtual ~ActiveNamer() {}
     void main(AstScope* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
 };
 
@@ -182,9 +179,9 @@ private:
                 nodep->v3warn(COMBDLY, "Delayed assignments (<=) in non-clocked"
                               " (non flop or latch) block; suggest blocking assignments (=).");
 	    }
-	    AstNode* newp = new AstAssign (nodep->fileline(),
-					   nodep->lhsp()->unlinkFrBack(),
-					   nodep->rhsp()->unlinkFrBack());
+            AstNode* newp = new AstAssign(nodep->fileline(),
+                                          nodep->lhsp()->unlinkFrBack(),
+                                          nodep->rhsp()->unlinkFrBack());
 	    nodep->replaceWith(newp);
 	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
@@ -193,7 +190,7 @@ private:
 	if (m_check == CT_SEQ) {
 	    AstNode* las = m_assignp;
 	    m_assignp = nodep;
-	    nodep->lhsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->lhsp());
 	    m_assignp = las;
 	}
     }
@@ -217,7 +214,7 @@ private:
     }
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -225,7 +222,7 @@ public:
 	m_alwaysp = nodep;
 	m_check = check;
 	m_assignp = NULL;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~ActiveDlyVisitor() {}
 };
@@ -252,7 +249,7 @@ private:
 	// Clear last scope's names, and collect this scope's existing names
 	m_namer.main(nodep);
 	m_scopeFinalp = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstActive* nodep) {
 	// Actives are being formed, so we can ignore any already made
@@ -314,8 +311,8 @@ private:
 	// Move always to appropriate ACTIVE based on its sense list
 	if (oldsensesp
 	    && oldsensesp->sensesp()
-	    && oldsensesp->sensesp()->castSenItem()
-	    && oldsensesp->sensesp()->castSenItem()->isNever()) {
+            && VN_IS(oldsensesp->sensesp(), SenItem)
+            && VN_CAST(oldsensesp->sensesp(), SenItem)->isNever()) {
 	    // Never executing.  Kill it.
 	    if (oldsensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
@@ -325,7 +322,7 @@ private:
 	// Read sensitivitues
 	m_itemCombo = false;
 	m_itemSequent = false;
-	if (oldsensesp) oldsensesp->iterateAndNext(*this);
+        iterateAndNextNull(oldsensesp);
 	bool combo = m_itemCombo;
 	bool sequent = m_itemSequent;
 
@@ -399,7 +396,7 @@ private:
 	    && subitemp->edgeType() != AstEdgeType::ET_NEGEDGE) {
 	    nodep->v3fatalSrc("Strange activity type under SenGate");
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstSenItem* nodep) {
 	if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
@@ -421,7 +418,7 @@ private:
     virtual void visit(AstVarScope* nodep) {}
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -429,7 +426,7 @@ public:
 	m_scopeFinalp = NULL;
 	m_itemCombo = false;
 	m_itemSequent = false;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~ActiveVisitor() {}
 };

src/V3ActiveTop.cpp

@@ -58,24 +58,20 @@ private:
     SenTreeFinder	m_finder;	// Find global sentree's and add them
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
     virtual void visit(AstTopScope* nodep) {
 	m_topscopep = nodep;
 	m_finder.main(m_topscopep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_topscopep = NULL;
     }
     virtual void visit(AstNodeModule* nodep) {
 	// Create required actives and add to module
 	// We can start ordering at a module, or a scope
 	UINFO(4," MOD   "<<nodep<<endl);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstActive* nodep) {
 	UINFO(4,"   ACTIVE "<<nodep<<endl);
@@ -83,8 +79,8 @@ private:
 	AstSenTree* sensesp = nodep->sensesp();
 	if (!sensesp) nodep->v3fatalSrc("NULL");
 	if (sensesp->sensesp()
-	    && sensesp->sensesp()->castSenItem()
-	    && sensesp->sensesp()->castSenItem()->isNever()) {
+            && VN_IS(sensesp->sensesp(), SenItem)
+            && VN_CAST(sensesp->sensesp(), SenItem)->isNever()) {
 	    // Never executing.  Kill it.
 	    if (sensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
@@ -93,8 +89,8 @@ private:
 	// Copy combo tree to settlement tree with duplicated statements
 	if (sensesp->hasCombo()) {
 	    AstSenTree* newsentreep
-		= new AstSenTree (nodep->fileline(),
-				  new AstSenItem (nodep->fileline(), AstSenItem::Settle()));
+                = new AstSenTree(nodep->fileline(),
+                                 new AstSenItem (nodep->fileline(), AstSenItem::Settle()));
 	    AstActive* newp = new AstActive(nodep->fileline(),"settle", newsentreep);
 	    newp->sensesStorep(newsentreep);
 	    if (nodep->stmtsp()) newp->addStmtsp(nodep->stmtsp()->cloneTree(true));
@@ -118,7 +114,7 @@ private:
 	    nodep->sensesp(wantp);
 	}
 	// No need to do statements under it, they're already moved.
-	//nodep->iterateChildren(*this);
+        //iterateChildren(nodep);
     }
     virtual void visit(AstInitial* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
@@ -143,13 +139,13 @@ private:
     virtual void visit(AstVarScope* nodep) {}
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit ActiveTopVisitor(AstNetlist* nodep) {
 	m_topscopep = NULL;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~ActiveTopVisitor() {}
 };

src/V3Assert.cpp

@@ -77,23 +77,23 @@ private:
 	// Add a internal if to check assertions are on.
 	// Don't make this a AND term, as it's unlikely to need to test this.
 	AstNode* newp
-	    = new AstIf (nodep->fileline(),
-			 // If assertions are off, have constant propagation rip them out later
-			 // This allows syntax errors and such to be detected normally.
-			 (v3Global.opt.assertOn()
-			  ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
-			  : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
-			 nodep, NULL);
+            = new AstIf(nodep->fileline(),
+                        // If assertions are off, have constant propagation rip them out later
+                        // This allows syntax errors and such to be detected normally.
+                        (v3Global.opt.assertOn()
+                         ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
+                         : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
+                        nodep, NULL);
 	newp->user1(true); // Don't assert/cover this if
 	return newp;
     }
 
     AstNode* newFireAssertUnchecked(AstNode* nodep, const string& message) {
         // Like newFireAssert() but omits the asserts-on check
-	AstDisplay* dispp = new AstDisplay (nodep->fileline(), AstDisplayType::DT_ERROR, message, NULL, NULL);
+        AstDisplay* dispp = new AstDisplay(nodep->fileline(), AstDisplayType::DT_ERROR, message, NULL, NULL);
 	AstNode* bodysp = dispp;
 	replaceDisplay(dispp, "%%Error");   // Convert to standard DISPLAY format
-	bodysp->addNext(new AstStop (nodep->fileline()));
+        bodysp->addNext(new AstStop(nodep->fileline()));
         return bodysp;
     }
 
@@ -112,13 +112,13 @@ private:
 	AstNode* bodysp = NULL;
 	bool selfDestruct = false;
         AstIf* ifp = NULL;
-	if (AstPslCover* snodep = nodep->castPslCover()) {
+        if (AstPslCover* snodep = VN_CAST(nodep, PslCover)) {
             ++m_statAsCover;
 	    if (!v3Global.opt.coverageUser()) {
 		selfDestruct = true;
 	    } else {
 		// V3Coverage assigned us a bucket to increment.
-		AstCoverInc* covincp = snodep->coverincp()->castCoverInc();
+                AstCoverInc* covincp = VN_CAST(snodep->coverincp(), CoverInc);
 		if (!covincp) snodep->v3fatalSrc("Missing AstCoverInc under assertion");
 		covincp->unlinkFrBack();
 		if (message!="") covincp->declp()->comment(message);
@@ -126,10 +126,10 @@ private:
 	    }
 
             if (bodysp && stmtsp) bodysp = bodysp->addNext(stmtsp);
-            ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
+            ifp = new AstIf(nodep->fileline(), propp, bodysp, NULL);
             bodysp = ifp;
 
-        } else if (nodep->castPslAssert()) {
+        } else if (VN_IS(nodep, PslAssert)) {
             ++m_statAsPsl;
             // Insert an automatic error message and $stop after
             // any user-supplied statements.
@@ -148,10 +148,8 @@ private:
 	    nodep->v3fatalSrc("Unknown node type");
 	}
 
-	AstNode* newp = new AstAlways (nodep->fileline(),
-				       VAlwaysKwd::ALWAYS,
-				       sentreep,
-				       bodysp);
+        AstNode* newp = new AstAlways(nodep->fileline(),
+                                      VAlwaysKwd::ALWAYS, sentreep, bodysp);
 	// Install it
 	if (selfDestruct) {
 	    // Delete it after making the tree.  This way we can tell the user
@@ -170,16 +168,16 @@ private:
 	AstNode* passsp = nodep->passsp(); if (passsp) passsp->unlinkFrBackWithNext();
 	AstNode* failsp = nodep->failsp(); if (failsp) failsp->unlinkFrBackWithNext();
 	//
-	if (nodep->castVAssert()) {
+        if (VN_IS(nodep, VAssert)) {
 	    if (passsp) passsp = newIfAssertOn(passsp);
 	    if (failsp) failsp = newIfAssertOn(failsp);
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
 
-	AstIf* ifp = new AstIf (nodep->fileline(), propp, passsp, failsp);
+        AstIf* ifp = new AstIf(nodep->fileline(), propp, passsp, failsp);
 	AstNode* newp = ifp;
-	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
+        if (VN_IS(nodep, VAssert)) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 	//
 	// Install it
 	nodep->replaceWith(newp);
@@ -197,14 +195,14 @@ private:
 		// If this statement ends with 'else if', then nextIf will point to the
 		// nextIf statement.  Otherwise it will be null.
 		AstNodeIf* nextifp = dynamic_cast<AstNodeIf*>(ifp->elsesp());
-		ifp->condp()->iterateAndNext(*this);
+                iterateAndNextNull(ifp->condp());
 
 		// Recurse into the true case.
-		ifp->ifsp()->iterateAndNext(*this);
+                iterateAndNextNull(ifp->ifsp());
 
 		// If the last else is not an else if, recurse into that too.
 		if (ifp->elsesp() && !nextifp) {
-		    ifp->elsesp()->iterateAndNext(*this);
+                    iterateAndNextNull(ifp->elsesp());
 		}
 
 		// Build a bitmask of the true predicates
@@ -234,24 +232,24 @@ private:
 	    AstNode* ohot = ((allow_none || hasDefaultElse)
 			     ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
 			     : static_cast<AstNode*>(new AstOneHot (nodep->fileline(), propp)));
-	    AstIf* checkifp = new AstIf (nodep->fileline(),
-					 new AstLogNot (nodep->fileline(), ohot),
-					 newFireAssert(nodep, "'unique if' statement violated"),
-					 newifp);
+            AstIf* checkifp = new AstIf(nodep->fileline(),
+                                        new AstLogNot(nodep->fileline(), ohot),
+                                        newFireAssert(nodep, "'unique if' statement violated"),
+                                        newifp);
 	    checkifp->branchPred(AstBranchPred::BP_UNLIKELY);
 	    nodep->replaceWith(checkifp);
 	    pushDeletep(nodep);
 	} else {
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
     }
 
     // VISITORS  //========== Case assertions
     virtual void visit(AstCase* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (!nodep->user1SetOnce()) {
 	    bool has_default=false;
-	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+            for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 		if (itemp->isDefault()) has_default=true;
 	    }
 	    if (nodep->fullPragma() || nodep->priorityPragma()) {
@@ -270,7 +268,7 @@ private:
 		    // Not parallel, but harmlessly so.
 		} else {
 		    AstNode* propp = NULL;
-		    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+                    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 			for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 			    AstNode* onep;
 			    if (nodep->casex() || nodep->casez() || nodep->caseInside()) {
@@ -293,10 +291,10 @@ private:
 		    AstNode* ohot = (allow_none
 				     ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
 				     : static_cast<AstNode*>(new AstOneHot (nodep->fileline(), propp)));
-		    AstIf* ifp = new AstIf (nodep->fileline(),
-					    new AstLogNot (nodep->fileline(), ohot),
-					    newFireAssert(nodep, "synthesis parallel_case, but multiple matches found"),
-					    NULL);
+                    AstIf* ifp = new AstIf(nodep->fileline(),
+                                           new AstLogNot(nodep->fileline(), ohot),
+                                           newFireAssert(nodep, "synthesis parallel_case, but multiple matches found"),
+                                           NULL);
 		    ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 		    nodep->addNotParallelp(ifp);
 		}
@@ -306,7 +304,7 @@ private:
 
     // VISITORS  //========== Statements
     virtual void visit(AstDisplay* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Replace the special types with standard text
 	if (nodep->displayType()==AstDisplayType::DT_INFO) {
 	    replaceDisplay(nodep, "-Info");
@@ -319,13 +317,13 @@ private:
     }
 
     virtual void visit(AstNodePslCoverOrAssert* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
 	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
 			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
     }
     virtual void visit(AstVAssert* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
 	++m_statAsSV;
     }
@@ -333,7 +331,7 @@ private:
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	//
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Reset defaults
 	m_modp = NULL;
     }
@@ -343,13 +341,13 @@ private:
 	AstBegin* lastp = m_beginp;
 	{
 	    m_beginp = nodep;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_beginp = lastp;
     }
 
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
@@ -357,7 +355,7 @@ public:
 	m_beginp = NULL;
 	m_modp = NULL;
 	// Process
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~AssertVisitor() {
 	V3Stats::addStat("Assertions, PSL asserts", m_statAsPsl);

src/V3AssertPre.cpp

@@ -49,11 +49,7 @@ private:
     AstNodeSenItem*	m_senip;	// Last sensitivity
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     AstSenTree* newSenTree(AstNode* nodep) {
 	// Create sentree based on clocked or default clock
@@ -89,12 +85,12 @@ private:
     virtual void visit(AstNodePslCoverOrAssert* nodep) {
 	if (nodep->sentreep()) return;  // Already processed
 	clearAssertInfo();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->sentreep(newSenTree(nodep));
 	clearAssertInfo();
     }
     virtual void visit(AstPslClocked* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (m_senip) {
 	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
 	}
@@ -112,12 +108,12 @@ private:
 	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     virtual void visit(AstNodeModule* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Reset defaults
 	m_seniDefaultp = NULL;
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
@@ -126,7 +122,7 @@ public:
 	m_seniDefaultp = NULL;
 	clearAssertInfo();
 	// Process
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~AssertPreVisitor() {}
 };

src/V3Ast.cpp

@@ -58,7 +58,7 @@ int AstNodeDType::s_uniqueNum = 0;
 //######################################################################
 // V3AstType
 
-ostream& operator<<(ostream& os, AstType rhs);
+std::ostream& operator<<(std::ostream& os, AstType rhs);
 
 //######################################################################
 // Creators
@@ -290,9 +290,8 @@ void AstNode::addNextHere(AstNode* newp) {
     // Add to m_nextp on exact node passed, not at the end.
     //  This could be at head, tail, or both (single)
     //  New  could be head of single node, or list
-    UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     UASSERT(newp,"Null item passed to addNext");
-    UASSERT(newp->backp()==NULL,"New node (back) already assigned?");
+    UASSERT(!newp->backp(), "New node (back) already assigned?");
     this->debugTreeChange("-addHereThs: ", __LINE__, false);
     newp->debugTreeChange("-addHereNew: ", __LINE__, true);
     newp->editCountInc();
@@ -335,7 +334,7 @@ void AstNode::addNextHere(AstNode* newp) {
 }
 
 void AstNode::setOp1p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to setOp1p\n");
+    UASSERT(newp, "Null item passed to setOp1p");
     UDEBUGONLY(if (m_op1p) this->v3fatalSrc("Adding to non-empty, non-list op1"););
     UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
     UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op1"););
@@ -348,7 +347,7 @@ void AstNode::setOp1p(AstNode* newp) {
 }
 
 void AstNode::setOp2p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to setOp2p\n");
+    UASSERT(newp, "Null item passed to setOp2p");
     UDEBUGONLY(if (m_op2p) this->v3fatalSrc("Adding to non-empty, non-list op2"););
     UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
     UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op2"););
@@ -361,7 +360,7 @@ void AstNode::setOp2p(AstNode* newp) {
 }
 
 void AstNode::setOp3p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to setOp3p\n");
+    UASSERT(newp, "Null item passed to setOp3p");
     UDEBUGONLY(if (m_op3p) this->v3fatalSrc("Adding to non-empty, non-list op3"););
     UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
     UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op3"););
@@ -374,7 +373,7 @@ void AstNode::setOp3p(AstNode* newp) {
 }
 
 void AstNode::setOp4p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to setOp4p\n");
+    UASSERT(newp, "Null item passed to setOp4p");
     UDEBUGONLY(if (m_op4p) this->v3fatalSrc("Adding to non-empty, non-list op4"););
     UDEBUGONLY(if (newp->m_backp) newp->v3fatalSrc("Adding already linked node"););
     UDEBUGONLY(if (newp->m_nextp) newp->v3fatalSrc("Adding list to non-list op4"););
@@ -387,25 +386,25 @@ void AstNode::setOp4p(AstNode* newp) {
 }
 
 void AstNode::addOp1p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to addOp1p\n");
+    UASSERT(newp, "Null item passed to addOp1p");
     if (!m_op1p) { op1p(newp); }
     else { m_op1p->addNext(newp); }
 }
 
 void AstNode::addOp2p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to addOp2p\n");
+    UASSERT(newp, "Null item passed to addOp2p");
     if (!m_op2p) { op2p(newp); }
     else { m_op2p->addNext(newp); }
 }
 
 void AstNode::addOp3p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to addOp3p\n");
+    UASSERT(newp, "Null item passed to addOp3p");
     if (!m_op3p) { op3p(newp); }
     else { m_op3p->addNext(newp); }
 }
 
 void AstNode::addOp4p(AstNode* newp) {
-    UASSERT(newp,"Null item passed to addOp4p\n");
+    UASSERT(newp, "Null item passed to addOp4p");
     if (!m_op4p) { op4p(newp); }
     else { m_op4p->addNext(newp); }
 }
@@ -418,7 +417,7 @@ void AstNode::replaceWith(AstNode* newp) {
     repHandle.relink(newp);
 }
 
-void AstNRelinker::dump(ostream& str) const {
+void AstNRelinker::dump(std::ostream& str) const {
     str<<" BK="<<(uint32_t*)m_backp;
     str<<" ITER="<<(uint32_t*)m_iterpp;
     str<<" CHG="<<(m_chg==RELINK_NEXT?"[NEXT] ":"");
@@ -431,7 +430,7 @@ void AstNRelinker::dump(ostream& str) const {
 AstNode* AstNode::unlinkFrBackWithNext(AstNRelinker* linkerp) {
     this->debugTreeChange("-unlinkWNextThs: ", __LINE__, true);
     AstNode* oldp = this;
-    UASSERT(oldp->m_backp,"Node has no back, already unlinked?\n");
+    UASSERT(oldp->m_backp, "Node has no back, already unlinked?");
     oldp->editCountInc();
     AstNode* backp = oldp->m_backp;
     if (linkerp) {
@@ -479,7 +478,7 @@ AstNode* AstNode::unlinkFrBackWithNext(AstNRelinker* linkerp) {
 AstNode* AstNode::unlinkFrBack(AstNRelinker* linkerp) {
     this->debugTreeChange("-unlinkFrBkThs: ", __LINE__, true);
     AstNode* oldp = this;
-    UASSERT(oldp->m_backp,"Node has no back, already unlinked?\n");
+    UASSERT(oldp->m_backp, "Node has no back, already unlinked?");
     oldp->editCountInc();
     AstNode* backp = oldp->m_backp;
     if (linkerp) {
@@ -531,8 +530,8 @@ AstNode* AstNode::unlinkFrBack(AstNRelinker* linkerp) {
 void AstNode::relink(AstNRelinker* linkerp) {
     if (debug()>8) {	UINFO(0," EDIT:      relink: "); dumpPtrs();    }
     AstNode* newp = this;
-    UASSERT(linkerp && linkerp->m_backp, "Need non-empty linker\n");
-    UASSERT(newp->backp()==NULL, "New node already linked?\n");
+    UASSERT(linkerp && linkerp->m_backp, "Need non-empty linker");
+    UASSERT(!newp->backp(), "New node already linked?");
     newp->editCountInc();
 
     if (debug()>8) { linkerp->dump(cout); cout<<endl; }
@@ -594,7 +593,7 @@ void AstNode::relinkOneLink(AstNode*& pointpr,  // Ref to pointer that gets set
     pointpr = newp;
 }
 
-void AstNode::addHereThisAsNext (AstNode* newp) {
+void AstNode::addHereThisAsNext(AstNode* newp) {
     // {old}->this->{next} becomes {old}->new->this->{next}
     AstNRelinker handle;
     this->unlinkFrBackWithNext(&handle);
@@ -602,7 +601,7 @@ void AstNode::addHereThisAsNext (AstNode* newp) {
     handle.relink(newp);
 }
 
-void AstNode::swapWith (AstNode* bp) {
+void AstNode::swapWith(AstNode* bp) {
     AstNRelinker aHandle;
     AstNRelinker bHandle;
     this->unlinkFrBack(&aHandle);
@@ -646,7 +645,6 @@ AstNode* AstNode::cloneTreeIterList() {
 }
 
 AstNode* AstNode::cloneTree(bool cloneNextLink) {
-    if (!this) return NULL;  // verilog.y relies on this
     this->debugTreeChange("-cloneThs: ", __LINE__, cloneNextLink);
     cloneClearTree();
     AstNode* newp;
@@ -668,7 +666,7 @@ AstNode* AstNode::cloneTree(bool cloneNextLink) {
 
 void AstNode::deleteNode() {
     // private: Delete single node. Publicly call deleteTree() instead.
-    UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
+    UASSERT(!m_backp, "Delete called on node with backlink still set");
     editCountInc();
     // Change links of old node so we coredump if used
     this->m_nextp = (AstNode*)1;
@@ -713,7 +711,7 @@ void AstNode::deleteTreeIter() {
 void AstNode::deleteTree() {
     // deleteTree always deletes the next link, because you must have called
     // unlinkFromBack or unlinkFromBackWithNext as appropriate before calling this.
-    UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
+    UASSERT(!m_backp, "Delete called on node with backlink still set");
     this->debugTreeChange("-delTree:  ", __LINE__, true);
     this->editCountInc();
     // MUST be depth first!
@@ -802,7 +800,6 @@ void AstNode::iterateAndNext(AstNVisitor& v) {
 }
 
 void AstNode::iterateListBackwards(AstNVisitor& v) {
-    UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     AstNode* nodep=this;
     while (nodep->m_nextp) nodep=nodep->m_nextp;
     while (nodep) {
@@ -822,13 +819,13 @@ void AstNode::iterateChildrenBackwards(AstNVisitor& v) {
 
 void AstNode::iterateAndNextConst(AstNVisitor& v) {
     // Keep following the current list even if edits change it
-    if (!this) return;  // A few cases could be cleaned up, but want symmetry with iterateAndNext
-    for (AstNode* nodep=this; nodep; ) {   // effectively: if (!this) return;  // Callers rely on this
+    AstNode* nodep=this;
+    do {
 	AstNode* nnextp = nodep->m_nextp;
 	ASTNODE_PREFETCH(nnextp);
 	nodep->accept(v);
 	nodep = nnextp;
-    }
+    } while (nodep);
 }
 
 AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v) {
@@ -839,7 +836,7 @@ AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v) {
     // To solve this, this function returns the pointer to the replacement node,
     // which in many cases is just the same node that was passed in.
     AstNode* nodep = this;  // Note "this" may point to bogus point later in this function
-    if (nodep->castNetlist()) {
+    if (VN_IS(nodep, Netlist)) {
 	// Calling on top level; we know the netlist won't get replaced
 	nodep->accept(v);
     } else if (!nodep->backp()) {
@@ -886,7 +883,7 @@ void AstNode::cloneRelinkTree() {
 //======================================================================
 // Comparison
 
-bool AstNode::gateTreeIter() {
+bool AstNode::gateTreeIter() const {
     // private: Return true if the two trees are identical
     if (!isGateOptimizable()) return false;
     if (m_op1p && !m_op1p->gateTreeIter()) return false;
@@ -896,7 +893,7 @@ bool AstNode::gateTreeIter() {
     return true;
 }
 
-bool AstNode::sameTreeIter(AstNode* node1p, AstNode* node2p, bool ignNext, bool gateOnly) {
+bool AstNode::sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext, bool gateOnly) {
     // private: Return true if the two trees are identical
     if (!node1p && !node2p) return true;
     if (!node1p || !node2p) return false;
@@ -917,9 +914,9 @@ bool AstNode::sameTreeIter(AstNode* node1p, AstNode* node2p, bool ignNext, bool
 //======================================================================
 // Static utilities
 
-ostream& operator<<(ostream& os, const V3Hash& rhs) {
-    return os<<hex<<setw(2)<<setfill('0')<<rhs.depth()
-	     <<"_"<<setw(6)<<setfill('0')<<rhs.hshval();
+std::ostream& operator<<(std::ostream& os, const V3Hash& rhs) {
+    return os<<std::hex<<std::setw(2)<<std::setfill('0')<<rhs.depth()
+             <<"_"<<std::setw(6)<<std::setfill('0')<<rhs.hshval();
 }
 
 V3Hash::V3Hash(const string& name) {
@@ -938,7 +935,7 @@ void AstNode::checkTreeIter(AstNode* backp) {
     if (backp != this->backp()) {
 	this->v3fatalSrc("Back node inconsistent");
     }
-    if (castNodeTermop() || castNodeVarRef()) {
+    if (VN_IS(this, NodeTermop) || VN_IS(this, NodeVarRef)) {
 	// Termops have a short-circuited iterateChildren, so check usage
 	if (op1p()||op2p()||op3p()||op4p())
 	    this->v3fatalSrc("Terminal operation with non-terminals");
@@ -975,17 +972,14 @@ void AstNode::checkTree() {
 }
 
 void AstNode::dumpGdb() {  // For GDB only
-    if (!dynamic_cast<const AstNode*>(this)) { cout<<"This=NULL"<<endl; return; }
     dumpGdbHeader();
     cout<<"  "; dump(cout); cout<<endl;
 }
 void AstNode::dumpGdbHeader() const {  // For GDB only
-    if (!dynamic_cast<const AstNode*>(this)) { cout<<"This=NULL"<<endl; return; }
     dumpPtrs(cout);
     cout<<"  Fileline = "<<fileline()<<endl;
 }
 void AstNode::dumpTreeGdb() {  // For GDB only
-    if (!dynamic_cast<const AstNode*>(this)) { cout<<"This=NULL"<<endl; return; }
     dumpGdbHeader();
     dumpTree(cout);
 }
@@ -1002,7 +996,7 @@ void AstNode::checkIter() const {
     }
 }
 
-void AstNode::dumpPtrs(ostream& os) const {
+void AstNode::dumpPtrs(std::ostream& os) const {
     os<<"This="<<typeName()<<" "<<(void*)this;
     os<<" back="<<(void*)backp();
     if (nextp()) os<<" next="<<(void*)nextp();
@@ -1024,7 +1018,7 @@ void AstNode::dumpPtrs(ostream& os) const {
     os<<endl;
 }
 
-void AstNode::dumpTree(ostream& os, const string& indent, int maxDepth) {
+void AstNode::dumpTree(std::ostream& os, const string& indent, int maxDepth) {
     os<<indent<<" "<<this<<endl;
     if (debug()>8) { os<<indent<<"     "; dumpPtrs(os); }
     if (maxDepth==1) {
@@ -1037,7 +1031,7 @@ void AstNode::dumpTree(ostream& os, const string& indent, int maxDepth) {
     }
 }
 
-void AstNode::dumpTreeAndNext(ostream& os, const string& indent, int maxDepth) {
+void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDepth) {
     // Audited to make sure this is never NULL
     for (AstNode* nodep=this; nodep; nodep=nodep->nextp()) {
 	nodep->dumpTree(os, indent, maxDepth);
@@ -1048,10 +1042,10 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
     if (doDump) {
 	{   // Write log & close
 	    UINFO(2,"Dumping "<<filename<<endl);
-	    const vl_unique_ptr<ofstream> logsp (V3File::new_ofstream(filename, append));
-	    if (logsp->fail()) v3fatalSrc("Can't write "<<filename);
-	    *logsp<<"Verilator Tree Dump (format 0x3900) from <e"<<dec<<editCountLast()<<">";
-	    *logsp<<" to <e"<<dec<<editCountGbl()<<">"<<endl;
+            const vl_unique_ptr<std::ofstream> logsp (V3File::new_ofstream(filename, append));
+            if (logsp->fail()) v3fatal("Can't write "<<filename);
+            *logsp<<"Verilator Tree Dump (format 0x3900) from <e"<<std::dec<<editCountLast()<<">";
+            *logsp<<" to <e"<<std::dec<<editCountGbl()<<">"<<endl;
 	    if (editCountGbl()==editCountLast()
 		&& !(v3Global.opt.dumpTree()>=9)) {
 		*logsp<<endl;
@@ -1066,23 +1060,19 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
 	checkTree();
 	// Broken isn't part of check tree because it can munge iterp's
 	// set by other steps if it is called in the middle of other operations
-	if (AstNetlist* netp=this->castNetlist()) V3Broken::brokenAll(netp);
+        if (AstNetlist* netp=VN_CAST(this, Netlist)) V3Broken::brokenAll(netp);
     }
     // Next dump can indicate start from here
     editCountSetLast();
 }
 
-void AstNode::v3errorEndFatal(ostringstream& str) const { v3errorEnd(str); assert(0); }
+void AstNode::v3errorEndFatal(std::ostringstream& str) const { v3errorEnd(str); assert(0); }
 
-void AstNode::v3errorEnd(ostringstream& str) const {
-    if (!dynamic_cast<const AstNode*>(this)) {
-	// No known cases cause this, but better than a core dump
-	if (debug()) UINFO(0, "-node: NULL. Please report this along with a --gdbbt backtrace as a Verilator bug.\n");
-	V3Error::v3errorEnd(str);
-    } else if (!m_fileline) {
+void AstNode::v3errorEnd(std::ostringstream& str) const {
+    if (!m_fileline) {
 	V3Error::v3errorEnd(str);
     } else {
-	ostringstream nsstr;
+        std::ostringstream nsstr;
 	nsstr<<str.str();
 	if (debug()) {
 	    nsstr<<endl;
@@ -1153,7 +1143,7 @@ AstBasicDType* AstNode::findInsertSameDType(AstBasicDType* nodep) {
 // AstNVisitor
 
 void AstNVisitor::doDeletes() {
-    for (vector<AstNode*>::iterator it = m_deleteps.begin(); it != m_deleteps.end(); ++it) {
+    for (std::vector<AstNode*>::iterator it = m_deleteps.begin(); it != m_deleteps.end(); ++it) {
 	(*it)->deleteTree();
     }
     m_deleteps.clear();

src/V3Ast.h

@@ -29,19 +29,36 @@
 #include <vector>
 #include <cmath>
 #include <map>
+#include VL_INCLUDE_UNORDERED_SET
 
 #include "V3Ast__gen_classes.h"	// From ./astgen
 // Things like:
 //   class V3AstNode;
 
+// Forward declarations
+class V3Graph;
+class ExecMTask;
+
 // Hint class so we can choose constructors
 class VFlagLogicPacked {};
 class VFlagBitPacked {};
 class VFlagChildDType {};  // Used by parser.y to select constructor that sets childDType
 
+// Used as key for another map, needs operator<, hence not an unordered_set
+typedef std::set<int> MTaskIdSet;  // Set of mtaskIds for Var sorting
+
+//######################################################################
+
 // For broken() function, return error string if have a match
 #define BROKEN_RTN(test) do { if (VL_UNLIKELY(test)) return # test; } while(0)
 
+// (V)erilator (N)ode is: True if AstNode is of a a given AstType
+#define VN_IS(nodep,nodetypename) (AstNode::privateIs ## nodetypename(nodep))
+
+// (V)erilator (N)ode cast: Cast to given type if can; effectively dynamic_cast(nodep)(nodetypename)
+#define VN_CAST(nodep,nodetypename) (AstNode::privateCast ## nodetypename(nodep))
+#define VN_CAST_CONST(nodep,nodetypename) (AstNode::privateConstCast ## nodetypename(nodep) )
+
 //######################################################################
 
 class AstType {
@@ -52,16 +69,16 @@ public:
     //   const char* ascii() const {...};
     enum en m_e;
     // cppcheck-suppress uninitVar  // responsiblity of each subclass
-    inline AstType () {}
+    inline AstType() {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstType (en _e) : m_e(_e) {}
-    explicit inline AstType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstType(en _e) : m_e(_e) {}
+    explicit inline AstType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (AstType lhs, AstType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstType lhs, AstType::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstType::en lhs, AstType rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstType& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstType& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -87,19 +104,19 @@ public:
 	};
 	return names[m_e];
     };
-    inline AstNumeric () : m_e(UNSIGNED) {}
+    inline AstNumeric() : m_e(UNSIGNED) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstNumeric (en _e) : m_e(_e) {}
+    inline AstNumeric(en _e) : m_e(_e) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstNumeric (VSignedState signst) {
+    inline AstNumeric(VSignedState signst) {
 	if (signst==signedst_UNSIGNED) m_e=UNSIGNED;
 	else if (signst==signedst_SIGNED) m_e=SIGNED;
 	else m_e=NOSIGN;
     }
-    static inline AstNumeric fromBool (bool isSigned) {  // Factory method
+    static inline AstNumeric fromBool(bool isSigned) {  // Factory method
 	return isSigned ? AstNumeric(SIGNED) : AstNumeric(UNSIGNED); }
-    explicit inline AstNumeric (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    explicit inline AstNumeric(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     inline bool isSigned() const { return m_e==SIGNED; }
     inline bool isNosign() const { return m_e==NOSIGN; }
     // No isUnsigned() as it's ambiguous if NOSIGN should be included or not.
@@ -107,7 +124,7 @@ public:
   inline bool operator== (AstNumeric lhs, AstNumeric rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstNumeric lhs, AstNumeric::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstNumeric::en lhs, AstNumeric rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstNumeric& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstNumeric& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -123,11 +140,11 @@ public:
 	PUBLIC_TASK
     };
     enum en m_e;
-    inline AstPragmaType () : m_e(ILLEGAL) {}
+    inline AstPragmaType() : m_e(ILLEGAL) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstPragmaType (en _e) : m_e(_e) {}
-    explicit inline AstPragmaType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstPragmaType(en _e) : m_e(_e) {}
+    explicit inline AstPragmaType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (AstPragmaType lhs, AstPragmaType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstPragmaType lhs, AstPragmaType::en rhs) { return (lhs.m_e == rhs); }
@@ -147,11 +164,11 @@ public:
 	TRACE_CHANGE_SUB
     };
     enum en m_e;
-    inline AstCFuncType () : m_e(FT_NORMAL) {}
+    inline AstCFuncType() : m_e(FT_NORMAL) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstCFuncType (en _e) : m_e(_e) {}
-    explicit inline AstCFuncType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstCFuncType(en _e) : m_e(_e) {}
+    explicit inline AstCFuncType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     // METHODS
     bool isTrace() const { return (m_e==TRACE_INIT || m_e==TRACE_INIT_SUB
 				   || m_e==TRACE_FULL || m_e==TRACE_FULL_SUB
@@ -167,7 +184,7 @@ class AstEdgeType {
 public:
 // REMEMBER to edit the strings below too
     enum en {
-	// These must be in general -> most specific order, as we sort by it in V3Const::visit AstSenTre
+        // These must be in general -> most specific order, as we sort by it in V3Const::visit AstSenTree
 	ET_ILLEGAL,
 	// Involving a variable
 	ET_ANYEDGE,	// Default for sensitivities; rip them out
@@ -239,11 +256,11 @@ public:
         }
         return false;
     }
-    inline AstEdgeType () : m_e(ET_ILLEGAL) {}
+    inline AstEdgeType() : m_e(ET_ILLEGAL) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstEdgeType (en _e) : m_e(_e) {}
-    explicit inline AstEdgeType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstEdgeType(en _e) : m_e(_e) {}
+    explicit inline AstEdgeType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (AstEdgeType lhs, AstEdgeType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstEdgeType lhs, AstEdgeType::en rhs) { return (lhs.m_e == rhs); }
@@ -307,11 +324,11 @@ public:
 	};
 	return names[m_e];
     };
-    inline AstAttrType () : m_e(ILLEGAL) {}
+    inline AstAttrType() : m_e(ILLEGAL) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstAttrType (en _e) : m_e(_e) {}
-    explicit inline AstAttrType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstAttrType(en _e) : m_e(_e) {}
+    explicit inline AstAttrType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (AstAttrType lhs, AstAttrType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstAttrType lhs, AstAttrType::en rhs) { return (lhs.m_e == rhs); }
@@ -364,14 +381,14 @@ public:
 	return names[m_e];
     };
     static void selfTest() {
-	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).ascii()," MAX"),"Enum array mismatch");
-	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).dpiType()," MAX"),"Enum array mismatch");
+        UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).ascii()," MAX"), "SelfTest: Enum mismatch");
+        UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).dpiType()," MAX"),"SelfTest: Enum mismatch");
     }
-    inline AstBasicDTypeKwd () : m_e(UNKNOWN) {}
+    inline AstBasicDTypeKwd() : m_e(UNKNOWN) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstBasicDTypeKwd (en _e) : m_e(_e) {}
-    explicit inline AstBasicDTypeKwd (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstBasicDTypeKwd(en _e) : m_e(_e) {}
+    explicit inline AstBasicDTypeKwd(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     int width() const {
 	switch (m_e) {
 	case BIT:	return 1;   // scalar, can't bit extract unless ranged
@@ -473,11 +490,11 @@ public:
 	IFACEREF	// Used to link Interfaces between modules
     };
     enum en m_e;
-    inline AstVarType () : m_e(UNKNOWN) {}
+    inline AstVarType() : m_e(UNKNOWN) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstVarType (en _e) : m_e(_e) {}
-    explicit inline AstVarType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstVarType(en _e) : m_e(_e) {}
+    explicit inline AstVarType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     const char* ascii() const {
 	static const char* const names[] = {
 	    "?","GPARAM","LPARAM","GENVAR",
@@ -497,7 +514,7 @@ public:
   inline bool operator== (AstVarType lhs, AstVarType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstVarType lhs, AstVarType::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstVarType::en lhs, AstVarType rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstVarType& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstVarType& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -511,11 +528,11 @@ public:
     };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
-    inline AstBranchPred () : m_e(BP_UNKNOWN) {}
+    inline AstBranchPred() : m_e(BP_UNKNOWN) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstBranchPred (en _e) : m_e(_e) {}
-    explicit inline AstBranchPred (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstBranchPred(en _e) : m_e(_e) {}
+    explicit inline AstBranchPred(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     AstBranchPred invert() const {
 	if (m_e==BP_UNLIKELY) return BP_LIKELY;
 	else if (m_e==BP_LIKELY) return BP_UNLIKELY;
@@ -529,7 +546,7 @@ public:
   inline bool operator== (AstBranchPred lhs, AstBranchPred rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstBranchPred lhs, AstBranchPred::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstBranchPred::en lhs, AstBranchPred rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstBranchPred& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstBranchPred& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -543,11 +560,11 @@ public:
     };
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
-    inline AstVarAttrClocker () : m_e(CLOCKER_UNKNOWN) {}
+    inline AstVarAttrClocker() : m_e(CLOCKER_UNKNOWN) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstVarAttrClocker (en _e) : m_e(_e) {}
-    explicit inline AstVarAttrClocker (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstVarAttrClocker(en _e) : m_e(_e) {}
+    explicit inline AstVarAttrClocker(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     bool unknown() const { return m_e==CLOCKER_UNKNOWN; }
     AstVarAttrClocker invert() const {
 	if (m_e==CLOCKER_YES) return CLOCKER_NO;
@@ -562,7 +579,7 @@ public:
   inline bool operator== (AstVarAttrClocker lhs, AstVarAttrClocker rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstVarAttrClocker lhs, AstVarAttrClocker::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstVarAttrClocker::en lhs, AstVarAttrClocker rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstVarAttrClocker& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstVarAttrClocker& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -575,11 +592,11 @@ public:
 	ALWAYS_COMB
     };
     enum en m_e;
-    inline VAlwaysKwd () : m_e(ALWAYS) {}
+    inline VAlwaysKwd() : m_e(ALWAYS) {}
     // cppcheck-suppress noExplicitConstructor
-    inline VAlwaysKwd (en _e) : m_e(_e) {}
-    explicit inline VAlwaysKwd (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline VAlwaysKwd(en _e) : m_e(_e) {}
+    explicit inline VAlwaysKwd(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     const char* ascii() const {
 	static const char* const names[] = {
 	    "always","always_ff","always_latch","always_comb"};
@@ -600,11 +617,11 @@ public:
 	CT_CASEINSIDE
     };
     enum en m_e;
-    inline VCaseType () : m_e(CT_CASE) {}
+    inline VCaseType() : m_e(CT_CASE) {}
     // cppcheck-suppress noExplicitConstructor
-    inline VCaseType (en _e) : m_e(_e) {}
-    explicit inline VCaseType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline VCaseType(en _e) : m_e(_e) {}
+    explicit inline VCaseType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (VCaseType lhs, VCaseType rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (VCaseType lhs, VCaseType::en rhs) { return (lhs.m_e == rhs); }
@@ -623,11 +640,11 @@ public:
 	DT_FATAL
     };
     enum en m_e;
-    inline AstDisplayType () : m_e(DT_DISPLAY) {}
+    inline AstDisplayType() : m_e(DT_DISPLAY) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstDisplayType (en _e) : m_e(_e) {}
-    explicit inline AstDisplayType (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstDisplayType(en _e) : m_e(_e) {}
+    explicit inline AstDisplayType(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     bool addNewline() const { return m_e!=DT_WRITE; }
     bool needScopeTracking() const { return m_e!=DT_DISPLAY && m_e!=DT_WRITE; }
     const char* ascii() const {
@@ -650,9 +667,9 @@ public:
     enum en m_e;
     inline AstParseRefExp() : m_e(PX_NONE) {}
     // cppcheck-suppress noExplicitConstructor
-    inline AstParseRefExp (en _e) : m_e(_e) {}
-    explicit inline AstParseRefExp (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline AstParseRefExp(en _e) : m_e(_e) {}
+    explicit inline AstParseRefExp(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     const char* ascii() const {
 	static const char* const names[] = {
 	    "","TEXT","PREDOT"};
@@ -661,7 +678,7 @@ public:
   inline bool operator== (AstParseRefExp lhs, AstParseRefExp rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstParseRefExp lhs, AstParseRefExp::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (AstParseRefExp::en lhs, AstParseRefExp rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, const AstParseRefExp& rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, const AstParseRefExp& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 // VNumRange - Structure containing numberic range information
@@ -715,9 +732,9 @@ struct VNumRange {
     int hiMaxSelect() const { return (lo()<0 ? hi()-lo() : hi()); } // Maximum value a [] select may index
     bool representableByWidth() const  // Could be represented by just width=1, or [width-1:0]
 	{ return (!m_ranged || (m_lo==0 && m_hi>=1 && !m_littleEndian)); }
-    void dump(ostream& str) const { if (ranged()) str<<"["<<left()<<":"<<right()<<"]"; else str<<"[norg]"; }
+    void dump(std::ostream& str) const { if (ranged()) str<<"["<<left()<<":"<<right()<<"]"; else str<<"[norg]"; }
 };
-inline ostream& operator<<(ostream& os, const VNumRange& rhs) { rhs.dump(os); return os; }
+inline std::ostream& operator<<(std::ostream& os, const VNumRange& rhs) { rhs.dump(os); return os; }
 
 //######################################################################
 
@@ -786,8 +803,8 @@ public:
     inline int	toInt() {
 	return m_u.ui;
     }
-    static inline VNUser fromZero () { return VNUser(0); }
-    static inline VNUser fromInt (int i) { return VNUser(i); }
+    static inline VNUser fromZero() { return VNUser(0); }
+    static inline VNUser fromInt(int i) { return VNUser(i); }
 };
 
 //######################################################################
@@ -891,10 +908,12 @@ public:
 
 class AstNVisitor {
 private:
-    vector<AstNode*> m_deleteps;  // Nodes to delete when doDeletes() called
+    // MEMBERS
+    std::vector<AstNode*> m_deleteps;  // Nodes to delete when doDeletes() called
 protected:
     friend class AstNode;
 public:
+    // METHODS
     /// At the end of the visitor (or doDeletes()), delete this pushed node
     /// along with all children and next(s). This is often better to use
     /// than an immediate deleteTree, as any pointers into this node will
@@ -908,6 +927,21 @@ public:
     virtual ~AstNVisitor() {
 	doDeletes();
     }
+    /// Call visit()s on nodep
+    void iterate(AstNode* nodep);
+    /// Call visit()s on nodep's children
+    void iterateChildren(AstNode* nodep);
+    /// Call visit()s on nodep's children in backp() order
+    void iterateChildrenBackwards(AstNode* nodep);
+    /// Call visit()s on const nodep's children
+    void iterateChildrenConst(AstNode* nodep);
+    /// Call visit()s on nodep (maybe NULL) and nodep's nextp() list
+    void iterateAndNextNull(AstNode* nodep);
+    /// Call visit()s on const nodep (maybe NULL) and nodep's nextp() list
+    void iterateAndNextConstNull(AstNode* nodep);
+    /// Return edited nodep; see comments in V3Ast.cpp
+    AstNode* iterateSubtreeReturnEdits(AstNode* nodep);
+
 #include "V3Ast__gen_visitor.h"	// From ./astgen
     // Things like:
     //  virtual void visit(AstBreak* nodep) { visit((AstNodeStmt*)(nodep)); }
@@ -932,9 +966,9 @@ public:
     AstNRelinker() { m_oldp=NULL; m_backp=NULL; m_chg=RELINK_BAD; m_iterpp=NULL;}
     void relink(AstNode* newp);
     AstNode* oldp() const { return m_oldp; }
-    void dump(ostream& str=cout) const;
+    void dump(std::ostream& str=std::cout) const;
 };
-inline ostream& operator<<(ostream& os, const AstNRelinker& rhs) { rhs.dump(os); return os;}
+inline std::ostream& operator<<(std::ostream& os, const AstNRelinker& rhs) { rhs.dump(os); return os;}
 
 //######################################################################
 // V3Hash -- Node hashing for V3Combine
@@ -984,7 +1018,7 @@ public:
     V3Hash(V3Hash h1, V3Hash h2, V3Hash h3, V3Hash h4) {
 	setBoth(1,((h1.hshval()*31+h2.hshval())*31+h3.hshval())*31+h4.hshval()); }
 };
-ostream& operator<<(ostream& os, const V3Hash& rhs);
+std::ostream& operator<<(std::ostream& os, const V3Hash& rhs);
 
 //######################################################################
 // AstNode -- Base type of all Ast types
@@ -1042,14 +1076,13 @@ class AstNode {
     void	op4p(AstNode* nodep) { m_op4p = nodep; if (nodep) nodep->m_backp = this; }
 
     void	init();	// initialize value of AstNode
-    void	iterateListBackwards(AstNVisitor& v);
 private:
     AstNode*	cloneTreeIter();
     AstNode*	cloneTreeIterList();
     void	checkTreeIter(AstNode* backp);
     void	checkTreeIterList(AstNode* backp);
-    bool	gateTreeIter();
-    bool	sameTreeIter(AstNode* node1p, AstNode* node2p, bool ignNext, bool gateOnly);
+    bool        gateTreeIter() const;
+    static bool sameTreeIter(const AstNode* node1p, const AstNode* node2p, bool ignNext, bool gateOnly);
     void	deleteTreeIter();
     void	deleteNode();
 public:
@@ -1241,11 +1274,11 @@ public:
 
     // ACCESSORS for specific types
     // Alas these can't be virtual or they break when passed a NULL
-    bool	isZero();
-    bool	isOne();
-    bool	isNeqZero();
-    bool	isAllOnes();
-    bool	isAllOnesV();  // Verilog width rules apply
+    bool isZero() const;
+    bool isOne() const;
+    bool isNeqZero() const;
+    bool isAllOnes() const;
+    bool isAllOnesV() const;  // Verilog width rules apply
 
     // METHODS - data type changes especially for initial creation
     void	dtypep(AstNodeDType* nodep) { if (m_dtypep != nodep) { m_dtypep = nodep; editCountInc(); } }
@@ -1276,10 +1309,10 @@ public:
     AstBasicDType* findInsertSameDType(AstBasicDType* nodep);
 
     // METHODS - dump and error
-    void	v3errorEnd(ostringstream& str) const;
-    void	v3errorEndFatal(ostringstream& str) const VL_ATTR_NORETURN;
+    void        v3errorEnd(std::ostringstream& str) const;
+    void        v3errorEndFatal(std::ostringstream& str) const VL_ATTR_NORETURN;
     string	warnMore() const;
-    virtual void dump(ostream& str=cout);
+    virtual void dump(std::ostream& str=std::cout);
     void	dumpGdb(); // For GDB only
     void	dumpGdbHeader() const;
 
@@ -1303,19 +1336,21 @@ public:
     virtual void addBeforeStmt(AstNode* newp, AstNode* belowp);  // When calling, "this" is second argument
 
     // METHODS - Iterate on a tree
+    static AstNode* cloneTreeNull(AstNode* nodep, bool cloneNextLink) {  // Clone or return NULL if NULL
+        return nodep ? nodep->cloneTree(cloneNextLink) : NULL; }
     AstNode*	cloneTree(bool cloneNextLink);
     bool	gateTree() { return gateTreeIter(); }  // Is tree isGateOptimizable?
-    bool	sameTree(AstNode* node2p);	// Does tree of this == node2p?
-    bool	sameGateTree(AstNode* node2p);	// Does tree of this == node2p?, not allowing non-isGateOptimizable
+    bool        sameTree(const AstNode* node2p) const;  // Does tree of this == node2p?
+    bool        sameGateTree(const AstNode* node2p) const;  // Does tree of this == node2p?, not allowing non-isGateOptimizable
     void	deleteTree();	// Always deletes the next link
     void	checkTree();  // User Interface version
     void	checkIter() const;
     void	clearIter() { m_iterpp=NULL; }
-    void	dumpPtrs(ostream& str=cout) const;
-    void	dumpTree(ostream& str=cout, const string& indent="    ", int maxDepth=0);
+    void        dumpPtrs(std::ostream& str=std::cout) const;
+    void        dumpTree(std::ostream& str=std::cout, const string& indent="    ", int maxDepth=0);
     void	dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
     void	dumpTreeGdb(); // For GDB only
-    void	dumpTreeAndNext(ostream& str=cout, const string& indent="    ", int maxDepth=0);
+    void        dumpTreeAndNext(std::ostream& str=std::cout, const string& indent="    ", int maxDepth=0);
     void	dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
     static void	dumpTreeFileGdb(const char* filenamep=NULL);
 
@@ -1341,21 +1376,27 @@ public:
 
     // INVOKERS
     virtual void accept(AstNVisitor& v) = 0;
-    void	iterate(AstNVisitor& v) { this->accept(v); } 	  // Does this; excludes following this->next
-    void	iterateAndNext(AstNVisitor& v);
-    void	iterateAndNextConst(AstNVisitor& v);
-    void	iterateChildren(AstNVisitor& v);  // Excludes following this->next
-    void	iterateChildrenBackwards(AstNVisitor& v);  // Excludes following this->next
-    void	iterateChildrenConst(AstNVisitor& v);  // Excludes following this->next
-    AstNode*	iterateSubtreeReturnEdits(AstNVisitor& v);  // Return edited nodep; see comments in V3Ast.cpp
+
+protected:
+    // All AstNVisitor related functions are called as methods off the visitor
+    friend class AstNVisitor;
+    void iterateChildren(AstNVisitor& v);  // Use instead AstNVisitor::iterateChildren
+    void iterateChildrenBackwards(AstNVisitor& v);  // Use instead AstNVisitor::iterateChildrenBackwards
+    void iterateChildrenConst(AstNVisitor& v);  // Use instead AstNVisitor::iterateChildrenConst
+    void iterateAndNext(AstNVisitor& v);  // Use instead AstNVisitor::iterateAndNextNull
+    void iterateAndNextConst(AstNVisitor& v);  // Use instead AstNVisitor::iterateAndNextConstNull
+    AstNode* iterateSubtreeReturnEdits(AstNVisitor& v);  // Use instead AstNVisitor::iterateSubtreeReturnEdits
+private:
+    void iterateListBackwards(AstNVisitor& v);
 
     // CONVERSION
+public:
 #include "V3Ast__gen_interface.h"	// From ./astgen
     // Things like:
     //  AstAlways*	castAlways();
 };
 
-inline ostream& operator<<(ostream& os, AstNode* rhs) { if (!rhs) os<<"NULL"; else rhs->dump(os); return os; }
+inline std::ostream& operator<<(std::ostream& os, AstNode* rhs) { if (!rhs) os<<"NULL"; else rhs->dump(os); return os; }
 inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
 
 //######################################################################
@@ -1364,6 +1405,8 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
 
 #define ASTNODE_BASE_FUNCS(name)	\
     virtual ~Ast ##name() {} \
+    static Ast ##name * cloneTreeNull(Ast ##name * nodep, bool cloneNextLink) { \
+        return nodep ? nodep->cloneTree(cloneNextLink) : NULL; } \
     Ast ##name * cloneTree(bool cloneNext) { return static_cast<Ast ##name *>(AstNode::cloneTree(cloneNext)); } \
     Ast ##name * clonep() const { return static_cast<Ast ##name *>(AstNode::clonep()); }
 
@@ -1381,7 +1424,7 @@ public:
     virtual bool cleanOut() = 0; // True if output has extra upper bits zero
     // Someday we will generically support data types on every math node
     // Until then isOpaque indicates we shouldn't constant optimize this node type
-    bool isOpaque() { return castCvtPackString()!=NULL; }
+    bool isOpaque() { return VN_IS(this, CvtPackString); }
 };
 
 class AstNodeTermop : public AstNodeMath {
@@ -1523,7 +1566,7 @@ public:
     AstNode*	fromp() const { return lhsp(); }
     AstNode*	rhsp() 	const { return op2p(); }
     AstNode*	thsp() 	const { return op3p(); }
-    AstAttrOf*	attrp() const { return op4p()->castAttrOf(); }
+    AstAttrOf* attrp() const { return VN_CAST(op4p(), AttrOf); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
     void	rhsp(AstNode* nodep)  { return setOp2p(nodep); }
     void	thsp(AstNode* nodep)  { return setOp3p(nodep); }
@@ -1618,7 +1661,7 @@ public:
     ASTNODE_BASE_FUNCS(NodeCase)
     virtual int   instrCount()	const { return instrCountBranch(); }
     AstNode*	  exprp()	const { return op1p(); }	// op1 = case condition <expression>
-    AstCaseItem*  itemsp()	const { return op2p()->castCaseItem(); }  // op2 = list of case expressions
+    AstCaseItem* itemsp() const { return VN_CAST(op2p(), CaseItem); }  // op2 = list of case expressions
     AstNode*	  notParallelp() const { return op3p(); }	// op3 = assertion code for non-full case's
     void addItemsp(AstNode* nodep) { addOp2p(nodep); }
     void addNotParallelp(AstNode* nodep) { setOp3p(nodep); }
@@ -1694,7 +1737,7 @@ public:
 	m_text = textp;	// Copy it
     }
     ASTNODE_BASE_FUNCS(NodeText)
-    virtual void dump(ostream& str=cout);
+    virtual void dump(std::ostream& str=std::cout);
     virtual V3Hash sameHash() const { return V3Hash(text()); }
     virtual bool same(const AstNode* samep) const {
 	const AstNodeText* asamep = static_cast<const AstNodeText*>(samep);
@@ -1720,8 +1763,8 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeDType)
     // ACCESSORS
-    virtual void dump(ostream& str);
-    virtual void dumpSmall(ostream& str);
+    virtual void dump(std::ostream& str);
+    virtual void dumpSmall(std::ostream& str);
     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
@@ -1755,7 +1798,7 @@ public:
     bool generic() const { return m_generic; }
     void generic(bool flag) { m_generic = flag; }
     AstNodeDType* dtypeDimensionp(int depth);
-    pair<uint32_t,uint32_t> dimensions(bool includeBasic);
+    std::pair<uint32_t,uint32_t> dimensions(bool includeBasic);
     uint32_t	arrayUnpackedElements();	// 1, or total multiplication of all dimensions
     static int uniqueNumInc() { return ++s_uniqueNum; }
     const char* charIQWN() const { return (isString() ? "N" : isWide() ? "W" : isQuad() ? "Q" : "I"); }
@@ -1764,7 +1807,7 @@ public:
 class AstNodeClassDType : public AstNodeDType {
 private:
     // TYPES
-    typedef map<string,AstMemberDType*> MemberNameMap;
+    typedef std::map<string,AstMemberDType*> MemberNameMap;
     // MEMBERS
     bool		m_packed;
     bool		m_isFourstate;
@@ -1779,11 +1822,12 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeClassDType)
     virtual const char* broken() const;
-    virtual void dump(ostream& str);
+    virtual void dump(std::ostream& str);
     // For basicp() we reuse the size to indicate a "fake" basic type of same size
     virtual AstBasicDType* basicp() const {
-        return (isFourstate() ? findLogicDType(width(),width(),numeric())->castBasicDType()
-                : findBitDType(width(),width(),numeric())->castBasicDType()); }
+        return (isFourstate()
+                ? VN_CAST(findLogicDType(width(),width(),numeric()), BasicDType)
+                : VN_CAST(findBitDType(width(),width(),numeric()), BasicDType)); }
     virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; }
     virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; }
     virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; }
@@ -1793,7 +1837,7 @@ public:
     virtual bool similarDType(AstNodeDType* samep) const {
 	return this==samep;  // We don't compare members, require exact equivalence
     }
-    AstMemberDType* membersp() const { return op1p()->castMemberDType(); } // op1 = AstMember list
+    AstMemberDType* membersp() const { return VN_CAST(op1p(), MemberDType); }  // op1 = AstMember list
     void addMembersp(AstNode* nodep) { addNOp1p(nodep); }
     bool packed() const { return m_packed; }
     bool packedUnsup() const { return true; }  // packed() but as don't support unpacked, presently all structs
@@ -1822,8 +1866,8 @@ public:
 	m_refDTypep = NULL;
     }
     ASTNODE_BASE_FUNCS(NodeArrayDType)
-    virtual void dump(ostream& str);
-    virtual void dumpSmall(ostream& str);
+    virtual void dump(std::ostream& str);
+    virtual void dumpSmall(std::ostream& str);
     virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
 						      || (!m_refDTypep && childDTypep()))); return NULL; }
     virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
@@ -1844,13 +1888,13 @@ public:
     }
     virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_refDTypep),V3Hash(msb()),V3Hash(lsb())); }
     AstNodeDType* getChildDTypep() const { return childDTypep(); }
-    AstNodeDType* childDTypep() const { return op1p()->castNodeDType(); } // op1 = Range of variable
+    AstNodeDType* childDTypep() const { return VN_CAST(op1p(), NodeDType); }  // op1 = Range of variable
     void	childDTypep(AstNodeDType* nodep) { setOp1p(nodep); }
     virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); }
     void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
     virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; }
     virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); }
-    AstRange*	rangep() const { return op2p()->castRange(); }	// op2 = Array(s) of variable
+    AstRange* rangep() const { return VN_CAST(op2p(), Range); }  // op2 = Array(s) of variable
     void	rangep(AstRange* nodep);
     // METHODS
     virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); }  // (Slow) recurse down to find basic data type
@@ -1919,7 +1963,7 @@ public:
 	cname(name);  // Might be overridden by dpi import/export
     }
     ASTNODE_BASE_FUNCS(NodeFTask)
-    virtual void dump(ostream& str=cout);
+    virtual void dump(std::ostream& str=std::cout);
     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); }
@@ -1935,7 +1979,7 @@ public:
     AstNode*	stmtsp() 	const { return op3p(); }	// op3 = List of statements
     void	addStmtsp(AstNode* nodep) { addNOp3p(nodep); }
     // op4 = scope name
-    AstScopeName* scopeNamep() const { return op4p()->castScopeName(); }
+    AstScopeName* scopeNamep() const { return VN_CAST(op4p(), ScopeName); }
     // MORE ACCESSORS
     void dpiOpenParentInc() { ++m_dpiOpenParent; }
     void dpiOpenParentClear() { m_dpiOpenParent=0; }
@@ -1985,7 +2029,7 @@ public:
     virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
 	m_taskp = m_taskp->clonep();
     }}
-    virtual void dump(ostream& str=cout);
+    virtual void dump(std::ostream& str=std::cout);
     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 ""
@@ -2004,7 +2048,7 @@ public:
     AstNode*	pinsp() 	const { return op2p(); }
     void addPinsp(AstNode* nodep) { addOp2p(nodep); }
     // op3 = scope tracking
-    AstScopeName* scopeNamep() const { return op3p()->castScopeName(); }
+    AstScopeName* scopeNamep() const { return VN_CAST(op3p(), ScopeName); }
     void 	scopeNamep(AstNode* nodep) { setNOp3p(nodep); }
 };
 
@@ -2027,17 +2071,17 @@ private:
     int		m_typeNum;	// Incrementing implicit type number
 public:
     AstNodeModule(FileLine* fl, const string& name)
-	: AstNode (fl)
+        : AstNode(fl)
 	,m_name(name), m_origName(name)
 	,m_modPublic(false), m_modTrace(false), m_inLibrary(false), m_dead(false)
 	,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(ostream& str);
+    virtual void dump(std::ostream& str);
     virtual bool maybePointedTo() const { return true; }
     virtual string name()	const { return m_name; }
     AstNode*	stmtsp() 	const { return op2p(); }	// op2 = List of statements
-    AstActive*  activesp()	const { return op3p()->castActive(); }	// op3 = List of i/sblocks
+    AstActive* activesp() const { return VN_CAST(op3p(), Active); }  // op3 = List of i/sblocks
     // METHODS
     void addInlinesp(AstNode* nodep) { addOp1p(nodep); }
     void addStmtp(AstNode* nodep) { addOp2p(nodep); }
@@ -2069,7 +2113,7 @@ public:
 class AstNodeRange : public AstNode {
     // A range, sized or unsized
 public:
-    explicit AstNodeRange(FileLine* fl) : AstNode (fl) { }
+    explicit AstNodeRange(FileLine* fl) : AstNode(fl) { }
     ASTNODE_BASE_FUNCS(NodeRange)
 };
 
@@ -2079,7 +2123,33 @@ public:
 
 #include "V3Ast__gen_impl.h"	// From ./astgen
 // Things like:
-//  inline AstAlways*	AstNode::castAlways() {	  return dynamic_cast<AstAlways*>(this);}
+//  inline AstAlways* AstNode::castAlways() { return dynamic_cast<AstAlways*>(this);}
+//  inline bool AstNode::privateIsaAlways(const AstNode* nodep) { return nodep && nodep->type() == AstType::atAlways; }
+
+//######################################################################
+// Inline AstNVisitor METHODS
+
+inline void AstNVisitor::iterate(AstNode* nodep) {
+    nodep->accept(*this);
+}
+inline void AstNVisitor::iterateChildren(AstNode* nodep) {
+    nodep->iterateChildren(*this);
+}
+inline void AstNVisitor::iterateChildrenBackwards(AstNode* nodep) {
+    nodep->iterateChildrenBackwards(*this);
+}
+inline void AstNVisitor::iterateChildrenConst(AstNode* nodep) {
+    nodep->iterateChildrenConst(*this);
+}
+inline void AstNVisitor::iterateAndNextNull(AstNode* nodep) {
+    if (VL_LIKELY(nodep)) nodep->iterateAndNext(*this);
+}
+inline void AstNVisitor::iterateAndNextConstNull(AstNode* nodep) {
+    if (VL_LIKELY(nodep)) nodep->iterateAndNextConst(*this);
+}
+inline AstNode* AstNVisitor::iterateSubtreeReturnEdits(AstNode* nodep) {
+    return nodep->iterateSubtreeReturnEdits(*this);
+}
 
 //######################################################################
 // Inline ACCESSORS
@@ -2091,19 +2161,19 @@ inline bool AstNode::width1() const  {  // V3Const uses to know it can optimize
 inline int  AstNode::widthInstrs() const {
     return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1)); }
 inline bool AstNode::isDouble() const {
-    return dtypep() && dtypep()->castBasicDType() && dtypep()->castBasicDType()->isDouble(); }
+    return dtypep() && VN_IS(dtypep(), BasicDType) && VN_CAST(dtypep(), BasicDType)->isDouble(); }
 inline bool AstNode::isString() const {
     return dtypep() && dtypep()->basicp() && dtypep()->basicp()->isString(); }
 inline bool AstNode::isSigned() const {
     return dtypep() && dtypep()->isSigned(); }
 
-inline bool AstNode::isZero()     { return (this->castConst() && this->castConst()->num().isEqZero()); }
-inline bool AstNode::isNeqZero()  { return (this->castConst() && this->castConst()->num().isNeqZero()); }
-inline bool AstNode::isOne()      { return (this->castConst() && this->castConst()->num().isEqOne()); }
-inline bool AstNode::isAllOnes()  { return (this->castConst() && this->castConst()->isEqAllOnes()); }
-inline bool AstNode::isAllOnesV() { return (this->castConst() && this->castConst()->isEqAllOnesV()); }
-inline bool AstNode::sameTree(AstNode* node2p) { return sameTreeIter(this, node2p, true, false); }
-inline bool AstNode::sameGateTree(AstNode* node2p) { return sameTreeIter(this, node2p, true, true); }
+inline bool AstNode::isZero() const     { return (VN_IS(this, Const) && VN_CAST_CONST(this, Const)->num().isEqZero()); }
+inline bool AstNode::isNeqZero() const  { return (VN_IS(this, Const) && VN_CAST_CONST(this, Const)->num().isNeqZero()); }
+inline bool AstNode::isOne() const      { return (VN_IS(this, Const) && VN_CAST_CONST(this, Const)->num().isEqOne()); }
+inline bool AstNode::isAllOnes() const  { return (VN_IS(this, Const) && VN_CAST_CONST(this, Const)->isEqAllOnes()); }
+inline bool AstNode::isAllOnesV() const { return (VN_IS(this, Const) && VN_CAST_CONST(this, Const)->isEqAllOnesV()); }
+inline bool AstNode::sameTree(const AstNode* node2p) const { return sameTreeIter(this, node2p, true, false); }
+inline bool AstNode::sameGateTree(const AstNode* node2p) const { return sameTreeIter(this, node2p, true, true); }
 
 inline void AstNodeVarRef::init() { if (m_varp) dtypep(m_varp->dtypep()); }
 

src/V3AstNodes.cpp

@@ -31,6 +31,8 @@
 #include "V3Ast.h"
 #include "V3File.h"
 #include "V3Global.h"
+#include "V3Graph.h"
+#include "V3PartitionGraph.h"  // Just for mtask dumping
 
 //======================================================================
 // Special methods
@@ -44,7 +46,7 @@ const char* AstIfaceRefDType::broken() const {
 }
 
 AstIface* AstIfaceRefDType::ifaceViaCellp() const {
-    return ((m_cellp && m_cellp->modp()) ? m_cellp->modp()->castIface() : m_ifacep);
+    return ((m_cellp && m_cellp->modp()) ? VN_CAST(m_cellp->modp(), Iface) : m_ifacep);
 }
 
 const char* AstNodeVarRef::broken() const {
@@ -58,12 +60,13 @@ void AstNodeVarRef::cloneRelink() {
 }
 
 int AstNodeSel::bitConst() const {
-    AstConst* constp=bitp()->castConst(); return (constp?constp->toSInt():0);
+    AstConst* constp=VN_CAST(bitp(), Const);
+    return (constp ? constp->toSInt() : 0);
 }
 
 void AstNodeClassDType::repairMemberCache() {
     clearCache();
-    for (AstMemberDType* itemp = membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
+    for (AstMemberDType* itemp = membersp(); itemp; itemp=VN_CAST(itemp->nextp(), MemberDType)) {
         if (m_members.find(itemp->name())!=m_members.end()) {
             itemp->v3error("Duplicate declaration of member name: "<<itemp->prettyName()); }
 	else m_members.insert(make_pair(itemp->name(), itemp));
@@ -72,7 +75,7 @@ void AstNodeClassDType::repairMemberCache() {
 
 const char* AstNodeClassDType::broken() const {
     vl_unordered_set<AstMemberDType*> exists;
-    for (AstMemberDType* itemp = membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
+    for (AstMemberDType* itemp = membersp(); itemp; itemp=VN_CAST(itemp->nextp(), MemberDType)) {
 	exists.insert(itemp);
     }
     for (MemberNameMap::const_iterator it=m_members.begin(); it!=m_members.end(); ++it) {
@@ -150,22 +153,26 @@ AstNodeBiop* AstEqWild::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
     }
 }
 
+AstExecGraph::AstExecGraph(FileLine* fileline)
+    : AstNode(fileline) {
+    m_depGraphp = new V3Graph;
+}
+AstExecGraph::~AstExecGraph() {
+    delete m_depGraphp; VL_DANGLING(m_depGraphp);
+}
+
 bool AstVar::isSigPublic() const {
     return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp() && !isGenVar()));
 }
-
 bool AstVar::isScQuad() const {
     return (isSc() && isQuad() && !isScBv() && !isScBigUint());
 }
-
 bool AstVar::isScBv() const {
     return ((isSc() && width() >= v3Global.opt.pinsBv()) || m_attrScBv);
 }
-
 bool AstVar::isScUint() const {
     return ((isSc() && v3Global.opt.pinsScUint() && width() >= 2 && width() <= 64) && !isScBv());
 }
-
 bool AstVar::isScBigUint() const {
     return ((isSc() && v3Global.opt.pinsScBigUint() && width() >= 65 && width() <= 512) && !isScBv());
 }
@@ -244,7 +251,7 @@ string AstVar::vlArgType(bool named, bool forReturn, bool forFunc) const {
         arg += " (& "+name()+")";
         for (AstNodeDType* dtp=dtypep(); dtp; ) {
             dtp = dtp->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-            if (AstUnpackArrayDType* adtypep = dtp->castUnpackArrayDType()) {
+            if (AstUnpackArrayDType* adtypep = VN_CAST(dtp, UnpackArrayDType)) {
                 arg += "["+cvtToStr(adtypep->declRange().elements())+"]";
                 dtp = adtypep->subDTypep();
             } else break;
@@ -316,7 +323,7 @@ string AstVar::vlPropInit() const {
     bool first = true;
     for (AstNodeDType* dtp=dtypep(); dtp; ) {
         dtp = dtp->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-        if (AstNodeArrayDType* adtypep = dtp->castNodeArrayDType()) {
+        if (AstNodeArrayDType* adtypep = VN_CAST(dtp, NodeArrayDType)) {
             if (first) {
                 out += ", VerilatedVarProps::Unpacked()";
                 first = false;
@@ -423,15 +430,15 @@ AstVar* AstVar::scVarRecurse(AstNode* nodep) {
     // See if this is a SC assignment; if so return that type
     // Historically sc variables are identified by a variable
     // attribute. TODO it would better be a data type attribute.
-    if (AstVar* anodep = nodep->castVar()) {
+    if (AstVar* anodep = VN_CAST(nodep, Var)) {
 	if (anodep->isSc()) return anodep;
 	else return NULL;
     }
-    else if (nodep->castVarRef()) {
-	if (nodep->castVarRef()->varp()->isSc()) return nodep->castVarRef()->varp();
+    else if (VN_IS(nodep, VarRef)) {
+        if (VN_CAST(nodep, VarRef)->varp()->isSc()) return VN_CAST(nodep, VarRef)->varp();
 	else return NULL;
     }
-    else if (nodep->castArraySel()) {
+    else if (VN_IS(nodep, ArraySel)) {
 	if (nodep->op1p()) if (AstVar* p = scVarRecurse(nodep->op1p())) return p;
 	if (nodep->op2p()) if (AstVar* p = scVarRecurse(nodep->op2p())) return p;
 	if (nodep->op3p()) if (AstVar* p = scVarRecurse(nodep->op3p())) return p;
@@ -440,6 +447,16 @@ AstVar* AstVar::scVarRecurse(AstNode* nodep) {
     return NULL;
 }
 
+string AstVar::mtasksString() const {
+    std::ostringstream os;
+    os<<" all: ";
+    for (MTaskIdSet::const_iterator it = m_mtaskIds.begin();
+         it != m_mtaskIds.end(); ++it) {
+        os<<*it<<" ";
+    }
+    return os.str();
+}
+
 AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     // dimension passed from AstArraySel::dimension
     // Dimension 0 means the VAR itself, 1 is the closest SEL to the AstVar,
@@ -455,17 +472,16 @@ AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     // TODO this function should be removed in favor of recursing the dtype(),
     // as that allows for more complicated data types.
     int dim = 0;
-    UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
+        if (AstNodeArrayDType* adtypep = VN_CAST(dtypep, NodeArrayDType)) {
 	    if ((dim++)==dimension) {
 		return dtypep;
 	    }
 	    dtypep = adtypep->subDTypep();
 	    continue;
 	}
-	else if (AstBasicDType* adtypep = dtypep->castBasicDType()) {
+        else if (AstBasicDType* adtypep = VN_CAST(dtypep, BasicDType)) {
 	    // AstBasicDType - nothing below, return null
 	    if (adtypep->isRanged()) {
 		if ((dim++) == dimension) {
@@ -474,7 +490,7 @@ AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
 	    }
 	    return NULL;
 	}
-	else if (AstNodeClassDType* adtypep = dtypep->castNodeClassDType()) {
+        else if (AstNodeClassDType* adtypep = VN_CAST(dtypep, NodeClassDType)) {
 	    if (adtypep->packed()) {
 		if ((dim++) == dimension) {
 		    return adtypep;
@@ -490,10 +506,9 @@ AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
 
 uint32_t AstNodeDType::arrayUnpackedElements() {
     uint32_t entries=1;
-    UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstUnpackArrayDType* adtypep = dtypep->castUnpackArrayDType()) {
+        if (AstUnpackArrayDType* adtypep = VN_CAST(dtypep, UnpackArrayDType)) {
 	    entries *= adtypep->elementsConst();
 	    dtypep = adtypep->subDTypep();
 	}
@@ -505,20 +520,19 @@ uint32_t AstNodeDType::arrayUnpackedElements() {
     return entries;
 }
 
-pair<uint32_t,uint32_t> AstNodeDType::dimensions(bool includeBasic) {
+std::pair<uint32_t,uint32_t> AstNodeDType::dimensions(bool includeBasic) {
     // How many array dimensions (packed,unpacked) does this Var have?
     uint32_t packed = 0;
     uint32_t unpacked = 0;
-    UDEBUGONLY(UASSERT(dynamic_cast<AstNode*>(this),"this should not be NULL"););
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
-	    if (adtypep->castPackArrayDType()) packed++;
+        if (const AstNodeArrayDType* adtypep = VN_CAST(dtypep, NodeArrayDType)) {
+            if (VN_IS(adtypep, PackArrayDType)) packed++;
 	    else unpacked++;
 	    dtypep = adtypep->subDTypep();
 	    continue;
 	}
-	else if (AstBasicDType* adtypep = dtypep->castBasicDType()) {
+        else if (const AstBasicDType* adtypep = VN_CAST(dtypep, BasicDType)) {
 	    if (includeBasic && adtypep->isRanged()) packed++;
 	}
 	break;
@@ -538,15 +552,15 @@ int AstNodeDType::widthPow2() const {
 AstNode* AstArraySel::baseFromp(AstNode* nodep) {	///< What is the base variable (or const) this dereferences?
     // Else AstArraySel etc; search for the base
     while (nodep) {
-	if (nodep->castArraySel()) { nodep=nodep->castArraySel()->fromp(); continue; }
-	else if (nodep->castSel()) { nodep=nodep->castSel()->fromp(); continue; }
+        if (VN_IS(nodep, ArraySel)) { nodep=VN_CAST(nodep, ArraySel)->fromp(); continue; }
+        else if (VN_IS(nodep, Sel)) { nodep=VN_CAST(nodep, Sel)->fromp(); continue; }
 	// AstNodeSelPre stashes the associated variable under an ATTROF of AstAttrType::VAR_BASE/MEMBER_BASE so it isn't constified
-	else if (nodep->castAttrOf()) { nodep=nodep->castAttrOf()->fromp(); continue; }
-	else if (nodep->castNodePreSel()) {
-	    if (nodep->castNodePreSel()->attrp()) {
-		nodep=nodep->castNodePreSel()->attrp();
+        else if (VN_IS(nodep, AttrOf)) { nodep=VN_CAST(nodep, AttrOf)->fromp(); continue; }
+        else if (VN_IS(nodep, NodePreSel)) {
+            if (VN_CAST(nodep, NodePreSel)->attrp()) {
+                nodep=VN_CAST(nodep, NodePreSel)->attrp();
 	    } else {
-		nodep=nodep->castNodePreSel()->lhsp();
+                nodep=VN_CAST(nodep, NodePreSel)->lhsp();
 	    }
 	    continue;
 	}
@@ -580,7 +594,7 @@ string AstScope::nameDotless() const {
 
 string AstScopeName::scopePrettyNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=VN_CAST(textp->nextp(), Text)) {
 	out += textp->text();
     }
     // TOP will be replaced by top->name()
@@ -592,7 +606,7 @@ string AstScopeName::scopePrettyNameFormatter(AstText* scopeTextp) const {
 
 string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=VN_CAST(textp->nextp(), Text)) {
 	out += textp->text();
     }
     if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
@@ -610,28 +624,28 @@ string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
 
 bool AstSenTree::hasClocked() const {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=VN_CAST(senp->nextp(), NodeSenItem)) {
 	if (senp->isClocked()) return true;
     }
     return false;
 }
 bool AstSenTree::hasSettle() const {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=VN_CAST(senp->nextp(), NodeSenItem)) {
 	if (senp->isSettle()) return true;
     }
     return false;
 }
 bool AstSenTree::hasInitial() const {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=VN_CAST(senp->nextp(), NodeSenItem)) {
 	if (senp->isInitial()) return true;
     }
     return false;
 }
 bool AstSenTree::hasCombo() const {
     if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
-    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
+    for (AstNodeSenItem* senp = sensesp(); senp; senp=VN_CAST(senp->nextp(), NodeSenItem)) {
 	if (senp->isCombo()) return true;
     }
     return false;
@@ -652,7 +666,7 @@ void AstTypeTable::clearCache() {
     m_detailedMap.clear();
     // Clear generic()'s so dead detection will work
     for (AstNode* nodep = typesp(); nodep; nodep=nodep->nextp()) {
-	if (AstBasicDType* bdtypep = nodep->castBasicDType()) {
+        if (AstBasicDType* bdtypep = VN_CAST(nodep, BasicDType)) {
 	    bdtypep->generic(false);
 	}
     }
@@ -662,7 +676,7 @@ void AstTypeTable::repairCache() {
     // After we mass-change widthMin in V3WidthCommit, we need to correct the table.
     clearCache();
     for (AstNode* nodep = typesp(); nodep; nodep=nodep->nextp()) {
-	if (AstBasicDType* bdtypep = nodep->castBasicDType()) {
+        if (AstBasicDType* bdtypep = VN_CAST(nodep, BasicDType)) {
 	    (void)findInsertSameDType(bdtypep);
 	}
     }
@@ -689,7 +703,7 @@ AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kw
     if (kwd == AstBasicDTypeKwd::LOGIC) idx = IDX0_LOGIC;
     else if (kwd == AstBasicDTypeKwd::BIT) idx = IDX0_BIT;
     else fl->v3fatalSrc("Bad kwd for findLogicBitDType");
-    pair<int,int> widths = make_pair(width,widthMin);
+    std::pair<int,int> widths = make_pair(width,widthMin);
     LogicMap& mapr = m_logicMap[idx][(int)numeric];
     LogicMap::const_iterator it = mapr.find(widths);
     if (it != mapr.end()) return it->second;
@@ -792,12 +806,12 @@ void AstWhile::addNextStmt(AstNode* newp, AstNode* belowp) {
 //======================================================================
 // Per-type Debugging
 
-void AstNode::dump(ostream& str) {
+void AstNode::dump(std::ostream& str) {
     str<<typeName()<<" "<<(void*)this
 	//<<" "<<(void*)this->m_backp
-       <<" <e"<<dec<<editCount()
+       <<" <e"<<std::dec<<editCount()
        <<((editCount()>=editCountLast())?"#>":">")
-       <<" {"<<fileline()->filenameLetters()<<dec<<fileline()->lineno()<<"}";
+       <<" {"<<fileline()->filenameLetters()<<std::dec<<fileline()->lineno()<<"}";
     if (user1p()) str<<" u1="<<(void*)user1p();
     if (user2p()) str<<" u2="<<(void*)user2p();
     if (user3p()) str<<" u3="<<(void*)user3p();
@@ -813,50 +827,50 @@ void AstNode::dump(ostream& str) {
 	if (dtypep()) str<<" %Error-dtype-exp=null,got="<<(void*)dtypep();
     }
     if (name()!="") {
-	if (castConst()) str<<"  "<<name();  // Already quoted
+        if (VN_IS(this, Const)) str<<"  "<<name();  // Already quoted
 	else str<<"  "<<V3Number::quoteNameControls(name());
     }
 }
 
-void AstAlways::dump(ostream& str) {
+void AstAlways::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (keyword() != VAlwaysKwd::ALWAYS) str<<" ["<<keyword().ascii()<<"]";
 }
 
-void AstAttrOf::dump(ostream& str) {
+void AstAttrOf::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" ["<<attrType().ascii()<<"]";
 }
-void AstBasicDType::dump(ostream& str) {
+void AstBasicDType::dump(std::ostream& str) {
     this->AstNodeDType::dump(str);
     str<<" kwd="<<keyword().ascii();
     if (isRanged() && !rangep()) str<<" range=["<<left()<<":"<<right()<<"]";
 }
-void AstCCast::dump(ostream& str) {
+void AstCCast::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" sz"<<size();
 }
-void AstCell::dump(ostream& str) {
+void AstCell::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (recursive()) str<<" [RECURSIVE]";
     if (modp()) { str<<" -> "; modp()->dump(str); }
     else { str<<" ->UNLINKED:"<<modName(); }
 }
-void AstCellInline::dump(ostream& str) {
+void AstCellInline::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> "<<origModName();
 }
-void AstDisplay::dump(ostream& str) {
+void AstDisplay::dump(std::ostream& str) {
     this->AstNode::dump(str);
     //str<<" "<<displayType().ascii();
 }
-void AstEnumItemRef::dump(ostream& str) {
+void AstEnumItemRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> ";
     if (itemp()) { itemp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstIfaceRefDType::dump(ostream& str) {
+void AstIfaceRefDType::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (cellName()!="") { str<<" cell="<<cellName(); }
     if (ifaceName()!="") { str<<" if="<<ifaceName(); }
@@ -865,54 +879,54 @@ void AstIfaceRefDType::dump(ostream& str) {
     else if (ifacep()) { str<<" -> "; ifacep()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstIfaceRefDType::dumpSmall(ostream& str) {
+void AstIfaceRefDType::dumpSmall(std::ostream& str) {
     this->AstNodeDType::dumpSmall(str);
     str<<"iface";
 }
-void AstJumpGo::dump(ostream& str) {
+void AstJumpGo::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> ";
     if (labelp()) { labelp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstModportFTaskRef::dump(ostream& str) {
+void AstModportFTaskRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (isExport()) str<<" EXPORT";
     if (isImport()) str<<" IMPORT";
     if (ftaskp()) { str<<" -> "; ftaskp()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstModportVarRef::dump(ostream& str) {
+void AstModportVarRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" "<<varType();
     if (varp()) { str<<" -> "; varp()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstPin::dump(ostream& str) {
+void AstPin::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (modVarp()) { str<<" -> "; modVarp()->dump(str); }
     else { str<<" ->UNLINKED"; }
     if (svImplicit()) str<<" [.SV]";
 }
-void AstTypedef::dump(ostream& str) {
+void AstTypedef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (attrPublic()) str<<" [PUBLIC]";
 }
-void AstRange::dump(ostream& str) {
+void AstRange::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (littleEndian()) str<<" [LITTLE]";
 }
-void AstRefDType::dump(ostream& str) {
+void AstRefDType::dump(std::ostream& str) {
     this->AstNodeDType::dump(str);
     if (defp()) { str<<" -> "; defp()->dump(str); }
     else { str<<" -> UNLINKED"; }
 }
-void AstNodeClassDType::dump(ostream& str) {
+void AstNodeClassDType::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (packed()) str<<" [PACKED]";
     if (isFourstate()) str<<" [4STATE]";
 }
-void AstNodeDType::dump(ostream& str) {
+void AstNodeDType::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (generic()) str<<" [GENERIC]";
     if (AstNodeDType* dtp = virtRefDTypep()) {
@@ -920,7 +934,7 @@ void AstNodeDType::dump(ostream& str) {
 	dtp->dumpSmall(str);
     }
 }
-void AstNodeDType::dumpSmall(ostream& str) {
+void AstNodeDType::dumpSmall(std::ostream& str) {
     str<<"("
        <<(generic()?"G/":"")
        <<((isSigned()&&!isDouble())?"s":"")
@@ -933,16 +947,16 @@ void AstNodeDType::dumpSmall(ostream& str) {
     if (!widthSized()) str<<"/"<<widthMin();
     str<<")";
 }
-void AstNodeArrayDType::dumpSmall(ostream& str) {
+void AstNodeArrayDType::dumpSmall(std::ostream& str) {
     this->AstNodeDType::dumpSmall(str);
-    if (castPackArrayDType()) str<<"p"; else str<<"u";
+    if (VN_IS(this, PackArrayDType)) str<<"p"; else str<<"u";
     str<<declRange();
 }
-void AstNodeArrayDType::dump(ostream& str) {
+void AstNodeArrayDType::dump(std::ostream& str) {
     this->AstNodeDType::dump(str);
     str<<" "<<declRange();
 }
-void AstNodeModule::dump(ostream& str) {
+void AstNodeModule::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<"  L"<<level();
     if (modPublic()) str<<" [P]";
@@ -951,33 +965,38 @@ void AstNodeModule::dump(ostream& str) {
     if (recursiveClone()) str<<" [RECURSIVE-CLONE]";
     else if (recursive()) str<<" [RECURSIVE]";
 }
-void AstPackageExport::dump(ostream& str) {
+void AstPackageExport::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> "<<packagep();
 }
-void AstPackageImport::dump(ostream& str) {
+void AstPackageImport::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> "<<packagep();
 }
-void AstSel::dump(ostream& str) {
+void AstSel::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (declRange().ranged()) {
 	str<<" decl"<<declRange()<<"]";
 	if (declElWidth()!=1) str<<"/"<<declElWidth();
     }
 }
-void AstSliceSel::dump(ostream& str) {
+void AstSliceSel::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (declRange().ranged()) {
         str<<" decl"<<declRange();
     }
 }
-void AstTypeTable::dump(ostream& str) {
+void AstMTaskBody::dump(std::ostream& str) {
+    this->AstNode::dump(str);
+    str<<" ";
+    m_execMTaskp->dump(str);
+}
+void AstTypeTable::dump(std::ostream& str) {
     this->AstNode::dump(str);
     for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
 	if (AstBasicDType* subnodep=m_basicps[i]) {
 	    str<<endl;  // Newline from caller, so newline first
-	    str<<"\t\t"<<setw(8)<<AstBasicDTypeKwd(i).ascii();
+            str<<"\t\t"<<std::setw(8)<<AstBasicDTypeKwd(i).ascii();
 	    str<<"  -> ";
 	    subnodep->dump(str);
 	}
@@ -988,10 +1007,10 @@ void AstTypeTable::dump(ostream& str) {
 	    for (LogicMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
 		AstBasicDType* dtypep = it->second;
 		str<<endl;  // Newline from caller, so newline first
-		stringstream nsstr;
+                std::stringstream nsstr;
 		nsstr<<(isbit?"bw":"lw")
 		     <<it->first.first<<"/"<<it->first.second;
-		str<<"\t\t"<<setw(8)<<nsstr.str();
+                str<<"\t\t"<<std::setw(8)<<nsstr.str();
 		if (issigned) str<<" s"; else str<<" u";
 		str<<"  ->  ";
 		dtypep->dump(str);
@@ -1009,17 +1028,17 @@ void AstTypeTable::dump(ostream& str) {
     }
     // Note get newline from caller too.
 }
-void AstUnsizedArrayDType::dumpSmall(ostream& str) {
+void AstUnsizedArrayDType::dumpSmall(std::ostream& str) {
     this->AstNodeDType::dumpSmall(str);
     str<<"[]";
 }
-void AstVarScope::dump(ostream& str) {
+void AstVarScope::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (isCircular()) str<<" [CIRC]";
     if (varp()) { str<<" -> "; varp()->dump(str); }
     else { str<<" ->UNLINKED"; }
 }
-void AstVarXRef::dump(ostream& str) {
+void AstVarXRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     if (lvalue()) str<<" [LV] => ";
@@ -1030,7 +1049,7 @@ void AstVarXRef::dump(ostream& str) {
     else if (varp()) { varp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstVarRef::dump(ostream& str) {
+void AstVarRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     if (lvalue()) str<<" [LV] => ";
@@ -1039,7 +1058,7 @@ void AstVarRef::dump(ostream& str) {
     else if (varp()) { varp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstVar::dump(ostream& str) {
+void AstVar::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (isSc()) str<<" [SC]";
     if (isPrimaryIO()) str<<(isInout()?" [PIO]":(isInput()?" [PI]":" [PO]"));
@@ -1063,35 +1082,35 @@ void AstVar::dump(ostream& str) {
     if (!attrClocker().unknown()) str<<" ["<<attrClocker().ascii()<<"] ";
     str<<" "<<varType();
 }
-void AstSenTree::dump(ostream& str) {
+void AstSenTree::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (isMulti()) str<<" [MULTI]";
 }
-void AstSenItem::dump(ostream& str) {
+void AstSenItem::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" ["<<edgeType().ascii()<<"]";
 }
-void AstParseRef::dump(ostream& str) {
+void AstParseRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" ["<<expect().ascii()<<"]";
 }
-void AstPackageRef::dump(ostream& str) {
+void AstPackageRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     str<<" -> ";
     if (packagep()) { packagep()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstDot::dump(ostream& str) {
+void AstDot::dump(std::ostream& str) {
     this->AstNode::dump(str);
 }
-void AstActive::dump(ostream& str) {
+void AstActive::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" => ";
     if (sensesp()) { sensesp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstNodeFTaskRef::dump(ostream& str) {
+void AstNodeFTaskRef::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     str<<" -> ";
@@ -1099,7 +1118,7 @@ void AstNodeFTaskRef::dump(ostream& str) {
     if (taskp()) { taskp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
-void AstNodeFTask::dump(ostream& str) {
+void AstNodeFTask::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (taskPublic()) str<<" [PUBLIC]";
     if (prototype()) str<<" [PROTOTYPE]";
@@ -1109,34 +1128,34 @@ void AstNodeFTask::dump(ostream& str) {
     if (dpiOpenParent()) str<<" [DPIOPENPARENT]";
     if ((dpiImport() || dpiExport()) && cname()!=name()) str<<" [c="<<cname()<<"]";
 }
-void AstBegin::dump(ostream& str) {
+void AstBegin::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (unnamed()) str<<" [UNNAMED]";
     if (generate()) str<<" [GEN]";
     if (genforp()) str<<" [GENFOR]";
 }
-void AstCoverDecl::dump(ostream& str) {
+void AstCoverDecl::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (this->dataDeclNullp()) {
 	str<<" -> ";
 	this->dataDeclNullp()->dump(str);
     } else {
-	if (binNum()) { str<<" bin"<<dec<<binNum(); }
+        if (binNum()) { str<<" bin"<<std::dec<<binNum(); }
     }
 }
-void AstCoverInc::dump(ostream& str) {
+void AstCoverInc::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> ";
     if (declp()) { declp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstTraceInc::dump(ostream& str) {
+void AstTraceInc::dump(std::ostream& str) {
     this->AstNode::dump(str);
     str<<" -> ";
     if (declp()) { declp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
-void AstNodeText::dump(ostream& str) {
+void AstNodeText::dump(std::ostream& str) {
     this->AstNode::dump(str);
     string out = text();
     string::size_type pos;
@@ -1147,19 +1166,19 @@ void AstNodeText::dump(ostream& str) {
     str<<" \""<<out<<"\"";
 }
 
-void AstCFile::dump(ostream& str) {
+void AstCFile::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (source()) str<<" [SRC]";
     if (slow()) str<<" [SLOW]";
 }
-void AstCCall::dump(ostream& str) {
+void AstCCall::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (funcp()) {
 	str<<" "<<funcp()->name()<<" => ";
 	funcp()->dump(str);
     }
 }
-void AstCFunc::dump(ostream& str) {
+void AstCFunc::dump(std::ostream& str) {
     this->AstNode::dump(str);
     if (slow()) str<<" [SLOW]";
     if (pure()) str<<" [PURE]";

src/V3Begin.cpp

@@ -77,17 +77,13 @@ private:
     int			m_ifDepth;	// Current if depth
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     // VISITORS
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_repeatNum = 0;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstNodeFTask* nodep) {
@@ -107,7 +103,7 @@ private:
 	    m_namedScope = "";
 	    m_unnamedScope = "";
 	    m_ftaskp = nodep;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    m_ftaskp = NULL;
 	}
 	m_namedScope = oldScope;
@@ -143,7 +139,7 @@ private:
 	    }
 
 	    // Remap var names and replace lower Begins
-	    nodep->stmtsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->stmtsp());
 	    if (nodep->genforp()) nodep->v3fatalSrc("GENFORs should have been expanded earlier");
 	}
 	m_namedScope = oldScope;
@@ -184,7 +180,7 @@ private:
 	    nodep->unlinkFrBack();
 	    m_modp->addStmtp(nodep);
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstVarXRef* nodep) {
 	UINFO(9, "   VARXREF "<<nodep<<endl);
@@ -204,12 +200,12 @@ private:
 	    nodep->scopeAttrp(new AstText(nodep->fileline(), (string)"__DOT__"+m_namedScope));
 	    if (afterp) nodep->scopeAttrp(afterp);
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstCoverDecl* nodep) {
 	// Don't need to fix path in coverage statements, they're not under
 	// any BEGINs, but V3Coverage adds them all under the module itself.
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     // VISITORS - LINT CHECK
     virtual void visit(AstIf* nodep) { // Note not AstNodeIf; other types don't get covered
@@ -223,11 +219,11 @@ private:
 	    nodep->fileline()->modifyWarnOff(V3ErrorCode::IFDEPTH, true);  // Warn only once
 	    m_ifDepth = -1;
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_ifDepth = prevIfDepth;
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -237,7 +233,7 @@ public:
 	m_ftaskp = NULL;
 	m_repeatNum = 0;
 	m_ifDepth = 0;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~BeginVisitor() {}
 };
@@ -257,14 +253,14 @@ private:
 	    UINFO(9, "    relinkFTask "<<nodep<<endl);
 	    nodep->name(nodep->taskp()->name());
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()->user1()) { // It was converted
 	    UINFO(9, "    relinVarRef "<<nodep<<endl);
 	    nodep->name(nodep->varp()->name());
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstIfaceRefDType* nodep) {
 	// May have changed cell names
@@ -272,16 +268,16 @@ private:
 	UINFO(8,"   IFACEREFDTYPE "<<nodep<<endl);
 	if (nodep->cellp()) nodep->cellName(nodep->cellp()->name());
 	UINFO(8,"       rename to "<<nodep<<endl);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //--------------------
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     BeginRelinkVisitor(AstNetlist* nodep, BeginState*) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~BeginRelinkVisitor() {}
 };

src/V3Branch.cpp

@@ -49,7 +49,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // TYPES
-    typedef vector<AstCFunc*> CFuncVec;
+    typedef std::vector<AstCFunc*> CFuncVec;
 
     // STATE
     int		m_likely;	// Excuses for branch likely taken
@@ -57,11 +57,7 @@ private:
     CFuncVec	m_cfuncsp;	// List of all tasks
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void reset() {
 	m_likely = false;
@@ -82,12 +78,12 @@ private:
 	{
 	    // Do if
 	    reset();
-	    nodep->ifsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->ifsp());
 	    int ifLikely = m_likely;
 	    int ifUnlikely = m_unlikely;
 	    // Do else
 	    reset();
-	    nodep->elsesp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->elsesp());
 	    int elseLikely = m_likely;
 	    int elseUnlikely = m_unlikely;
 	    // Compute
@@ -104,16 +100,16 @@ private:
     virtual void visit(AstCCall* nodep) {
 	checkUnlikely(nodep);
 	nodep->funcp()->user1Inc();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstCFunc* nodep) {
 	checkUnlikely(nodep);
 	m_cfuncsp.push_back(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNode* nodep) {
 	checkUnlikely(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     // METHODS
@@ -130,7 +126,7 @@ public:
     // CONSTUCTORS
     explicit BranchVisitor(AstNetlist* nodep) {
 	reset();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	calc_tasks();
     }
     virtual ~BranchVisitor() {}

src/V3Broken.cpp

@@ -155,9 +155,9 @@ public:
 		    // Use only AstNode::dump instead of the virtual one, as there
 		    // may be varp() and other cross links that are bad.
 		    if (v3Global.opt.debugCheck()) {
-			cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
-			((AstNode*)(it->first))->AstNode::dump(cerr);
-			cerr<<endl;
+                        std::cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
+                        ((AstNode*)(it->first))->AstNode::dump(std::cerr);
+                        std::cerr<<endl;
 			V3Error::incErrors();
 		    }
 		    it->second |= FLAG_LEAKED;
@@ -193,7 +193,7 @@ private:
     // METHODS
     void processAndIterate(AstNode* nodep) {
 	BrokenTable::addInTree(nodep, nodep->maybePointedTo());
-	nodep->iterateChildrenConst(*this);
+        iterateChildrenConst(nodep);
     }
     // VISITORS
     virtual void visit(AstNode* nodep) {
@@ -202,7 +202,7 @@ private:
 public:
     // CONSTUCTORS
     explicit BrokenMarkVisitor(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~BrokenMarkVisitor() {}
 };
@@ -212,7 +212,7 @@ public:
 
 class BrokenCheckVisitor : public AstNVisitor {
 private:
-    void checkWidthMin(AstNode* nodep) {
+    void checkWidthMin(const AstNode* nodep) {
 	if (nodep->width() != nodep->widthMin()
 	    && v3Global.widthMinUsage()==VWidthMinUsage::MATCHES_WIDTH) {
 	    nodep->v3fatalSrc("Width != WidthMin");
@@ -225,10 +225,9 @@ private:
 	}
 	if (nodep->dtypep()) {
             if (!nodep->dtypep()->brokeExists()) {
-                nodep->v3fatalSrc("Broken link in node->dtypep() to "<<(void*)nodep->dtypep());
-            } else if (!nodep->dtypep()->castNodeDType()) {
-                nodep->v3fatalSrc("Non-dtype link in node->dtypep() to "<<(void*)nodep->dtypep());
-            }
+                nodep->v3fatalSrc("Broken link in node->dtypep() to "<<(void*)nodep->dtypep()); }
+            else if (!VN_IS(nodep->dtypep(), NodeDType)) {
+                nodep->v3fatalSrc("Non-dtype link in node->dtypep() to "<<(void*)nodep->dtypep()); }
 	}
 	if (v3Global.assertDTypesResolved()) {
 	    if (nodep->hasDType()) {
@@ -237,18 +236,18 @@ private:
 		if (nodep->dtypep()) nodep->v3fatalSrc("DType on node without hasDType(): "<<nodep->prettyTypeName());
 	    }
 	    if (nodep->getChildDTypep()) nodep->v3fatalSrc("childDTypep() non-null on node after should have removed");
-	    if (AstNodeDType* dnodep = nodep->castNodeDType()) checkWidthMin(dnodep);
+            if (const AstNodeDType* dnodep = VN_CAST(nodep, NodeDType)) checkWidthMin(dnodep);
 	}
 	checkWidthMin(nodep);
-	nodep->iterateChildrenConst(*this);
+        iterateChildrenConst(nodep);
 	BrokenTable::setUnder(nodep,false);
     }
     virtual void visit(AstNodeAssign* nodep) {
 	processAndIterate(nodep);
 	if (v3Global.assertDTypesResolved()
 	    && nodep->brokeLhsMustBeLvalue()
-	    && nodep->lhsp()->castNodeVarRef()
-	    && !nodep->lhsp()->castNodeVarRef()->lvalue()) {
+            && VN_IS(nodep->lhsp(), NodeVarRef)
+            && !VN_CAST(nodep->lhsp(), NodeVarRef)->lvalue()) {
 	    nodep->v3fatalSrc("Assignment LHS is not an lvalue");
 	}
     }
@@ -258,7 +257,7 @@ private:
 public:
     // CONSTUCTORS
     explicit BrokenCheckVisitor(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~BrokenCheckVisitor() {}
 };

src/V3CCtors.cpp

@@ -113,9 +113,9 @@ void V3CCtors::evalAsserts() {
     funcp->ifdef("VL_DEBUG");
     modp->addStmtp(funcp);
     for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
-	if (AstVar* varp = np->castVar()) {
+        if (AstVar* varp = VN_CAST(np, Var)) {
 	    if (varp->isPrimaryIn() && !varp->isSc()) {
-		if (AstBasicDType* basicp = varp->dtypeSkipRefp()->castBasicDType()) {
+                if (AstBasicDType* basicp = VN_CAST(varp->dtypeSkipRefp(), BasicDType)) {
 		    int storedWidth = basicp->widthAlignBytes() * 8;
 		    int lastWordWidth = varp->width() % storedWidth;
 		    if (lastWordWidth != 0) {
@@ -145,13 +145,14 @@ void V3CCtors::evalAsserts() {
 void V3CCtors::cctorsAll() {
     UINFO(2,__FUNCTION__<<": "<<endl);
     evalAsserts();
-    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castNodeModule()) {
+    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=VN_CAST(modp->nextp(), NodeModule)) {
         // Process each module in turn
         {
             V3CCtorsVisitor var_reset (modp, "_ctor_var_reset");
             for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
-                if (AstVar* varp = np->castVar()) {
-                    if (!varp->isIfaceParent() && !varp->isIfaceRef()) {
+                if (AstVar* varp = VN_CAST(np, Var)) {
+                    if (!varp->isIfaceParent() && !varp->isIfaceRef()
+                        && !varp->noReset()) {
                         var_reset.add(new AstCReset(varp->fileline(), new AstVarRef(varp->fileline(), varp, true)));
                     }
                 }
@@ -160,9 +161,9 @@ void V3CCtors::cctorsAll() {
         if (v3Global.opt.coverage()) {
             V3CCtorsVisitor configure_coverage
                 (modp, "_configure_coverage", EmitCBaseVisitor::symClassVar()+ ", bool first", "vlSymsp, first",
-                 "if (0 && vlSymsp && first) {} // Prevent unused\n");
+                 "if (0 && vlSymsp && first) {}  // Prevent unused\n");
             for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
-                if (AstCoverDecl* coverp = np->castCoverDecl()) {
+                if (AstCoverDecl* coverp = VN_CAST(np, CoverDecl)) {
                     AstNode* backp = coverp->backp();
                     coverp->unlinkFrBack();
                     configure_coverage.add(coverp);

src/V3Case.cpp

@@ -30,9 +30,9 @@
 //		Or, converts to a if/else tree.
 //	FUTURES:
 //	    Large 16+ bit tables with constants and no masking (address muxes)
-//		Enter all into multimap, sort by value and use a tree of < and == compares.
+//              Enter all into std::multimap, sort by value and use a tree of < and == compares.
 //	    "Diagonal" find of {rightmost,leftmost} bit {set,clear}
-//		Ignoring mask, check each value is unique (using multimap as above?)
+//              Ignoring mask, check each value is unique (using std::multimap as above?)
 //		Each branch is then mask-and-compare operation (IE <000000001_000000000 at midpoint.)
 //
 //*************************************************************************
@@ -59,19 +59,16 @@ class CaseLintVisitor : public AstNVisitor {
 private:
     AstNodeCase* m_caseExprp;	// Under a CASE value node, if so the relevant case statement
 
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    // METHODS
+    VL_DEBUG_FUNC;  // Declare debug()
 
     virtual void visit(AstNodeCase* nodep) {
-	if (nodep->castCase() && nodep->castCase()->casex()) {
+        if (VN_IS(nodep, Case) && VN_CAST(nodep, Case)->casex()) {
 	    nodep->v3warn(CASEX,"Suggest casez (with ?'s) in place of casex (with X's)");
 	}
 	// Detect multiple defaults
 	bool hitDefault = false;
-	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+        for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 	    if (itemp->isDefault()) {
 		if (hitDefault) {
 		    nodep->v3error("Multiple default statements in case statement.");
@@ -83,9 +80,9 @@ private:
 	// Check for X/Z in non-casex statements
 	{
 	    m_caseExprp = nodep;
-	    nodep->exprp()->accept(*this);
-	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
-		itemp->condsp()->iterateAndNext(*this);
+            iterate(nodep->exprp());
+            for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
+                iterateAndNextNull(itemp->condsp());
 	    }
 	    m_caseExprp = NULL;
 	}
@@ -93,12 +90,12 @@ private:
     virtual void visit(AstConst* nodep) {
 	// See also neverItem
 	if (m_caseExprp && nodep->num().isFourState()) {
-	    if (m_caseExprp->castGenCase()) {
+            if (VN_IS(m_caseExprp, GenCase)) {
 		nodep->v3error("Use of x/? constant in generate case statement, (no such thing as 'generate casez')");
-	    } else if (m_caseExprp->castCase() && m_caseExprp->castCase()->casex()) {
+            } else if (VN_IS(m_caseExprp, Case) && VN_CAST(m_caseExprp, Case)->casex()) {
 		// Don't sweat it, we already complained about casex in general
-	    } else if (m_caseExprp->castCase() && (m_caseExprp->castCase()->casez()
-						   || m_caseExprp->castCase()->caseInside())) {
+            } else if (VN_IS(m_caseExprp, Case) && (VN_CAST(m_caseExprp, Case)->casez()
+                                                   || VN_CAST(m_caseExprp, Case)->caseInside())) {
 		if (nodep->num().isUnknown()) {
 		    nodep->v3warn(CASEWITHX, "Use of x constant in casez statement, (perhaps intended ?/z in constant)");
 		}
@@ -108,13 +105,13 @@ private:
 	}
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit CaseLintVisitor(AstNodeCase* nodep) {
 	m_caseExprp = NULL;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CaseLintVisitor() {}
 };
@@ -140,22 +137,18 @@ private:
     AstNode*	m_valueItem[1<<CASE_OVERLAP_WIDTH];  // For each possible value, the case branch we need
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     bool isCaseTreeFast(AstCase* nodep) {
 	int width = 0;
 	bool opaque = false;
 	m_caseItems = 0;
 	m_caseNoOverlapsAllCovered = true;
-	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+        for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 	    for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 		if (icondp->width() > width) width = icondp->width();
 		if (icondp->isDouble()) opaque = true;
-		if (!icondp->castConst()) width = CASE_BARF;  // Can't parse; not a constant
+                if (!VN_IS(icondp, Const)) width = CASE_BARF;  // Can't parse; not a constant
 		m_caseItems++;
 	    }
 	}
@@ -166,14 +159,14 @@ private:
 	}
 	UINFO(8,"Simple case statement: "<<nodep<<endl);
 	// Zero list of items for each value
-	for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) m_valueItem[i] = NULL;
+        for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) m_valueItem[i] = NULL;
 	// Now pick up the values for each assignment
 	// We can cheat and use uint32_t's because we only support narrow case's
 	bool bitched = false;
-	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+        for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 	    for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 		//if (debug()>=9) icondp->dumpTree(cout," caseitem: ");
-		AstConst* iconstp = icondp->castConst();
+                AstConst* iconstp = VN_CAST(icondp, Const);
 		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this");
 		if (neverItem(nodep, iconstp)) {
 		    // X in casez can't ever be executed
@@ -184,12 +177,12 @@ private:
 		    V3Number numval  (itemp->fileline(), iconstp->width());
 		    numval.opBitsOne(iconstp->num());
 		    uint32_t val  = numval.toUInt();
-		    for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
+                    for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) {
 			if ((i & mask) == val) {
 			    if (!m_valueItem[i]) {
 				m_valueItem[i] = itemp;
 			    } else if (!itemp->ignoreOverlap() && !bitched) {
-				itemp->v3warn(CASEOVERLAP,"Case values overlap (example pattern 0x"<<hex<<i<<")");
+                                itemp->v3warn(CASEOVERLAP,"Case values overlap (example pattern 0x"<<std::hex<<i<<")");
 				bitched = true;
 				m_caseNoOverlapsAllCovered = false;
 			    }
@@ -199,14 +192,14 @@ private:
 	    }
 	    // Defaults were moved to last in the caseitem list by V3LinkDot
 	    if (itemp->isDefault()) {  // Case statement's default... Fill the table
-		for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
+                for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) {
 		    if (!m_valueItem[i]) m_valueItem[i] = itemp;
 		}
 	    }
 	}
-	for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
+        for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) {
 	    if (!m_valueItem[i]) {
-		nodep->v3warn(CASEINCOMPLETE,"Case values incompletely covered (example pattern 0x"<<hex<<i<<")");
+                nodep->v3warn(CASEINCOMPLETE,"Case values incompletely covered (example pattern 0x"<<std::hex<<i<<")");
 		m_caseNoOverlapsAllCovered = false;
 		return false;
 	    }
@@ -214,8 +207,8 @@ private:
 	if (m_caseItems <= 3) return false;	// Not worth simplifing
 	// Convert valueItem from AstCaseItem* to the expression
 	// Not done earlier, as we may now have a NULL because it's just a ";" NOP branch
-	for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
-	    m_valueItem[i] = m_valueItem[i]->castCaseItem()->bodysp();
+        for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) {
+            m_valueItem[i] = VN_CAST(m_valueItem[i], CaseItem)->bodysp();
 	}
 	return true;  // All is fine
     }
@@ -278,9 +271,9 @@ private:
 	AstNode* cexprp = nodep->exprp()->unlinkFrBack();
 
 	if (debug()>=9) {
-	    for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
+            for (uint32_t i=0; i<(1UL<<m_caseWidth); ++i) {
 		if (AstNode* itemp = m_valueItem[i]) {
-		    UINFO(9,"Value "<<hex<<i<<" "<<itemp<<endl);
+                    UINFO(9,"Value "<<std::hex<<i<<" "<<itemp<<endl);
 		}
 	    }
 	}
@@ -310,7 +303,7 @@ private:
 	// the appropriate IF AND terms.
 	if (debug()>=9) nodep->dumpTree(cout,"    _comp_IN:   ");
 	bool hadDefault = false;
-	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+        for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 	    if (!itemp->condsp()) {
 		// Default clause.  Just make true, we'll optimize it away later
 		itemp->condsp(new AstConst(itemp->fileline(), AstConst::LogicTrue()));
@@ -324,14 +317,14 @@ private:
 		    icondp->unlinkFrBack();
 
 		    AstNode* condp = NULL;  // Default is to use and1p/and2p
-		    AstConst* iconstp = icondp->castConst();
+                    AstConst* iconstp = VN_CAST(icondp, Const);
 		    if (iconstp && neverItem(nodep, iconstp)) {
 			// X in casez can't ever be executed
 			icondp->deleteTree(); VL_DANGLING(icondp); VL_DANGLING(iconstp);
 			// For simplicity, make expression that is not equal, and let later
 			// optimizations remove it
 			condp = new AstConst(itemp->fileline(), AstConst::LogicFalse());
-		    } else if (AstInsideRange* irangep = icondp->castInsideRange()) {
+                    } else if (AstInsideRange* irangep = VN_CAST(icondp, InsideRange)) {
 			// Similar logic in V3Width::visit(AstInside)
 			AstNode* ap = AstGte::newTyped(itemp->fileline(),
 						       cexprp->cloneTree(false),
@@ -387,7 +380,7 @@ private:
 	AstNode* grouprootp = NULL;
 	AstIf* groupnextp = NULL;
 	AstIf* itemnextp = NULL;
-	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
+        for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=VN_CAST(itemp->nextp(), CaseItem)) {
 	    AstNode* istmtsp = itemp->bodysp();   // Maybe null -- no action.
 	    if (istmtsp) istmtsp->unlinkFrBackWithNext();
 	    // Expressioned clause
@@ -453,7 +446,7 @@ private:
     // VISITORS
     virtual void visit(AstCase* nodep) {
 	V3Case::caseLint(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (debug()>=9) nodep->dumpTree(cout," case_old: ");
 	if (isCaseTreeFast(nodep) && v3Global.opt.oCase()) {
 	    // It's a simple priority encoder or complete statement
@@ -468,14 +461,19 @@ private:
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit CaseVisitor(AstNetlist* nodep) {
+        m_caseWidth = 0;
+        m_caseItems = 0;
 	m_caseNoOverlapsAllCovered = false;
-	nodep->accept(*this);
+        for (uint32_t i=0; i<(1UL<<CASE_OVERLAP_WIDTH); ++i) {
+            m_valueItem[i] = NULL;
+        }
+        iterate(nodep);
     }
     virtual ~CaseVisitor() {
 	V3Stats::addStat("Optimizations, Cases parallelized", m_statCaseFast);

src/V3Cast.cpp

@@ -65,25 +65,21 @@ private:
     // STATE
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void insertCast(AstNode* nodep, int needsize) {  // We'll insert ABOVE passed node
 	UINFO(4,"  NeedCast "<<nodep<<endl);
 	AstNRelinker relinkHandle;
 	nodep->unlinkFrBack(&relinkHandle);
 	//
-	AstCCast* castp = new AstCCast (nodep->fileline(), nodep, needsize, nodep->widthMin());
+        AstCCast* castp = new AstCCast(nodep->fileline(), nodep, needsize, nodep->widthMin());
 	relinkHandle.relink(castp);
 	//if (debug()>8) castp->dumpTree(cout,"-castins: ");
 	//
 	insureLower32Cast(castp);
 	nodep->user1(1);  // Now must be of known size
     }
-    int castSize (AstNode* nodep) {
+    int castSize(AstNode* nodep) {
 	if (nodep->isQuad()) return VL_QUADSIZE;
 	else if (nodep->width()<=8) return 8;
 	else if (nodep->width()<=16) return 16;
@@ -101,26 +97,26 @@ private:
 	// Otherwise a (uint64)(a>b) would return wrong value, as
 	// less than has undeterministic signedness.
 	if (nodep->isQuad() && !nodep->lhsp()->isQuad()
-	    && !nodep->lhsp()->castCCast()) {
+            && !VN_IS(nodep->lhsp(), CCast)) {
 	    insertCast(nodep->lhsp(), VL_WORDSIZE);
 	}
     }
 
     // VISITORS
     virtual void visit(AstNodeUniop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
     }
     virtual void visit(AstNodeBiop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->user1(nodep->lhsp()->user1()
 		    | nodep->rhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
     }
     virtual void visit(AstNodeTriop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->user1(nodep->lhsp()->user1()
 		    | nodep->rhsp()->user1()
 		    | nodep->thsp()->user1());
@@ -129,12 +125,12 @@ private:
 	if (nodep->sizeMattersThs()) insureCast(nodep->thsp());
     }
     virtual void visit(AstCCast* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	insureLower32Cast(nodep);
 	nodep->user1(1);
     }
     virtual void visit(AstNegate* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->lhsp()->widthMin()==1) {
 	    // We want to avoid a GCC "converting of negative value" warning
@@ -147,14 +143,14 @@ private:
     }
     virtual void visit(AstVarRef* nodep) {
 	if (!nodep->lvalue()
-	    && !nodep->backp()->castCCast()
-	    && nodep->backp()->castNodeMath()
-	    && !nodep->backp()->castArraySel()
+            && !VN_IS(nodep->backp(), CCast)
+            && VN_IS(nodep->backp(), NodeMath)
+            && !VN_IS(nodep->backp(), ArraySel)
 	    && nodep->backp()->width()
 	    && castSize(nodep) != castSize(nodep->varp())) {
 	    // Cast vars to IData first, else below has upper bits wrongly set
 	    //  CData x=3;  out = (QData)(x<<30);
-	    insertCast (nodep, castSize(nodep));
+            insertCast(nodep, castSize(nodep));
 	}
 	nodep->user1(1);
     }
@@ -171,13 +167,13 @@ private:
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit CastVisitor(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CastVisitor() {}
 };

src/V3Cdc.cpp

@@ -51,11 +51,7 @@
 
 class CdcBaseVisitor : public AstNVisitor {
 public:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 //######################################################################
@@ -77,6 +73,7 @@ public:
 	, m_asyncPath(false) {}
     virtual ~CdcEitherVertex() {}
     // ACCESSORS
+    virtual FileLine* fileline() const { return nodep()->fileline(); }
     AstScope* scopep() const { return m_scopep; }
     AstNode* nodep() const { return m_nodep; }
     AstSenTree* srcDomainp() const { return m_srcDomainp; }
@@ -135,7 +132,7 @@ private:
     // NODE STATE
     //Entire netlist:
     // {statement}Node::user3	-> bool, indicating not hazard
-    ofstream*		m_ofp;		// Output file
+    std::ofstream* m_ofp;  // Output file
     string		m_prefix;
 
     virtual void visit(AstNode* nodep) {
@@ -145,22 +142,22 @@ private:
 	*m_ofp<<nodep->prettyTypeName()<<" "<<endl;
 	string lastPrefix = m_prefix;
 	m_prefix = lastPrefix + "1:";
-	nodep->op1p()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->op1p());
 	m_prefix = lastPrefix + "2:";
-	nodep->op2p()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->op2p());
 	m_prefix = lastPrefix + "3:";
-	nodep->op3p()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->op3p());
 	m_prefix = lastPrefix + "4:";
-	nodep->op4p()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->op4p());
 	m_prefix = lastPrefix;
     }
 
 public:
     // CONSTUCTORS
-    CdcDumpVisitor(AstNode* nodep, ofstream* ofp, const string& prefix) {
+    CdcDumpVisitor(AstNode* nodep, std::ofstream* ofp, const string& prefix) {
 	m_ofp = ofp;
 	m_prefix = prefix;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CdcDumpVisitor() {}
 };
@@ -173,7 +170,7 @@ private:
     size_t	m_maxFilenameLen;
 
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Keeping line+filename lengths separate is much faster than calling ascii().length()
 	if (nodep->fileline()->lineno() >= m_maxLineno) {
 	    m_maxLineno = nodep->fileline()->lineno()+1;
@@ -187,7 +184,7 @@ public:
     explicit CdcWidthVisitor(AstNode* nodep) {
 	m_maxLineno = 0;
 	m_maxFilenameLen = 0;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CdcWidthVisitor() {}
     // ACCESSORS
@@ -225,7 +222,7 @@ private:
     bool		m_inDly;	// In delayed assign
     int			m_inSenItem;	// Number of senitems
     string		m_ofFilename;	// Output filename
-    ofstream*		m_ofp;		// Output file
+    std::ofstream*      m_ofp;          // Output file
     uint32_t		m_userGeneration; // Generation count to avoid slow userClearVertices
     int			m_filelineWidth;  // Characters in longest fileline
 
@@ -241,7 +238,7 @@ private:
 		m_logicVertexp->dstDomainp(m_domainp);
 		m_logicVertexp->dstDomainSet(true);
 	    }
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    m_logicVertexp = NULL;
 
 	    if (0 && debug()>=9) {
@@ -284,7 +281,7 @@ private:
 	nodep->v3warnCode(code,msg);
 	if (!told_file) {
 	    told_file = 1;
-	    cerr<<V3Error::msgPrefix()<<"     See details in "<<m_ofFilename<<endl;
+            std::cerr<<V3Error::msgPrefix()<<"     See details in "<<m_ofFilename<<endl;
 	}
 	*m_ofp<<"%Warning-"<<code.ascii()<<": "<<nodep->fileline()<<" "<<msg<<endl;
     }
@@ -448,7 +445,7 @@ private:
 	// See also OrderGraph::loopsVertexCb(V3GraphVertex* vertexp)
 	AstNode* nodep = vertexp->nodep();
 	string front = pad(filelineWidth(),nodep->fileline()->ascii()+":")+" "+prefix+" +- ";
-	if (nodep->castVarScope()) {
+        if (VN_IS(nodep, VarScope)) {
 	    *m_ofp<<front<<"Variable: "<<nodep->prettyName()<<endl;
 	}
 	else {
@@ -496,11 +493,11 @@ private:
 	}
 
 	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc_edges.txt";
-	const vl_unique_ptr<ofstream> ofp (V3File::new_ofstream(filename));
-	if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
+        const vl_unique_ptr<std::ofstream> ofp (V3File::new_ofstream(filename));
+        if (ofp->fail()) v3fatal("Can't write "<<filename);
 	*ofp<<"Edge Report for "<<v3Global.opt.prefix()<<endl;
 
-	deque<string> report;  // Sort output by name
+        std::deque<string> report;  // Sort output by name
 	for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
 	    if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(itp)) {
 		AstVar* varp = vvertexp->varScp()->varp();
@@ -508,26 +505,26 @@ private:
 		    const char* whatp = "wire";
 		    if (varp->isPrimaryIO()) whatp = (varp->isInout()?"inout":varp->isInput()?"input":"output");
 
-		    ostringstream os;
-		    os.setf(ios::left);
+                    std::ostringstream os;
+                    os.setf(std::ios::left);
 		    // Module name - doesn't work due to flattening having lost the original
 		    // so we assume the modulename matches the filebasename
 		    string fname = vvertexp->varScp()->fileline()->filebasename() + ":";
-		    os<<"  "<<setw(20)<<fname;
-		    os<<"  "<<setw(8)<<whatp;
-		    os<<"  "<<setw(40)<<vvertexp->varScp()->prettyName();
+                    os<<"  "<<std::setw(20)<<fname;
+                    os<<"  "<<std::setw(8)<<whatp;
+                    os<<"  "<<std::setw(40)<<vvertexp->varScp()->prettyName();
 		    os<<"  SRC=";
 		    if (vvertexp->srcDomainp()) V3EmitV::verilogForTree(vvertexp->srcDomainp(), os);
 		    os<<"  DST=";
 		    if (vvertexp->dstDomainp()) V3EmitV::verilogForTree(vvertexp->dstDomainp(), os);
-		    os<<setw(0);
+                    os<<std::setw(0);
 		    os<<endl;
 		    report.push_back(os.str());
 		}
 	    }
 	}
 	stable_sort(report.begin(), report.end());
-	for (deque<string>::iterator it = report.begin(); it!=report.end(); ++it) {
+        for (std::deque<string>::iterator it = report.begin(); it!=report.end(); ++it) {
 	    *ofp << *it;
 	}
     }
@@ -541,7 +538,7 @@ private:
 	// Variables from flops already are domained
 	if (traceDests ? vertexp->dstDomainSet() : vertexp->srcDomainSet()) return;  // Fully computed
 
-	typedef set<AstSenTree*> SenSet;
+        typedef std::set<AstSenTree*> SenSet;
 	SenSet 	    senouts;   // List of all sensitivities for new signal
 	if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(vertexp)) {
 	    if (vvertexp) {}  // Unused
@@ -584,7 +581,7 @@ private:
 	}
 	// If multiple domains need to do complicated optimizations
 	if (senedited) {
-	    senoutp = V3Const::constifyExpensiveEdit(senoutp)->castSenTree();
+            senoutp = VN_CAST(V3Const::constifyExpensiveEdit(senoutp), SenTree);
 	}
 	if (traceDests) {
 	    vertexp->dstDomainSet(true);  // Note it's set - domainp may be null, so can't use that
@@ -606,14 +603,14 @@ private:
     // VISITORS
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVertexp = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_scopep = NULL;
     }
     virtual void visit(AstActive* nodep) {
@@ -657,14 +654,14 @@ private:
     }
     virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_inDly = false;
     }
     virtual void visit(AstSenItem* nodep) {
 	// Note we look at only AstSenItems, not AstSenGate's
 	// The gating term of a AstSenGate is normal logic
 	m_inSenItem = true;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_inSenItem = false;
     }
     virtual void visit(AstAlways* nodep) {
@@ -691,21 +688,21 @@ private:
     // Math that shouldn't cause us to clear hazard
     virtual void visit(AstConst* nodep) { }
     virtual void visit(AstReplicate* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstConcat* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNot* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstSel* nodep) {
-	if (!nodep->lsbp()->castConst()) setNodeHazard(nodep);
-	nodep->iterateChildren(*this);
+        if (!VN_IS(nodep->lsbp(), Const)) setNodeHazard(nodep);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNodeSel* nodep) {
-	if (!nodep->bitp()->castConst()) setNodeHazard(nodep);
-	nodep->iterateChildren(*this);
+        if (!VN_IS(nodep->bitp(), Const)) setNodeHazard(nodep);
+        iterateChildren(nodep);
     }
 
     // Ignores
@@ -718,10 +715,10 @@ private:
     // Default
     virtual void visit(AstNodeMath* nodep) {
 	setNodeHazard(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
@@ -739,7 +736,7 @@ public:
 	// Make report of all signal names and what clock edges they have
 	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc.txt";
 	m_ofp = V3File::new_ofstream(filename);
-	if (m_ofp->fail()) v3fatalSrc("Can't write "<<filename);
+        if (m_ofp->fail()) v3fatal("Can't write "<<filename);
 	m_ofFilename = filename;
 	*m_ofp<<"CDC Report for "<<v3Global.opt.prefix()<<endl;
 	*m_ofp<<"Each dump below traces logic from inputs/source flops to destination flop(s).\n";
@@ -747,7 +744,7 @@ public:
 	*m_ofp<<"repeating recursively forwards to the destination flop(s).\n";
 	*m_ofp<<"%% Indicates the operator considered potentially hazardous.\n";
 
-	nodep->accept(*this);
+        iterate(nodep);
 	analyze();
 	if (debug()>=1) edgeReport();  // Not useful to users at the moment
 

src/V3Changed.cpp

@@ -85,7 +85,7 @@ public:
 	    if (!m_tlChgFuncp->stmtsp()) {
 		m_tlChgFuncp->addStmtsp(new AstCReturn(m_scopetopp->fileline(), callp));
 	    } else {
-		AstCReturn* returnp = m_tlChgFuncp->stmtsp()->castCReturn();
+                AstCReturn* returnp = VN_CAST(m_tlChgFuncp->stmtsp(), CReturn);
 		if (!returnp) m_scopetopp->v3fatalSrc("Lost CReturn in top change function");
 		// This is currently using AstLogOr which will shortcut the evaluation if
 		// any function returns true. This is likely what we want and is similar to the logic already in use
@@ -131,13 +131,13 @@ private:
 	}
 	m_statep->maybeCreateChgFuncp();
 
-	AstChangeDet* changep = new AstChangeDet (m_vscp->fileline(),
-						  m_varEqnp->cloneTree(true),
-						  m_newRvEqnp->cloneTree(true), false);
+        AstChangeDet* changep = new AstChangeDet(m_vscp->fileline(),
+                                                 m_varEqnp->cloneTree(true),
+                                                 m_newRvEqnp->cloneTree(true), false);
 	m_statep->m_chgFuncp->addStmtsp(changep);
-	AstAssign* initp = new AstAssign (m_vscp->fileline(),
-					  m_newLvEqnp->cloneTree(true),
-					  m_varEqnp->cloneTree(true));
+        AstAssign* initp = new AstAssign(m_vscp->fileline(),
+                                         m_newLvEqnp->cloneTree(true),
+                                         m_varEqnp->cloneTree(true));
 	m_statep->m_chgFuncp->addFinalsp(initp);
 	EmitCBaseCounterVisitor visitor(initp);
 	m_statep->m_numStmts += visitor.count();
@@ -159,7 +159,7 @@ private:
 	    m_newLvEqnp = new AstArraySel(nodep->fileline(), m_newLvEqnp->cloneTree(true), index);
 	    m_newRvEqnp = new AstArraySel(nodep->fileline(), m_newRvEqnp->cloneTree(true), index);
 
-	    nodep->subDTypep()->skipRefp()->accept(*this);
+            iterate(nodep->subDTypep()->skipRefp());
 
 	    m_varEqnp->deleteTree();
 	    m_newLvEqnp->deleteTree();
@@ -181,7 +181,7 @@ private:
 	}
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (debug()) nodep->dumpTree(cout,"-DETECTARRAY-general-");
         m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable"
                        " (probably with UNOPTFLAT warning suppressed): "
@@ -200,7 +200,7 @@ public:
 	    //          ASSIGN(VARREF(_last), VARREF(var))
 	    //          ...
 	    //          CHANGEDET(VARREF(_last), VARREF(var))
-	    AstVar* newvarp = new AstVar (varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
+            AstVar* newvarp = new AstVar(varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
 	    m_statep->m_topModp->addStmtp(newvarp);
 	    m_newvscp = new AstVarScope(m_vscp->fileline(), m_statep->m_scopetopp, newvarp);
 	    m_statep->m_scopetopp->addVarp(m_newvscp);
@@ -209,7 +209,7 @@ public:
 	    m_newLvEqnp = new AstVarRef(m_vscp->fileline(), m_newvscp, true);
 	    m_newRvEqnp = new AstVarRef(m_vscp->fileline(), m_newvscp, false);
 	}
-	vscp->dtypep()->skipRefp()->accept(*this);
+        iterate(vscp->dtypep()->skipRefp());
 	m_varEqnp->deleteTree();
 	m_newLvEqnp->deleteTree();
 	m_newRvEqnp->deleteTree();
@@ -231,11 +231,7 @@ private:
     ChangedState*	m_statep;	// Shared state across visitors
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void genChangeDet(AstVarScope* vscp) {
 	vscp->v3warn(IMPERFECTSCH,"Imperfect scheduling of variable: "<<vscp);
@@ -248,7 +244,7 @@ private:
 	if (nodep->isTop()) {
 	    m_statep->m_topModp = nodep;
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     virtual void visit(AstTopScope* nodep) {
@@ -271,7 +267,7 @@ private:
 	m_statep->maybeCreateChgFuncp();
 	m_statep->m_chgFuncp->addStmtsp(new AstChangeDet(nodep->fileline(), NULL, NULL, false));
 
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstVarScope* nodep) {
 	if (nodep->isCircular()) {
@@ -287,14 +283,14 @@ private:
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     ChangedVisitor(AstNetlist* nodep, ChangedState* statep) {
 	m_statep = statep;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~ChangedVisitor() {}
 };

src/V3Clean.cpp

@@ -59,11 +59,7 @@ private:
     AstNodeModule* m_modp;
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     // Width resetting
     int  cppWidth(AstNode* nodep) {
@@ -71,14 +67,14 @@ private:
 	else if (nodep->width()<=VL_QUADSIZE) return VL_QUADSIZE;
 	else return nodep->widthWords()*VL_WORDSIZE;
     }
-    void setCppWidth (AstNode* nodep) {
+    void setCppWidth(AstNode* nodep) {
 	nodep->user2(true);  // Don't resize it again
 	AstNodeDType* old_dtypep = nodep->dtypep();
 	int width=cppWidth(nodep);  // widthMin is unchanged
 	if (old_dtypep->width() != width) {
 	    // Since any given dtype's cppWidth() is the same, we can just
 	    // remember one convertion for each, and reuse it
-	    if (AstNodeDType* new_dtypep = old_dtypep->user3p()->castNodeDType()) {
+            if (AstNodeDType* new_dtypep = VN_CAST(old_dtypep->user3p(), NodeDType)) {
 		nodep->dtypep(new_dtypep);
 	    } else {
 		nodep->dtypeChgWidth(width, nodep->widthMin());
@@ -88,10 +84,10 @@ private:
 	    }
 	}
     }
-    void computeCppWidth (AstNode* nodep) {
+    void computeCppWidth(AstNode* nodep) {
 	if (!nodep->user2() && nodep->hasDType()) {
-            if (nodep->castVar() || nodep->castNodeDType()  // Don't want to change variable widths!
-                || nodep->dtypep()->skipRefp()->castUnpackArrayDType()) {  // Or arrays
+            if (VN_IS(nodep, Var) || VN_IS(nodep, NodeDType)  // Don't want to change variable widths!
+                || VN_IS(nodep->dtypep()->skipRefp(), UnpackArrayDType)) {  // Or arrays
 	    } else {
 		setCppWidth(nodep);
 	    }
@@ -113,7 +109,7 @@ private:
 	return false;
     }
     void setClean(AstNode* nodep, bool isClean) {
-	computeCppWidth (nodep);  // Just to be sure it's in widthMin
+        computeCppWidth(nodep);  // Just to be sure it's in widthMin
 	bool wholeUint = ((nodep->widthMin() % VL_WORDSIZE) == 0);  //32,64,...
 	setCleanState(nodep, ((isClean||wholeUint) ? CS_CLEAN:CS_DIRTY));
     }
@@ -127,9 +123,9 @@ private:
 	computeCppWidth(nodep);
 	V3Number mask (nodep->fileline(), cppWidth(nodep));
 	mask.setMask(nodep->widthMin());
-	AstNode* cleanp = new AstAnd (nodep->fileline(),
-				      new AstConst (nodep->fileline(), mask),
-				      nodep);
+        AstNode* cleanp = new AstAnd(nodep->fileline(),
+                                     new AstConst(nodep->fileline(), mask),
+                                     nodep);
 	cleanp->dtypeFrom(nodep);  // Otherwise the AND normally picks LHS
 	relinkHandle.relink(cleanp);
     }
@@ -148,7 +144,7 @@ private:
 
     // Base type handling methods
     void operandBiop(AstNodeBiop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
 	if (nodep->cleanLhs()) {
 	    insureClean(nodep->lhsp());
@@ -159,7 +155,7 @@ private:
 	//no setClean.. must do it in each user routine.
     }
     void operandTriop(AstNodeTriop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
 	if (nodep->cleanLhs()) {
 	    insureClean(nodep->lhsp());
@@ -176,118 +172,119 @@ private:
     // VISITORS
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstNodeUniop* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
 	if (nodep->cleanLhs()) {
 	    insureClean(nodep->lhsp());
 	}
-	setClean (nodep, nodep->cleanOut());
+        setClean(nodep, nodep->cleanOut());
     }
     virtual void visit(AstNodeBiop* nodep) {
 	operandBiop(nodep);
-	setClean (nodep, nodep->cleanOut());
+        setClean(nodep, nodep->cleanOut());
     }
     virtual void visit(AstAnd* nodep) {
 	operandBiop(nodep);
-	setClean (nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
+        setClean(nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
     }
     virtual void visit(AstXor* nodep) {
 	operandBiop(nodep);
-	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
+        setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
     virtual void visit(AstOr* nodep) {
 	operandBiop(nodep);
-	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
+        setClean(nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
     virtual void visit(AstNodeMath* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
-        setClean (nodep, nodep->cleanOut());
+        setClean(nodep, nodep->cleanOut());
     }
     virtual void visit(AstNodeAssign* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
 	if (nodep->cleanRhs()) {
 	    insureClean(nodep->rhsp());
 	}
     }
     virtual void visit(AstText* nodep) {
-	setClean (nodep, true);
+        setClean(nodep, true);
     }
     virtual void visit(AstScopeName* nodep) {
-	setClean (nodep, true);
+        setClean(nodep, true);
     }
     virtual void visit(AstSel* nodep) {
 	operandTriop(nodep);
-        setClean (nodep, nodep->cleanOut());
+        setClean(nodep, nodep->cleanOut());
     }
     virtual void visit(AstUCFunc* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
-        setClean (nodep, false);
+        setClean(nodep, false);
 	// We always clean, as we don't trust those pesky users.
-	if (!nodep->backp()->castAnd()) {
+        if (!VN_IS(nodep->backp(), And)) {
 	    insertClean(nodep);
 	}
-	insureCleanAndNext (nodep->bodysp());
+        insureCleanAndNext(nodep->bodysp());
     }
     virtual void visit(AstTraceInc* nodep) {
-	nodep->iterateChildren(*this);
-	insureCleanAndNext (nodep->valuep());
+        iterateChildren(nodep);
+        insureCleanAndNext(nodep->valuep());
     }
     virtual void visit(AstTypedef* nodep) {
 	// No cleaning, or would loose pointer to enum
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstParamTypeDType* nodep) {
 	// No cleaning, or would loose pointer to enum
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     // Control flow operators
     virtual void visit(AstNodeCond* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	insureClean(nodep->condp());
 	setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
     }
     virtual void visit(AstWhile* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	insureClean(nodep->condp());
     }
     virtual void visit(AstNodeIf* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	insureClean(nodep->condp());
     }
     virtual void visit(AstSFormatF* nodep) {
-	nodep->iterateChildren(*this);
-	insureCleanAndNext (nodep->exprsp());
+        iterateChildren(nodep);
+        insureCleanAndNext(nodep->exprsp());
 	setClean(nodep, true);  // generates a string, so not relevant
     }
     virtual void visit(AstUCStmt* nodep) {
-	nodep->iterateChildren(*this);
-	insureCleanAndNext (nodep->bodysp());
+        iterateChildren(nodep);
+        insureCleanAndNext(nodep->bodysp());
     }
     virtual void visit(AstCCall* nodep) {
-	nodep->iterateChildren(*this);
-	insureCleanAndNext (nodep->argsp());
-	setClean (nodep, true);
+        iterateChildren(nodep);
+        insureCleanAndNext(nodep->argsp());
+        setClean(nodep, true);
     }
 
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	computeCppWidth(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit CleanVisitor(AstNetlist* nodep) {
-	nodep->accept(*this);
+        m_modp = NULL;
+        iterate(nodep);
     }
     virtual ~CleanVisitor() {}
 };

src/V3ClkGater.cpp

@@ -51,11 +51,7 @@
 
 class GaterBaseVisitor : public AstNVisitor {
 protected:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 //######################################################################
@@ -196,7 +192,7 @@ private:
     bool		m_isSimple;	// Set false when we know it isn't simple
     // METHODS
     inline void okIterate(AstNode* nodep) {
-	if (m_isSimple) nodep->iterateChildren(*this);
+        if (m_isSimple) iterateChildren(nodep);
     }
     // VISITORS
     virtual void visit(AstOr* nodep) {	okIterate(nodep); }
@@ -213,13 +209,13 @@ private:
 
     virtual void visit(AstNode* nodep) {
 	m_isSimple = false;
-	//nodep->iterateChildren(*this);
+        //iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit GaterCondVisitor(AstNode* nodep) {
 	m_isSimple = true;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~GaterCondVisitor() {}
     // PUBLIC METHODS
@@ -283,7 +279,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	uint32_t childstate;
 	{
 	    m_state = STATE_UNKNOWN;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    childstate = m_state;
 	}
 	m_state = oldstate;
@@ -305,7 +301,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	}
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -315,7 +311,7 @@ public:
 	m_state = STATE_UNKNOWN;
 	m_cloning = false;
 	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyIn:  ");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyOut: ");
 	// If there's no statements we shouldn't have had a resulting graph
 	// vertex asking for this creation
@@ -672,7 +668,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	AstSenTree* sensesp = nodep->sensesp()->cloneTree(true);
 #else
 	// Make a SenGate
-	AstSenItem* oldsenitemsp = nodep->sensesp()->sensesp()->castSenItem();
+        AstSenItem* oldsenitemsp = VN_CAST(nodep->sensesp()->sensesp(), SenItem);
 	if (!oldsenitemsp) nodep->v3fatalSrc("SenTree doesn't have any SenItem under it");
 
 	AstSenTree* sensesp = new AstSenTree(nodep->fileline(),
@@ -802,17 +798,17 @@ class GaterVisitor : public GaterBaseVisitor {
 	    GaterIfVertex* vertexp = new GaterIfVertex(&m_graph, nodep);
 	    new GaterEdge(&m_graph, m_aboveVertexp, vertexp, m_aboveTrue);
 	    {
-		nodep->condp()->iterateAndNext(*this);  // directlyUnder stays as-is
+                iterateAndNextNull(nodep->condp());  // directlyUnder stays as-is
 	    }
 	    {
 		m_aboveVertexp = vertexp;  // Vars will point at this edge
 		m_aboveTrue = VU_IF;
-		nodep->ifsp()->iterateAndNext(*this);  // directlyUnder stays as-is (true)
+                iterateAndNextNull(nodep->ifsp());  // directlyUnder stays as-is (true)
 	    }
 	    {
 		m_aboveVertexp = vertexp;  // Vars will point at this edge
 		m_aboveTrue = VU_ELSE;
-		nodep->elsesp()->iterateAndNext(*this);  // directlyUnder stays as-is (true)
+                iterateAndNextNull(nodep->elsesp());  // directlyUnder stays as-is (true)
 	    }
 	    m_aboveVertexp = lastabovep;
 	    m_aboveTrue = lasttrue;
@@ -857,7 +853,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	AstVarScope* lastvscp = m_stmtVscp;
 	bool lastpli = m_stmtInPli;
 	m_directlyUnderAlw = under;
-	if (nodep->castNodeStmt()) {  // Restored below
+        if (VN_IS(nodep, NodeStmt)) {  // Restored below
 	    UINFO(9,"       Stmt: "<<nodep<<endl);
 	    m_stmtVscp = NULL;
 	    m_stmtInPli = false;
@@ -868,10 +864,10 @@ class GaterVisitor : public GaterBaseVisitor {
 	    scoreboardPli(nodep);
 	}
 	{
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_directlyUnderAlw = lastdua;
-	if (nodep->castNodeStmt()) {  // Reset what set above; else propagate up to above statement
+        if (VN_IS(nodep, NodeStmt)) {  // Reset what set above; else propagate up to above statement
 	    m_stmtVscp = lastvscp;
 	    m_stmtInPli = lastpli;
 	}
@@ -882,7 +878,7 @@ public:
     explicit GaterVisitor(AstNetlist* nodep) {
 	// AstAlways visitor does the real work, so most zeroing needs to be in clear()
 	clear();
-	nodep->accept(*this);
+        iterate(nodep);
     }
     void clear() {
 	m_nonopt = "";

src/V3Clock.cpp

@@ -51,9 +51,7 @@ private:
     // NODE STATE
     // Cleared each Module:
     //  AstVarScope::user1p()	-> AstVarScope*.  Temporary signal that was created.
-    //  AstVarScope::user2p()	-> AstVarScope*.  Temporary signal for change detects
     AstUser1InUse	m_inuser1;
-    AstUser2InUse	m_inuser2;
 
     // TYPES
     enum {  DOUBLE_OR_RATE = 10 };	// How many | per ||, Determined experimentally as best
@@ -68,29 +66,34 @@ private:
     AstCFunc*		m_settleFuncp;	// Top settlement function we are creating
     AstSenTree*		m_lastSenp;	// Last sensitivity match, so we can detect duplicates.
     AstIf*		m_lastIfp;	// Last sensitivity if active to add more under
+    AstMTaskBody*       m_mtaskBodyp;   // Current mtask body
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     AstVarScope* getCreateLastClk(AstVarScope* vscp) {
 	if (vscp->user1p()) return ((AstVarScope*)vscp->user1p());
 	AstVar* varp = vscp->varp();
 	if (!varp->width1()) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
 	string newvarname = ((string)"__Vclklast__"+vscp->scopep()->nameDotless()+"__"+varp->name());
-	AstVar* newvarp = new AstVar (vscp->fileline(), AstVarType::MODULETEMP, newvarname, VFlagLogicPacked(), 1);
+        AstVar* newvarp = new AstVar(vscp->fileline(), AstVarType::MODULETEMP, newvarname, VFlagLogicPacked(), 1);
+        newvarp->noReset(true);  // Reset by below assign
 	m_modp->addStmtp(newvarp);
 	AstVarScope* newvscp = new AstVarScope(vscp->fileline(), m_scopep, newvarp);
 	vscp->user1p(newvscp);
 	m_scopep->addVarp(newvscp);
+        // Add init
+        AstNode* fromp = new AstVarRef(newvarp->fileline(), vscp, false);
+        if (v3Global.opt.xInitialEdge()) fromp = new AstNot(fromp->fileline(), fromp);
+        AstNode* newinitp = new AstAssign(vscp->fileline(),
+                                          new AstVarRef(newvarp->fileline(), newvscp, true),
+                                          fromp);
+        addToInitial(newinitp);
 	// At bottom, assign them
 	AstAssign* finalp
-	    = new AstAssign (vscp->fileline(),
-			     new AstVarRef(vscp->fileline(), newvscp, true),
-			     new AstVarRef(vscp->fileline(), vscp, false));
+            = new AstAssign(vscp->fileline(),
+                            new AstVarRef(vscp->fileline(), newvscp, true),
+                            new AstVarRef(vscp->fileline(), vscp, false));
 	m_evalFuncp->addFinalsp(finalp);
 	//
 	UINFO(4,"New Last: "<<newvscp<<endl);
@@ -154,11 +157,11 @@ private:
     AstNode* createSenseEquation(AstNodeSenItem* nodesp) {
 	// Nodep may be a list of elements; we need to walk it
 	AstNode* senEqnp = NULL;
-	for (AstNodeSenItem* senp = nodesp; senp; senp=senp->nextp()->castNodeSenItem()) {
+        for (AstNodeSenItem* senp = nodesp; senp; senp=VN_CAST(senp->nextp(), NodeSenItem)) {
 	    AstNode* senOnep = NULL;
-	    if (AstSenItem* itemp = senp->castSenItem()) {
+            if (AstSenItem* itemp = VN_CAST(senp, SenItem)) {
 		senOnep = createSenItemEquation(itemp);
-	    } else if (AstSenGate* itemp = senp->castSenGate()) {
+            } else if (AstSenGate* itemp = VN_CAST(senp, SenGate)) {
 		senOnep = createSenGateEquation(itemp);
 	    } else {
 		senp->v3fatalSrc("Strange node under sentree");
@@ -175,8 +178,7 @@ private:
     AstIf* makeActiveIf(AstSenTree* sensesp) {
 	AstNode* senEqnp = createSenseEquation(sensesp->sensesp());
 	if (!senEqnp) sensesp->v3fatalSrc("No sense equation, shouldn't be in sequent activation.");
-	AstIf* newifp = new AstIf (sensesp->fileline(),
-				   senEqnp, NULL, NULL);
+        AstIf* newifp = new AstIf(sensesp->fileline(), senEqnp, NULL, NULL);
 	return (newifp);
     }
     void clearLastSen() {
@@ -239,7 +241,7 @@ private:
 	    m_settleFuncp = funcp;
 	}
 	// Process the activates
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Done, clear so we can detect errors
 	UINFO(4," TOPSCOPEDONE "<<nodep<<endl);
 	clearLastSen();
@@ -249,13 +251,13 @@ private:
     virtual void visit(AstNodeModule* nodep) {
 	//UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp= NULL;
     }
     virtual void visit(AstScope* nodep) {
 	//UINFO(4," SCOPE   "<<nodep<<endl);
 	m_scopep = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (AstNode* movep = nodep->finalClksp()) {
 	    if (!m_topScopep) nodep->v3fatalSrc("Final clocks under non-top scope");
 	    movep->unlinkFrBackWithNext();
@@ -311,7 +313,7 @@ private:
 	nodep->deleteTree(); VL_DANGLING(nodep);
     }
     virtual void visit(AstCFunc* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Link to global function
 	if (nodep->formCallTree()) {
 	    UINFO(4, "    formCallTree "<<nodep<<endl);
@@ -342,6 +344,30 @@ private:
 	    // Only empty blocks should be leftover on the non-top.  Killem.
 	    if (nodep->stmtsp()) nodep->v3fatalSrc("Non-empty lower active");
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+        } else if (m_mtaskBodyp) {
+            UINFO(4,"  TR ACTIVE  "<<nodep<<endl);
+            AstNode* stmtsp = nodep->stmtsp()->unlinkFrBackWithNext();
+            if (nodep->hasClocked()) {
+                if (nodep->hasInitial()) nodep->v3fatalSrc("Initial block should not have clock sensitivity");
+                if (m_lastSenp && nodep->sensesp()->sameTree(m_lastSenp)) {
+                    UINFO(4,"    sameSenseTree\n");
+                } else {
+                    clearLastSen();
+                    m_lastSenp = nodep->sensesp();
+                    // Make a new if statement
+                    m_lastIfp = makeActiveIf(m_lastSenp);
+                    m_mtaskBodyp->addStmtsp(m_lastIfp);
+                }
+                // Move statements to if
+                m_lastIfp->addIfsp(stmtsp);
+            } else if (nodep->hasInitial() || nodep->hasSettle()) {
+                nodep->v3fatalSrc("MTask should not include initial/settle logic.");
+            } else {
+                // Combo logic. Move statements to mtask func.
+                clearLastSen();
+                m_mtaskBodyp->addStmtsp(stmtsp);
+            }
+            nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
 	    UINFO(4,"  ACTIVE  "<<nodep<<endl);
 	    AstNode* stmtsp = nodep->stmtsp()->unlinkFrBackWithNext();
@@ -376,24 +402,42 @@ private:
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	}
     }
+    virtual void visit(AstExecGraph* nodep) {
+        for (m_mtaskBodyp = VN_CAST(nodep->op1p(), MTaskBody);
+             m_mtaskBodyp;
+             m_mtaskBodyp = VN_CAST(m_mtaskBodyp->nextp(), MTaskBody)) {
+            clearLastSen();
+            iterate(m_mtaskBodyp);
+        }
+        clearLastSen();
+        // Move the ExecGraph into _eval. Its location marks the
+        // spot where the graph will execute, relative to other
+        // (serial) logic in the cycle.
+        nodep->unlinkFrBack();
+        addToEvalLoop(nodep);
+    }
 
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit ClockVisitor(AstNetlist* nodep) {
-	m_modp=NULL;
+        m_modp = NULL;
 	m_evalFuncp = NULL;
-	m_topScopep=NULL;
-	m_lastSenp=NULL;
+        m_initFuncp = NULL;
+        m_finalFuncp = NULL;
+        m_settleFuncp = NULL;
+        m_topScopep = NULL;
+        m_lastSenp = NULL;
 	m_lastIfp = NULL;
 	m_scopep = NULL;
+        m_mtaskBodyp = NULL;
 	//
-	nodep->accept(*this);
+        iterate(nodep);
         // Allow downstream modules to find _eval()
         // easily without iterating through the tree.
         nodep->evalp(m_evalFuncp);

src/V3Combine.cpp

@@ -60,13 +60,8 @@ protected:
     // STATE
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
-
     virtual ~CombBaseVisitor() {}
+    VL_DEBUG_FUNC;  // Declare debug()
 
     //***** optimization levels
     static bool emptyFunctionDeletion() { return true; }
@@ -86,16 +81,16 @@ class CombCallVisitor : CombBaseVisitor {
 private:
     // NODE STATE
     bool	m_find;		// Find mode vs. delete mode
-    typedef multimap<AstCFunc*,AstCCall*> CallMmap;
+    typedef std::multimap<AstCFunc*,AstCCall*> CallMmap;
     CallMmap	m_callMmap;	// Associative array of {function}{call}
     // METHODS
 public:
-    void replaceFunc (AstCFunc* oldfuncp, AstCFunc* newfuncp) {
+    void replaceFunc(AstCFunc* oldfuncp, AstCFunc* newfuncp) {
 	if (oldfuncp==newfuncp) return;
 	if (newfuncp) {
 	    UINFO(4, "   Replace "<<oldfuncp<<" -WITH-> "<<newfuncp<<endl);
 	} else UINFO(4, "   Remove "<<oldfuncp<<endl);
-	pair <CallMmap::iterator,CallMmap::iterator> eqrange = m_callMmap.equal_range(oldfuncp);
+        std::pair <CallMmap::iterator,CallMmap::iterator> eqrange = m_callMmap.equal_range(oldfuncp);
 	for (CallMmap::iterator nextit = eqrange.first; nextit != eqrange.second;) {
 	    CallMmap::iterator eqit = nextit++;
 	    AstCCall* callp = eqit->second;
@@ -121,7 +116,7 @@ public:
 	m_callMmap.insert(make_pair(nodep->funcp(), nodep));
     }
     void deleteCall(AstCCall* nodep) {
-	pair <CallMmap::iterator,CallMmap::iterator> eqrange = m_callMmap.equal_range(nodep->funcp());
+        std::pair<CallMmap::iterator,CallMmap::iterator> eqrange = m_callMmap.equal_range(nodep->funcp());
 	for (CallMmap::iterator nextit = eqrange.first; nextit != eqrange.second;) {
 	    CallMmap::iterator eqit = nextit++;
 	    AstCCall* callp = eqit->second;
@@ -141,7 +136,7 @@ private:
     virtual void visit(AstNodeAssign* nodep) {}
     virtual void visit(AstNodeMath* nodep) {}
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
@@ -150,7 +145,7 @@ public:
     }
     virtual ~CombCallVisitor() {}
     void main(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
 };
 
@@ -165,12 +160,12 @@ private:
     // VISITORS
     virtual void visit(AstNode* nodep) {
 	nodep->user3(true);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
     explicit CombMarkVisitor(AstNode* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CombMarkVisitor() {}
 };
@@ -214,18 +209,18 @@ private:
 	CombineState oldState = m_state;
 	{
 	    m_state = STATE_HASH;
-	    nodep->accept(*this);
+            iterate(nodep);
 	}
 	m_state = oldState;
     }
     void walkEmptyFuncs() {
 	for (V3Hashed::iterator it = m_hashed.begin(); it != m_hashed.end(); ++it) {
 	    AstNode* node1p = it->second;
-	    AstCFunc* oldfuncp = node1p->castCFunc();
+            AstCFunc* oldfuncp = VN_CAST(node1p, CFunc);
 	    if (oldfuncp
 		&& oldfuncp->emptyBody()
 		&& !oldfuncp->dontCombine()) {
-		UINFO(5,"     EmptyFunc "<<hex<<V3Hash(oldfuncp->user4p())<<" "<<oldfuncp<<endl);
+                UINFO(5,"     EmptyFunc "<<std::hex<<V3Hash(oldfuncp->user4p())<<" "<<oldfuncp<<endl);
 		// Mark user3p on entire old tree, so we don't process it more
 		CombMarkVisitor visitor(oldfuncp);
 		m_call.replaceFunc(oldfuncp, NULL);
@@ -238,7 +233,7 @@ private:
 	for (V3Hashed::iterator it = m_hashed.begin(); it != m_hashed.end(); ++it) {
 	    V3Hash hashval = it->first;
 	    AstNode* node1p = it->second;
-	    if (!node1p->castCFunc()) continue;
+            if (!VN_IS(node1p, CFunc)) continue;
 	    if (hashval.isIllegal()) node1p->v3fatalSrc("Illegal (unhashed) nodes");
 	    for (V3Hashed::iterator eqit = it; eqit != m_hashed.end(); ++eqit) {
 		AstNode* node2p = eqit->second;
@@ -247,16 +242,16 @@ private:
 		if (node1p->user3p() || node2p->user3p()) continue;   // Already merged
 		if (node1p->sameTree(node2p)) { // walk of tree has same comparison
 		    // Replace AstCCall's that point here
-		    replaceFuncWFunc(node2p->castCFunc(), node1p->castCFunc());
+                    replaceFuncWFunc(VN_CAST(node2p, CFunc), VN_CAST(node1p, CFunc));
 		    // Replacement may promote a slow routine to fast path
-		    if (!node2p->castCFunc()->slow()) node1p->castCFunc()->slow(false);
+                    if (!VN_CAST(node2p, CFunc)->slow()) VN_CAST(node1p, CFunc)->slow(false);
 		}
 	    }
 	}
     }
     void replaceFuncWFunc(AstCFunc* oldfuncp, AstCFunc* newfuncp) {
-	UINFO(5,"     DupFunc "<<hex<<V3Hash(newfuncp->user4p())<<" "<<newfuncp<<endl);
-	UINFO(5,"         and "<<hex<<V3Hash(oldfuncp->user4p())<<" "<<oldfuncp<<endl);
+        UINFO(5,"     DupFunc "<<std::hex<<V3Hash(newfuncp->user4p())<<" "<<newfuncp<<endl);
+        UINFO(5,"         and "<<std::hex<<V3Hash(oldfuncp->user4p())<<" "<<oldfuncp<<endl);
 	// Mark user3p on entire old tree, so we don't process it more
 	++m_statCombs;
 	CombMarkVisitor visitor(oldfuncp);
@@ -265,7 +260,7 @@ private:
 	pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
     }
     void replaceOnlyCallFunc(AstCCall* nodep) {
-	if (AstCFunc* oldfuncp = nodep->backp()->castCFunc()) {
+        if (AstCFunc* oldfuncp = VN_CAST(nodep->backp(), CFunc)) {
 	    //oldfuncp->dumpTree(cout,"MAYDEL: ");
 	    if (nodep->nextp()==NULL
 		&& oldfuncp->initsp()==NULL
@@ -280,7 +275,7 @@ private:
     }
 
     void walkDupCodeStart(AstNode* node1p) {
-	V3Hash hashval (node1p->user4p());
+        V3Hash hashval(node1p->user4p());
 	//UINFO(4,"    STMT "<<hashval<<" "<<node1p<<endl);
 	//
 	int	 bestDepth = 0;		// Best substitution found in the search
@@ -288,7 +283,7 @@ private:
 	AstNode* bestLast1p = NULL;
 	AstNode* bestLast2p = NULL;
 	//
-	pair <V3Hashed::iterator,V3Hashed::iterator> eqrange = m_hashed.mmap().equal_range(hashval);
+        std::pair<V3Hashed::iterator,V3Hashed::iterator> eqrange = m_hashed.mmap().equal_range(hashval);
 	for (V3Hashed::iterator eqit = eqrange.first; eqit != eqrange.second; ++eqit) {
 	    AstNode* node2p = eqit->second;
 	    if (node1p==node2p) continue;
@@ -396,16 +391,17 @@ private:
 	//In V3Hashed AstNode::user4ClearTree();	// user4p() used on entire tree
 	// Iterate modules backwards, in bottom-up order.
 	// Required so that a module instantiating another can benefit from collapsing.
-	nodep->iterateChildrenBackwards(*this);
+        iterateChildrenBackwards(nodep);
     }
     virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_modNFuncs = 0;
+        m_walkLast2p = NULL;
 	m_hashed.clear();
 	// Compute hash of all statement trees in the function
 	m_state = STATE_HASH;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_state = STATE_IDLE;
 	if (debug()>=9) {
 	    m_hashed.dumpFilePrefixed("combine");
@@ -421,7 +417,7 @@ private:
 	// Walk the statements looking for large replicated code sections
 	if (statementCombine()) {
 	    m_state = STATE_DUP;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    m_state = STATE_IDLE;
 	}
 	m_modp = NULL;
@@ -432,7 +428,7 @@ private:
 	    if (m_state == STATE_HASH) {
 		hashStatement(nodep);  // Hash the entire function - it might be identical
 	    } else if (m_state == STATE_DUP) {
-		nodep->iterateChildren(*this);
+                iterateChildren(nodep);
 	    }
 	}
 	m_funcp = NULL;
@@ -452,16 +448,19 @@ private:
     virtual void visit(AstTraceDecl*) {}
     virtual void visit(AstTraceInc*) {}
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit CombineVisitor(AstNetlist* nodep) {
-	m_modp=NULL;
-	m_funcp = NULL;
 	m_state = STATE_IDLE;
-	nodep->accept(*this);
+        m_modp = NULL;
+        m_funcp = NULL;
+        m_modNFuncs = 0;
+        m_walkLast1p = NULL;
+        m_walkLast2p = NULL;
+        iterate(nodep);
     }
     virtual ~CombineVisitor() {
 	V3Stats::addStat("Optimizations, Combined CFuncs", m_statCombs);

src/V3Config.cpp

@@ -47,11 +47,11 @@ public:
 	return (m_on>rh.m_on);
     }
 };
-ostream& operator<<(ostream& os, V3ConfigLine rhs) { return os<<rhs.m_lineno<<", "<<rhs.m_code<<", "<<rhs.m_on; }
+std::ostream& operator<<(std::ostream& os, V3ConfigLine rhs) { return os<<rhs.m_lineno<<", "<<rhs.m_code<<", "<<rhs.m_on; }
 
 class V3ConfigIgnores {
-    typedef multiset<V3ConfigLine> IgnLines;	// list of {line,code,on}
-    typedef map<string,IgnLines> IgnFiles;	// {filename} => list of {line,code,on}
+    typedef std::multiset<V3ConfigLine> IgnLines;  // list of {line,code,on}
+    typedef std::map<string,IgnLines> IgnFiles;  // {filename} => list of {line,code,on}
 
     // MEMBERS
     string		m_lastFilename;	// Last filename looked up

src/V3Coverage.cpp

@@ -45,7 +45,7 @@
 class CoverageVisitor : public AstNVisitor {
 private:
     // TYPES
-    typedef map<string,int>	FileMap;
+    typedef std::map<string,int> FileMap;
 
     struct ToggleEnt {
 	string		m_comment;	// Comment for coverage dump
@@ -74,11 +74,7 @@ private:
     string	m_beginHier;	// AstBegin hier name for user coverage points
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     const char* varIgnoreToggle(AstVar* nodep) {
 	// Return true if this shouldn't be traced
@@ -132,7 +128,7 @@ private:
 	m_modp = nodep;
 	m_inModOff = nodep->isTop();   // Ignore coverage on top module; it's a shell we created
 	m_fileps.clear();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
 	m_inModOff = true;
     }
@@ -142,12 +138,12 @@ private:
 	bool oldtog = m_inToggleOff;
 	{
 	    m_inToggleOff = true;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_inToggleOff = oldtog;
     }
     virtual void visit(AstVar* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (m_modp && !m_inModOff && !m_inToggleOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageToggle()) {
 	    const char* disablep = varIgnoreToggle(nodep);
@@ -167,7 +163,7 @@ private:
 
 		// Add signal to hold the old value
 		string newvarname = (string)"__Vtogcov__"+nodep->shortName();
-		AstVar* chgVarp = new AstVar (nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
+                AstVar* chgVarp = new AstVar(nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
 		chgVarp->fileline()->modifyWarnOff(V3ErrorCode::UNUSED, true);
 		m_modp->addStmtp(chgVarp);
 
@@ -189,18 +185,18 @@ private:
 		     const ToggleEnt& above,
 		     AstVar* varp, AstVar* chgVarp) { // Constant
 	AstCoverToggle* newp
-	    = new AstCoverToggle (varp->fileline(),
-				  newCoverInc(varp->fileline(), "", "v_toggle",
-					      varp->name()+above.m_comment),
-				  above.m_varRefp->cloneTree(true),
-				  above.m_chgRefp->cloneTree(true));
+            = new AstCoverToggle(varp->fileline(),
+                                 newCoverInc(varp->fileline(), "", "v_toggle",
+                                             varp->name()+above.m_comment),
+                                 above.m_varRefp->cloneTree(true),
+                                 above.m_chgRefp->cloneTree(true));
 	m_modp->addStmtp(newp);
     }
 
     void toggleVarRecurse(AstNodeDType* dtypep, int depth, // per-iteration
 		     const ToggleEnt& above,
 		     AstVar* varp, AstVar* chgVarp) { // Constant
-	if (AstBasicDType* bdtypep = dtypep->castBasicDType()) {
+        if (const AstBasicDType* bdtypep = VN_CAST(dtypep, BasicDType)) {
 	    if (bdtypep->isRanged()) {
 		for (int index_docs=bdtypep->lsb(); index_docs<bdtypep->msb()+1; index_docs++) {
 		    int index_code = index_docs - bdtypep->lsb();
@@ -218,7 +214,7 @@ private:
 				varp, chgVarp);
 	    }
 	}
-	else if (AstUnpackArrayDType* adtypep = dtypep->castUnpackArrayDType()) {
+        else if (AstUnpackArrayDType* adtypep = VN_CAST(dtypep, UnpackArrayDType)) {
 	    for (int index_docs=adtypep->lsb(); index_docs<=adtypep->msb(); ++index_docs) {
 		int index_code = index_docs - adtypep->lsb();
 		ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
@@ -230,7 +226,7 @@ private:
 		newent.cleanup();
 	    }
 	}
-	else if (AstPackArrayDType* adtypep = dtypep->castPackArrayDType()) {
+        else if (AstPackArrayDType* adtypep = VN_CAST(dtypep, PackArrayDType)) {
 	    for (int index_docs=adtypep->lsb(); index_docs<=adtypep->msb(); ++index_docs) {
 		AstNodeDType* subtypep = adtypep->subDTypep()->skipRefp();
 		int index_code = index_docs - adtypep->lsb();
@@ -245,9 +241,9 @@ private:
 		newent.cleanup();
 	    }
 	}
-	else if (AstStructDType* adtypep = dtypep->castStructDType()) {
+        else if (AstStructDType* adtypep = VN_CAST(dtypep, StructDType)) {
 	    // For now it's packed, so similar to array
-	    for (AstMemberDType* itemp = adtypep->membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
+            for (AstMemberDType* itemp = adtypep->membersp(); itemp; itemp=VN_CAST(itemp->nextp(), MemberDType)) {
 		AstNodeDType* subtypep = itemp->subDTypep()->skipRefp();
 		int index_code = itemp->lsb();
 		ToggleEnt newent (above.m_comment+string(".")+itemp->name(),
@@ -261,7 +257,7 @@ private:
 		newent.cleanup();
 	    }
 	}
-	else if (AstUnionDType* adtypep = dtypep->castUnionDType()) {
+        else if (AstUnionDType* adtypep = VN_CAST(dtypep, UnionDType)) {
 	    // Arbitrarially handle only the first member of the union
 	    if (AstMemberDType* itemp = adtypep->membersp()) {
 		AstNodeDType* subtypep = itemp->subDTypep()->skipRefp();
@@ -284,11 +280,11 @@ private:
 	UINFO(4," IF: "<<nodep<<endl);
 	if (m_checkBlock) {
 	    // An else-if.  When we iterate the if, use "elsif" marking
-	    bool elsif = (nodep->elsesp()->castIf()
-			  && !nodep->elsesp()->castIf()->nextp());
-	    if (elsif) nodep->elsesp()->castIf()->user1(true);
+            bool elsif = (VN_IS(nodep->elsesp(), If)
+                          && !VN_CAST(nodep->elsesp(), If)->nextp());
+            if (elsif) VN_CAST(nodep->elsesp(), If)->user1(true);
 	    //
-	    nodep->ifsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->ifsp());
 	    if (m_checkBlock && !m_inModOff
 		&& nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "if" branch didn't disable it
 		UINFO(4,"   COVER: "<<nodep<<endl);
@@ -301,7 +297,7 @@ private:
 	    // Don't do empty else's, only empty if/case's
 	    if (nodep->elsesp()) {
 		m_checkBlock = true;
-		nodep->elsesp()->iterateAndNext(*this);
+                iterateAndNextNull(nodep->elsesp());
 		if (m_checkBlock && !m_inModOff
 		    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "else" branch didn't disable it
 		    UINFO(4,"   COVER: "<<nodep<<endl);
@@ -317,7 +313,7 @@ private:
 	UINFO(4," CASEI: "<<nodep<<endl);
 	if (m_checkBlock && !m_inModOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {
-	    nodep->bodysp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->bodysp());
 	    if (m_checkBlock) {	// if the case body didn't disable it
 		UINFO(4,"   COVER: "<<nodep<<endl);
 		nodep->addBodysp(newCoverInc(nodep->fileline(), "", "v_line", "case"));
@@ -328,7 +324,7 @@ private:
     virtual void visit(AstPslCover* nodep) {
 	UINFO(4," PSLCOVER: "<<nodep<<endl);
 	m_checkBlock = true;  // Always do cover blocks, even if there's a $stop
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (!nodep->coverincp()) {
 	    // Note the name may be overridden by V3Assert processing
 	    nodep->coverincp(newCoverInc(nodep->fileline(), m_beginHier, "v_user", "cover"));
@@ -346,7 +342,7 @@ private:
 	    m_checkBlock = false;
 	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
-	    if (m_checkBlock) nodep->iterateChildren(*this);
+            if (m_checkBlock) iterateChildren(nodep);
 	}
     }
     virtual void visit(AstBegin* nodep) {
@@ -362,7 +358,7 @@ private:
 	    if (nodep->name()!="") {
 		m_beginHier = m_beginHier + (m_beginHier!=""?".":"") + nodep->name();
 	    }
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_beginHier = oldHier;
 	m_inToggleOff = oldtog;
@@ -372,7 +368,7 @@ private:
     virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_checkBlock) {
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
@@ -382,10 +378,11 @@ public:
     explicit CoverageVisitor(AstNetlist* rootp) {
 	// Operate on all modules
 	m_checkBlock = true;
+        m_modp = NULL;
 	m_beginHier = "";
 	m_inToggleOff = false;
 	m_inModOff = true;
-	rootp->iterateChildren(*this);
+        iterateChildren(rootp);
     }
     virtual ~CoverageVisitor() {}
 };

src/V3CoverageJoin.cpp

@@ -46,7 +46,7 @@ private:
     //AstUser4InUse	In V3Hashed
 
     // TYPES
-    typedef vector<AstCoverToggle*> ToggleList;
+    typedef std::vector<AstCoverToggle*> ToggleList;
 
     // STATE
     ToggleList		m_toggleps;	// List of of all AstCoverToggle's
@@ -54,11 +54,7 @@ private:
     V3Double0		m_statToggleJoins;	// Statistic tracking
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void detectDuplicates() {
 	UINFO(9,"Finding duplicates\n");
@@ -82,14 +78,14 @@ private:
 		    AstNode* duporigp = hashed.iteratorNodep(dupit);
 		    // Note hashed will point to the original variable (what's duplicated), not the covertoggle,
 		    // but we need to get back to the covertoggle which is immediately above, so:
-		    AstCoverToggle* removep = duporigp->backp()->castCoverToggle();
+                    AstCoverToggle* removep = VN_CAST(duporigp->backp(), CoverToggle);
 		    if (!removep) nodep->v3fatalSrc("CoverageJoin duplicate of wrong type");
 		    UINFO(8,"  Orig "<<nodep<<" -->> "<<nodep->incp()->declp()<<endl);
 		    UINFO(8,"   dup "<<removep<<" -->> "<<removep->incp()->declp()<<endl);
 		    // The CoverDecl the duplicate pointed to now needs to point to the original's data
 		    // IE the duplicate will get the coverage number from the non-duplicate
 		    AstCoverDecl* datadeclp = nodep->incp()->declp()->dataDeclThisp();
-		    removep->incp()->declp()->dataDeclp (datadeclp);
+                    removep->incp()->declp()->dataDeclp(datadeclp);
 		    UINFO(8,"   new "<<removep->incp()->declp()<<endl);
 		    // Mark the found node as a duplicate of the first node
 		    // (Not vice-versa as we have the iterator for the found node)
@@ -105,24 +101,24 @@ private:
     // VISITORS
     virtual void visit(AstNetlist* nodep) {
 	// Find all Coverage's
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Simplify
 	detectDuplicates();
     }
     virtual void visit(AstCoverToggle* nodep) {
 	m_toggleps.push_back(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //--------------------
     virtual void visit(AstNodeMath* nodep) {}  // Accelerate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit CoverageJoinVisitor(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~CoverageJoinVisitor() {
 	V3Stats::addStat("Coverage, Toggle points joined", m_statToggleJoins);

src/V3Dead.cpp

@@ -59,18 +59,18 @@ private:
     // ** Shared with DeadVisitor **
     // VISITORS
     virtual void visit(AstCell* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	nodep->modp()->user1Inc(-1);
     }
     //-----
     virtual void visit(AstNodeMath* nodep) {}  // Accelerate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
     explicit DeadModVisitor(AstNodeModule* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~DeadModVisitor() {}
 };
@@ -89,15 +89,15 @@ private:
     AstUser1InUse	m_inuser1;
 
     // TYPES
-    typedef multimap<AstVarScope*,AstNodeAssign*>	AssignMap;
+    typedef std::multimap<AstVarScope*,AstNodeAssign*>  AssignMap;
 
     // STATE
     AstNodeModule*		m_modp;		// Current module
-    vector<AstVar*>		m_varsp;	// List of all encountered to avoid another loop through tree
-    vector<AstNode*>		m_dtypesp;	// List of all encountered to avoid another loop through tree
-    vector<AstVarScope*>	m_vscsp;	// List of all encountered to avoid another loop through tree
-    vector<AstScope*>		m_scopesp;	// List of all encountered to avoid another loop through tree
-    vector<AstCell*>		m_cellsp;	// List of all encountered to avoid another loop through tree
+    std::vector<AstVar*>        m_varsp;        // List of all encountered to avoid another loop through tree
+    std::vector<AstNode*>       m_dtypesp;      // List of all encountered to avoid another loop through tree
+    std::vector<AstVarScope*>   m_vscsp;        // List of all encountered to avoid another loop through tree
+    std::vector<AstScope*>      m_scopesp;      // List of all encountered to avoid another loop through tree
+    std::vector<AstCell*>       m_cellsp;       // List of all encountered to avoid another loop through tree
     AssignMap			m_assignMap;	// List of all simple assignments for each variable
     bool			m_elimUserVars;	// Allow removal of user's vars
     bool			m_elimDTypes;	// Allow removal of DTypes
@@ -106,11 +106,7 @@ private:
     bool			m_sideEffect;	// Side effects discovered in assign RHS
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void checkAll(AstNode* nodep) {
 	if (nodep != nodep->dtypep()) {	 // NodeDTypes reference themselves
@@ -125,7 +121,7 @@ private:
     void checkDType(AstNodeDType* nodep) {
 	if (!nodep->generic()  // Don't remove generic types
 	    && m_elimDTypes  // dtypes stick around until post-widthing
-	    && !nodep->castMemberDType() // Keep member names iff upper type exists
+            && !VN_IS(nodep, MemberDType)  // Keep member names iff upper type exists
 	    ) {
 	    m_dtypesp.push_back(nodep);
 	}
@@ -138,18 +134,18 @@ private:
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	if (!nodep->dead()) {
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    checkAll(nodep);
 	}
 	m_modp = NULL;
     }
     virtual void visit(AstCFunc* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->scopep()) nodep->scopep()->user1Inc();
     }
     virtual void visit(AstScope* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
 
@@ -158,14 +154,14 @@ private:
 	}
     }
     virtual void visit(AstCell* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	m_cellsp.push_back(nodep);
 	nodep->modp()->user1Inc();
     }
 
     virtual void visit(AstNodeVarRef* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->varScopep()) {
 	    nodep->varScopep()->user1Inc();
@@ -180,7 +176,7 @@ private:
 	}
     }
     virtual void visit(AstNodeFTaskRef* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->packagep()) {
 	    if (m_elimCells) nodep->packagep(NULL);
@@ -188,7 +184,7 @@ private:
 	}
     }
     virtual void visit(AstRefDType* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkDType(nodep);
 	checkAll(nodep);
 	if (nodep->packagep()) {
@@ -197,12 +193,12 @@ private:
 	}
     }
     virtual void visit(AstNodeDType* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkDType(nodep);
 	checkAll(nodep);
     }
     virtual void visit(AstEnumItemRef* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->packagep()) {
 	    if (m_elimCells) nodep->packagep(NULL);
@@ -211,7 +207,7 @@ private:
 	checkAll(nodep);
     }
     virtual void visit(AstModport* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (m_elimCells) {
 	    if (!nodep->varsp()) {
 		pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
@@ -221,7 +217,7 @@ private:
 	checkAll(nodep);
     }
     virtual void visit(AstTypedef* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (m_elimCells && !nodep->attrPublic()) {
 	    pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
 	    return;
@@ -229,10 +225,10 @@ private:
 	checkAll(nodep);
 	// Don't let packages with only public variables disappear
 	// Normal modules may disappear, e.g. if they are parameterized then removed
-	if (nodep->attrPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
+        if (nodep->attrPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
     }
     virtual void visit(AstVarScope* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
 	if (nodep->scopep()) nodep->scopep()->user1Inc();
 	if (mightElimVar(nodep->varp())) {
@@ -240,9 +236,9 @@ private:
 	}
     }
     virtual void visit(AstVar* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
-	if (nodep->isSigPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
+        if (nodep->isSigPublic() && m_modp && VN_IS(m_modp, Package)) m_modp->user1Inc();
 	if (mightElimVar(nodep)) {
 	    m_varsp.push_back(nodep);
 	}
@@ -251,16 +247,16 @@ private:
 	// See if simple assignments to variables may be eliminated because that variable is never used.
 	// Similar code in V3Life
 	m_sideEffect = false;
-	nodep->rhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->rhsp());
 	checkAll(nodep);
 	// Has to be direct assignment without any EXTRACTing.
-	AstVarRef* varrefp = nodep->lhsp()->castVarRef();
+        AstVarRef* varrefp = VN_CAST(nodep->lhsp(), VarRef);
 	if (varrefp && !m_sideEffect
 	    && varrefp->varScopep()) {	// For simplicity, we only remove post-scoping
 	    m_assignMap.insert(make_pair(varrefp->varScopep(), nodep));
 	    checkAll(varrefp);	// Must track reference to dtype()
 	} else {  // Track like any other statement
-	    nodep->lhsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->lhsp());
 	}
 	checkAll(nodep);
     }
@@ -268,7 +264,7 @@ private:
     //-----
     virtual void visit(AstNode* nodep) {
 	if (nodep->isOutputter()) m_sideEffect=true;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	checkAll(nodep);
     }
 
@@ -281,7 +277,7 @@ private:
 	    retry=false;
 	    AstNodeModule* nextmodp;
 	    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=nextmodp) {
-		nextmodp = modp->nextp()->castNodeModule();
+                nextmodp = VN_CAST(modp->nextp(), NodeModule);
 		if (modp->dead() || (modp->level()>2 && modp->user1()==0 && !modp->internal())) {
 		    // > 2 because L1 is the wrapper, L2 is the top user module
 		    UINFO(4,"  Dead module "<<modp<<endl);
@@ -307,12 +303,12 @@ private:
     void deadCheckScope() {
 	for (bool retry=true; retry; ) {
 	    retry = false;
-	    for (vector<AstScope*>::iterator it = m_scopesp.begin(); it != m_scopesp.end();++it) {
+            for (std::vector<AstScope*>::iterator it = m_scopesp.begin(); it != m_scopesp.end();++it) {
 		AstScope* scp = *it;
 		if (!scp)
 		    continue;
 		if (scp->user1() == 0) {
-		    UINFO(4, "	Dead AstScope " << scp << endl);
+                    UINFO(4, "  Dead AstScope " << scp << endl);
 		    scp->aboveScopep()->user1Inc(-1);
 		    if (scp->dtypep()) {
 			scp->dtypep()->user1Inc(-1);
@@ -326,7 +322,7 @@ private:
     }
 
     void deadCheckCells() {
-	for (vector<AstCell*>::iterator it = m_cellsp.begin(); it!=m_cellsp.end(); ++it) {
+        for (std::vector<AstCell*>::iterator it = m_cellsp.begin(); it!=m_cellsp.end(); ++it) {
 	    AstCell* cellp = *it;
 	    if (cellp->user1() == 0 && !cellp->modp()->stmtsp()) {
 		cellp->modp()->user1Inc(-1);
@@ -337,14 +333,14 @@ private:
 
     void deadCheckVar() {
 	// Delete any unused varscopes
-	for (vector<AstVarScope*>::iterator it = m_vscsp.begin(); it!=m_vscsp.end(); ++it) {
+        for (std::vector<AstVarScope*>::iterator it = m_vscsp.begin(); it!=m_vscsp.end(); ++it) {
 	    AstVarScope* vscp = *it;
 	    if (vscp->user1() == 0) {
 		UINFO(4,"  Dead "<<vscp<<endl);
-		pair <AssignMap::iterator,AssignMap::iterator> eqrange = m_assignMap.equal_range(vscp);
+                std::pair<AssignMap::iterator,AssignMap::iterator> eqrange = m_assignMap.equal_range(vscp);
 		for (AssignMap::iterator itr = eqrange.first; itr != eqrange.second; ++itr) {
 		    AstNodeAssign* assp = itr->second;
-		    UINFO(4,"	 Dead assign "<<assp<<endl);
+                    UINFO(4,"    Dead assign "<<assp<<endl);
 		    assp->dtypep()->user1Inc(-1);
 		    assp->unlinkFrBack()->deleteTree(); VL_DANGLING(assp);
 		}
@@ -355,12 +351,12 @@ private:
 	}
 	for (bool retry=true; retry; ) {
 	    retry = false;
-	    for (vector<AstVar *>::iterator it = m_varsp.begin(); it != m_varsp.end();++it) {
+            for (std::vector<AstVar *>::iterator it = m_varsp.begin(); it != m_varsp.end();++it) {
 		AstVar* varp = *it;
 		if (!varp)
 		    continue;
 		if (varp->user1() == 0) {
-		    UINFO(4, "	Dead " << varp << endl);
+                    UINFO(4, "  Dead " << varp << endl);
 		    if (varp->dtypep()) {
 			varp->dtypep()->user1Inc(-1);
 		    }
@@ -370,15 +366,16 @@ private:
 		}
 	    }
 	}
-	for (vector<AstNode*>::iterator it = m_dtypesp.begin(); it != m_dtypesp.end();++it) {
+        for (std::vector<AstNode*>::iterator it = m_dtypesp.begin(); it != m_dtypesp.end();++it) {
 	    if ((*it)->user1() == 0) {
 		AstNodeClassDType *classp;
 		// It's possible that there if a reference to each individual member, but
 		// not to the dtype itself.  Check and don't remove the parent dtype if
 		// members are still alive.
-		if ((classp = (*it)->castNodeClassDType())) {
+                if ((classp = VN_CAST((*it), NodeClassDType))) {
 		    bool cont = true;
-		    for (AstMemberDType *memberp = classp->membersp(); memberp; memberp = memberp->nextp()->castMemberDType()) {
+                    for (AstMemberDType *memberp = classp->membersp();
+                         memberp; memberp = VN_CAST(memberp->nextp(), MemberDType)) {
 			if (memberp->user1() != 0) {
 			    cont = false;
 			    break;
@@ -404,7 +401,7 @@ public:
 	// Prepare to remove some datatypes
 	nodep->typeTablep()->clearCache();
 	// Operate on whole netlist
-	nodep->accept(*this);
+        iterate(nodep);
 
 	deadCheckVar();
 	// We only elimate scopes when in a flattened structure

src/V3Delayed.cpp

@@ -98,18 +98,14 @@ private:
     bool		m_inDly;	// True in delayed assignments
     bool		m_inLoop;	// True in for loops
     bool		m_inInitial;	// True in intial blocks
-    typedef std::map<pair<AstNodeModule*,string>,AstVar*> VarMap;
+    typedef std::map<std::pair<AstNodeModule*,string>,AstVar*> VarMap;
     VarMap		m_modVarMap;	// Table of new var names created under module
     V3Double0		m_statSharedSet;// Statistic tracking
     typedef std::map<AstVarScope*,int> ScopeVecMap;
     ScopeVecMap m_scopeVecMap; // Next var number for each scope
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void markVarUsage(AstVarScope* nodep, uint32_t flags) {
 	//UINFO(4," MVU "<<flags<<" "<<nodep<<endl);
@@ -119,7 +115,8 @@ private:
                           <<nodep->varp()->prettyName());
 	}
     }
-    AstVarScope* createVarSc(AstVarScope* oldvarscp, string name, int width/*0==fromoldvar*/, AstNodeDType* newdtypep) {
+    AstVarScope* createVarSc(AstVarScope* oldvarscp, const string& name,
+                             int width/*0==fromoldvar*/, AstNodeDType* newdtypep) {
 	// Because we've already scoped it, we may need to add both the AstVar and the AstVarScope
 	if (!oldvarscp->scopep()) oldvarscp->v3fatalSrc("Var unscoped");
 	AstVar* varp;
@@ -131,25 +128,25 @@ private:
 	    varp = it->second;
 	} else {
 	    if (newdtypep) {
-		varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, newdtypep);
+                varp = new AstVar(oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, newdtypep);
 	    } else if (width==0) {
-		varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, oldvarscp->varp());
+                varp = new AstVar(oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, oldvarscp->varp());
 		varp->dtypeFrom(oldvarscp);
 	    } else { // Used for vset and dimensions, so can zero init
-		varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, VFlagBitPacked(), width);
+                varp = new AstVar(oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, VFlagBitPacked(), width);
 	    }
 	    addmodp->addStmtp(varp);
 	    m_modVarMap.insert(make_pair(make_pair(addmodp, name), varp));
 	}
 
-	AstVarScope* varscp = new AstVarScope (oldvarscp->fileline(), oldvarscp->scopep(), varp);
+        AstVarScope* varscp = new AstVarScope(oldvarscp->fileline(), oldvarscp->scopep(), varp);
 	oldvarscp->scopep()->addVarp(varscp);
 	return varscp;
     }
 
     AstActive* createActivePost(AstVarRef* varrefp) {
-	AstActive* newactp = new AstActive (varrefp->fileline(), "sequentdly",
-					    m_activep->sensesp());
+        AstActive* newactp = new AstActive(varrefp->fileline(), "sequentdly",
+                                           m_activep->sensesp());
         // Was addNext(), but addNextHere() avoids a linear search.
         m_activep->addNextHere(newactp);
 	return newactp;
@@ -191,45 +188,45 @@ private:
 	AstNode* newlhsp = NULL;	// NULL = unlink old assign
 	AstSel*  bitselp = NULL;
 	AstArraySel*  arrayselp = NULL;
-	if (lhsp->castSel()) {
-	    bitselp = lhsp->castSel();
-	    arrayselp = bitselp->fromp()->castArraySel();
+        if (VN_IS(lhsp, Sel)) {
+            bitselp = VN_CAST(lhsp, Sel);
+            arrayselp = VN_CAST(bitselp->fromp(), ArraySel);
 	} else {
-	    arrayselp = lhsp->castArraySel();
+            arrayselp = VN_CAST(lhsp, ArraySel);
 	}
 	if (!arrayselp) nodep->v3fatalSrc("No arraysel under bitsel?");
-        if (arrayselp->dtypep()->skipRefp()->castUnpackArrayDType()) {
+        if (VN_IS(arrayselp->dtypep()->skipRefp(), UnpackArrayDType)) {
             nodep->v3fatalSrc("ArraySel with unpacked arrays should have been removed in V3Slice");
         }
 	UINFO(4,"AssignDlyArray: "<<nodep<<endl);
 	//
 	//=== Dimensions: __Vdlyvdim__
-	deque<AstNode*> dimvalp;		// Assignment value for each dimension of assignment
+        std::deque<AstNode*> dimvalp;           // Assignment value for each dimension of assignment
 	AstNode* dimselp=arrayselp;
-	for (; dimselp->castArraySel(); dimselp=dimselp->castArraySel()->fromp()) {
-	    AstNode* valp = dimselp->castArraySel()->bitp()->unlinkFrBack();
+        for (; VN_IS(dimselp, ArraySel); dimselp=VN_CAST(dimselp, ArraySel)->fromp()) {
+            AstNode* valp = VN_CAST(dimselp, ArraySel)->bitp()->unlinkFrBack();
 	    dimvalp.push_front(valp);
 	}
-	AstVarRef* varrefp = dimselp->castVarRef();
+        AstVarRef* varrefp = VN_CAST(dimselp, VarRef);
 	if (!varrefp) nodep->v3fatalSrc("No var underneath arraysels");
 	if (!varrefp->varScopep()) varrefp->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
 	varrefp->unlinkFrBack();
 	AstVar* oldvarp = varrefp->varp();
 	int modVecNum = m_scopeVecMap[varrefp->varScopep()]++;
 	//
-	deque<AstNode*> dimreadps;		// Read value for each dimension of assignment
+        std::deque<AstNode*> dimreadps;         // Read value for each dimension of assignment
 	for (unsigned dimension=0; dimension<dimvalp.size(); dimension++) {
 	    AstNode* dimp = dimvalp[dimension];
-	    if (dimp->castConst()) { // bit = const, can just use it
+            if (VN_IS(dimp, Const)) {  // bit = const, can just use it
 		dimreadps.push_front(dimp);
 	    } else {
 		string bitvarname = (string("__Vdlyvdim")+cvtToStr(dimension)
 				     +"__"+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 		AstVarScope* bitvscp = createVarSc(varrefp->varScopep(), bitvarname, dimp->width(), NULL);
 		AstAssign* bitassignp
-		    = new AstAssign (nodep->fileline(),
-				     new AstVarRef(nodep->fileline(), bitvscp, true),
-				     dimp);
+                    = new AstAssign(nodep->fileline(),
+                                    new AstVarRef(nodep->fileline(), bitvscp, true),
+                                    dimp);
 		nodep->addNextHere(bitassignp);
 		dimreadps.push_front(new AstVarRef(nodep->fileline(), bitvscp, false));
 	    }
@@ -239,14 +236,14 @@ private:
 	AstNode* bitreadp=NULL;  // Code to read Vdlyvlsb
 	if (bitselp) {
 	    AstNode* lsbvaluep = bitselp->lsbp()->unlinkFrBack();
-	    if (bitselp->fromp()->castConst()) {// vlsb = constant, can just push constant into where we use it
+            if (VN_IS(bitselp->fromp(), Const)) {  // vlsb = constant, can just push constant into where we use it
 		bitreadp = lsbvaluep;
 	    } else {
 		string bitvarname = (string("__Vdlyvlsb__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 		AstVarScope* bitvscp = createVarSc(varrefp->varScopep(), bitvarname, lsbvaluep->width(), NULL);
-		AstAssign* bitassignp = new AstAssign (nodep->fileline(),
-						       new AstVarRef(nodep->fileline(), bitvscp, true),
-						       lsbvaluep);
+                AstAssign* bitassignp = new AstAssign(nodep->fileline(),
+                                                      new AstVarRef(nodep->fileline(), bitvscp, true),
+                                                      lsbvaluep);
 		nodep->addNextHere(bitassignp);
 		bitreadp = new AstVarRef(nodep->fileline(), bitvscp, false);
 	    }
@@ -254,7 +251,7 @@ private:
 	//
 	//=== Value: __Vdlyvval__
 	AstNode* valreadp;	// Code to read Vdlyvval
-	if (nodep->rhsp()->castConst()) {	// vval = constant, can just push constant into where we use it
+        if (VN_IS(nodep->rhsp(), Const)) {  // vval = constant, can just push constant into where we use it
 	    valreadp = nodep->rhsp()->unlinkFrBack();
 	} else {
 	    string valvarname = (string("__Vdlyvval__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
@@ -272,19 +269,19 @@ private:
 	    // then we told this nodep->user3 we can use its Vdlyvset rather than making a new one.
 	    // This is good for code like:
 	    //    for (i=0; i<5; i++)  vector[i] <= something;
-	    setvscp = nodep->user3p()->castVarScope();
+            setvscp = VN_CAST(nodep->user3p(), VarScope);
 	    ++m_statSharedSet;
 	} else {  // Create new one
 	    string setvarname = (string("__Vdlyvset__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
 	    setvscp = createVarSc(varrefp->varScopep(), setvarname, 1, NULL);
-	    setinitp = new AstAssignPre (nodep->fileline(),
-					 new AstVarRef(nodep->fileline(), setvscp, true),
-					 new AstConst(nodep->fileline(), 0));
+            setinitp = new AstAssignPre(nodep->fileline(),
+                                        new AstVarRef(nodep->fileline(), setvscp, true),
+                                        new AstConst(nodep->fileline(), 0));
 	    AstAssign* setassignp
-		= new AstAssign (nodep->fileline(),
-				 new AstVarRef(nodep->fileline(), setvscp, true),
-				 new AstConst(nodep->fileline(),
-					      V3Number(nodep->fileline(),1,true)));
+                = new AstAssign(nodep->fileline(),
+                                new AstVarRef(nodep->fileline(), setvscp, true),
+                                new AstConst(nodep->fileline(),
+                                             V3Number(nodep->fileline(),1,true)));
 	    nodep->addNextHere(setassignp);
 	}
 	if (m_nextDlyp) {  // Tell next assigndly it can share the variable
@@ -307,9 +304,9 @@ private:
 	// Build "IF (changeit) ...
 	UINFO(9,"   For "<<setvscp<<endl);
 	UINFO(9,"     & "<<varrefp<<endl);
-	AstAlwaysPost* finalp = varrefp->varScopep()->user4p()->castAlwaysPost();
+        AstAlwaysPost* finalp = VN_CAST(varrefp->varScopep()->user4p(), AlwaysPost);
 	if (finalp) {
-	    AstActive* oldactivep = finalp->user2p()->castActive();
+            AstActive* oldactivep = VN_CAST(finalp->user2p(), Active);
 	    checkActivePost(varrefp, oldactivep);
 	    if (setinitp) oldactivep->addStmtsp(setinitp);
 	} else { // first time we've dealt with this memory
@@ -325,13 +322,12 @@ private:
 	if (finalp->user3p() == setvscp) {
 	    // Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*,
 	    // we can share the IF statement too
-	    postLogicp = finalp->user4p()->castIf();
+            postLogicp = VN_CAST(finalp->user4p(), If);
 	    if (!postLogicp) nodep->v3fatalSrc("Delayed assignment misoptimized; prev var found w/o associated IF");
 	} else {
-	    postLogicp = new AstIf (nodep->fileline(),
-				    new AstVarRef(nodep->fileline(), setvscp, false),
-				    NULL,
-				    NULL);
+            postLogicp = new AstIf(nodep->fileline(),
+                                   new AstVarRef(nodep->fileline(), setvscp, false),
+                                   NULL, NULL);
 	    UINFO(9,"     Created "<<postLogicp<<endl);
 	    finalp->addBodysp(postLogicp);
 	    finalp->user3p(setvscp);	// Remember IF's vset variable
@@ -345,16 +341,16 @@ private:
     virtual void visit(AstNetlist* nodep) {
 	//VV*****  We reset all userp() on the netlist
 	m_modVarMap.clear();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstScope* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	AstNode::user3ClearTree();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstCFunc* nodep) {
 	m_cfuncp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_cfuncp = NULL;
     }
     virtual void visit(AstActive* nodep) {
@@ -362,16 +358,16 @@ private:
 	bool oldinit = m_inInitial;
 	m_inInitial = nodep->hasInitial();
 	AstNode::user3ClearTree();  // Two sets to same variable in different actives must use different vars.
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_inInitial = oldinit;
     }
     virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
-	m_nextDlyp = nodep->nextp()->castAssignDly();  // Next assignment in same block, maybe NULL.
+        m_nextDlyp = VN_CAST(nodep->nextp(), AssignDly);  // Next assignment in same block, maybe NULL.
 	if (m_cfuncp) nodep->v3error("Unsupported: Delayed assignment inside public function/task");
-	if (nodep->lhsp()->castArraySel()
-	    || (nodep->lhsp()->castSel()
-		&& nodep->lhsp()->castSel()->fromp()->castArraySel())) {
+        if (VN_IS(nodep->lhsp(), ArraySel)
+            || (VN_IS(nodep->lhsp(), Sel)
+                && VN_IS(VN_CAST(nodep->lhsp(), Sel)->fromp(), ArraySel))) {
 	    AstNode* lhsp = nodep->lhsp()->unlinkFrBack();
 	    AstNode* newlhsp = createDlyArray(nodep, lhsp);
 	    if (m_inLoop) nodep->v3warn(BLKLOOPINIT,"Unsupported: Delayed assignment to array inside for loops (non-delayed is ok - see docs)");
@@ -383,7 +379,7 @@ private:
 	    lhsp->deleteTree(); VL_DANGLING(lhsp);
 	}
 	else {
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_inDly = false;
 	m_nextDlyp = NULL;
@@ -400,22 +396,22 @@ private:
                 }
 		AstVarScope* oldvscp = nodep->varScopep();
 		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
-		AstVarScope* dlyvscp = oldvscp->user1p()->castVarScope();
+                AstVarScope* dlyvscp = VN_CAST(oldvscp->user1p(), VarScope);
 		if (dlyvscp) {  // Multiple use of delayed variable
-		    AstActive* oldactivep = dlyvscp->user2p()->castActive();
+                    AstActive* oldactivep = VN_CAST(dlyvscp->user2p(), Active);
 		    checkActivePost(nodep, oldactivep);
 		}
 		if (!dlyvscp) {  // First use of this delayed variable
 		    string newvarname = (string("__Vdly__")+nodep->varp()->shortName());
 		    dlyvscp = createVarSc(oldvscp, newvarname, 0, NULL);
 		    AstNodeAssign* prep
-			= new AstAssignPre (nodep->fileline(),
-					    new AstVarRef(nodep->fileline(), dlyvscp, true),
-					    new AstVarRef(nodep->fileline(), oldvscp, false));
+                        = new AstAssignPre(nodep->fileline(),
+                                           new AstVarRef(nodep->fileline(), dlyvscp, true),
+                                           new AstVarRef(nodep->fileline(), oldvscp, false));
 		    AstNodeAssign* postp
-			= new AstAssignPost (nodep->fileline(),
-					     new AstVarRef(nodep->fileline(), oldvscp, true),
-					     new AstVarRef(nodep->fileline(), dlyvscp, false));
+                        = new AstAssignPost(nodep->fileline(),
+                                            new AstVarRef(nodep->fileline(), oldvscp, true),
+                                            new AstVarRef(nodep->fileline(), dlyvscp, false));
 		    postp->lhsp()->user2(true);	// Don't detect this assignment
 		    oldvscp->user1p(dlyvscp);  // So we can find it later
 		    // Make new ACTIVE with identical sensitivity tree
@@ -444,14 +440,14 @@ private:
     virtual void visit(AstWhile* nodep) {
 	bool oldloop = m_inLoop;
 	m_inLoop = true;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_inLoop = oldloop;
     }
 
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
@@ -464,7 +460,7 @@ public:
 	m_inLoop = false;
 	m_inInitial = false;
 
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~DelayedVisitor() {
 	V3Stats::addStat("Optimizations, Delayed shared-sets", m_statSharedSet);

src/V3Depth.cpp

@@ -52,32 +52,28 @@ private:
     int			m_maxdepth;	// Maximum depth in an expression
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void createDeepTemp(AstNode* nodep) {
 	UINFO(6,"  Deep  "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"deep:");
 
 	string newvarname = ((string)"__Vdeeptemp"+cvtToStr(m_modp->varNumGetInc()));
-	AstVar* varp = new AstVar (nodep->fileline(), AstVarType::STMTTEMP, newvarname,
-				   // Width, not widthMin, as we may be in middle of BITSEL expression which
-				   // though it's one bit wide, needs the mask in the upper bits.
-				   // (Someday we'll have a valid bitmask instead of widths....)
-				   // See t_func_crc for an example test that requires this
-				   VFlagLogicPacked(), nodep->width());
+        AstVar* varp = new AstVar(nodep->fileline(), AstVarType::STMTTEMP, newvarname,
+                                  // Width, not widthMin, as we may be in middle of BITSEL expression which
+                                  // though it's one bit wide, needs the mask in the upper bits.
+                                  // (Someday we'll have a valid bitmask instead of widths....)
+                                  // See t_func_crc for an example test that requires this
+                                  VFlagLogicPacked(), nodep->width());
 	if (!m_funcp) nodep->v3fatalSrc("Deep expression not under a function");
 	m_funcp->addInitsp(varp);
 	// Replace node tree with reference to var
-	AstVarRef* newp = new AstVarRef (nodep->fileline(), varp, false);
+        AstVarRef* newp = new AstVarRef(nodep->fileline(), varp, false);
 	nodep->replaceWith(newp);
 	// Put assignment before the referencing statement
-	AstAssign* assp = new AstAssign (nodep->fileline(),
-					 new AstVarRef(nodep->fileline(), varp, true),
-					 nodep);
+        AstAssign* assp = new AstAssign(nodep->fileline(),
+                                        new AstVarRef(nodep->fileline(), varp, true),
+                                        nodep);
 	AstNRelinker linker2;
 	m_stmtp->unlinkFrBack(&linker2);
 	assp->addNext(m_stmtp);
@@ -89,21 +85,21 @@ private:
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_funcp = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstCFunc* nodep) {
 	m_funcp = nodep;
 	m_depth = 0;
 	m_maxdepth = 0;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_funcp = NULL;
     }
     void visitStmt(AstNodeStmt* nodep) {
 	m_depth = 0;
 	m_maxdepth = 0;
 	m_stmtp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_stmtp = NULL;
     }
     virtual void visit(AstNodeStmt* nodep) {
@@ -116,13 +112,13 @@ private:
 	// We have some operator defines that use 2 parens, so += 2.
 	m_depth += 2;
 	if (m_depth>m_maxdepth) m_maxdepth=m_depth;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_depth -= 2;
 
 	if (m_stmtp
 	    && (v3Global.opt.compLimitParens() >= 1)	// Else compiler doesn't need it
 	    && (m_maxdepth-m_depth) > v3Global.opt.compLimitParens()
-	    && !nodep->backp()->castNodeStmt()  // Not much point if we're about to use it
+            && !VN_IS(nodep->backp(), NodeStmt)  // Not much point if we're about to use it
 	    ) {
 	    m_maxdepth = m_depth;
 	    createDeepTemp(nodep);
@@ -141,7 +137,7 @@ private:
     }
     virtual void visit(AstUCFunc* nodep) {
 	needNonStaticFunc(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstUCStmt* nodep) {
 	needNonStaticFunc(nodep);
@@ -152,7 +148,7 @@ private:
     // Default: Just iterate
     virtual void visit(AstVar* nodep) {}	// Don't hit varrefs under vars
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
@@ -164,7 +160,7 @@ public:
 	m_depth=0;
 	m_maxdepth=0;
 	//
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~DepthVisitor() {}
 };

src/V3DepthBlock.cpp

@@ -49,11 +49,7 @@ private:
     int			m_deepNum;	// How many functions made
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     AstCFunc* createDeepFunc(AstNode* nodep) {
 	AstNRelinker relinkHandle;
@@ -80,7 +76,7 @@ private:
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_deepNum = 0;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstCFunc* nodep) {
@@ -90,7 +86,7 @@ private:
 	{
 	    m_depth = 0;
 	    m_funcp = nodep;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_depth = lastDepth;
 	m_funcp = lastFuncp;
@@ -98,16 +94,16 @@ private:
     void visitStmt(AstNodeStmt* nodep) {
 	m_depth++;
 	if (m_depth > v3Global.opt.compLimitBlocks()
-	    && !nodep->castCCall()) {   // Already done
+            && !VN_IS(nodep, CCall)) {  // Already done
 	    UINFO(4, "DeepBlocks "<<m_depth<<" "<<nodep<<endl);
 	    AstNode* backp = nodep->backp();  // Only for debug
 	    if (debug()>=9) backp->dumpTree(cout,"-   pre : ");
 	    AstCFunc* funcp = createDeepFunc(nodep);
-	    funcp->accept(*this);
+            iterate(funcp);
 	    if (debug()>=9) backp->dumpTree(cout,"-   post: ");
 	    if (debug()>=9) funcp->dumpTree(cout,"-   func: ");
 	} else {
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
 	m_depth--;
     }
@@ -120,16 +116,18 @@ private:
     // Default: Just iterate
     virtual void visit(AstVar* nodep) {}	// Don't hit varrefs under vars
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit DepthBlockVisitor(AstNetlist* nodep) {
-	m_modp=NULL;
-	m_depth=0;
+        m_modp = NULL;
+        m_funcp = NULL;
+        m_depth = 0;
+        m_deepNum = 0;
 	//
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~DepthBlockVisitor() {}
 };

src/V3Descope.cpp

@@ -48,7 +48,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // TYPES
-    typedef multimap<string,AstCFunc*>	FuncMmap;
+    typedef std::multimap<string,AstCFunc*>     FuncMmap;
 
     // STATE
     AstNodeModule*	m_modp;		// Current module
@@ -58,17 +58,13 @@ private:
     FuncMmap		m_modFuncs;	// Name of public functions added
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     static bool modIsSingleton(AstNodeModule* modp) {
         // True iff there's exactly one instance of this module in the design.
         int instances = 0;
         for (AstNode* stmtp = modp->stmtsp(); stmtp; stmtp=stmtp->nextp()) {
-            if (stmtp->castScope()) {
+            if (VN_IS(stmtp, Scope)) {
                 if (++instances > 1) { return false; }
             }
         }
@@ -87,7 +83,7 @@ private:
     // false if the object is in another scope.
     string descopedName(const AstScope* scopep, bool& hierThisr,
                         const AstVar* varp=NULL) {
-	UASSERT(scopep, "Var/Func not scoped\n");
+        UASSERT(scopep, "Var/Func not scoped");
 	hierThisr = (scopep == m_scopep);
 
         // It's possible to disable relative references. This is a concession
@@ -187,7 +183,7 @@ private:
 		    funcp->declPrivate(true);
 		    AstNode* argsp = NULL;
 		    for (AstNode* stmtp = newfuncp->argsp(); stmtp; stmtp=stmtp->nextp()) {
-			if (AstVar* portp = stmtp->castVar()) {
+                        if (AstVar* portp = VN_CAST(stmtp, Var)) {
 			    if (portp->isIO() && !portp->isFuncReturn()) {
 				AstNode* newp = new AstVarRef(portp->fileline(), portp, portp->isOutput());
 				if (argsp) argsp = argsp->addNextNull(newp);
@@ -196,20 +192,19 @@ private:
 			}
 		    }
 
-		    AstNode* returnp = new AstCReturn (funcp->fileline(),
-						       new AstCCall (funcp->fileline(),
-								     funcp,
-								     argsp));
+                    AstNode* returnp = new AstCReturn(funcp->fileline(),
+                                                      new AstCCall(funcp->fileline(),
+                                                                   funcp, argsp));
 
 		    if (moreOfSame) {
-			AstIf* ifp = new AstIf (funcp->fileline(),
-						new AstEq(funcp->fileline(),
-							  new AstCMath(funcp->fileline(),
-								       "this", 64),
-							  new AstCMath(funcp->fileline(),
-								       string("&(")
-								       +funcp->scopep()->nameVlSym()
-								       +")", 64)),
+                        AstIf* ifp = new AstIf(funcp->fileline(),
+                                               new AstEq(funcp->fileline(),
+                                                         new AstCMath(funcp->fileline(),
+                                                                      "this", 64),
+                                                         new AstCMath(funcp->fileline(),
+                                                                      string("&(")
+                                                                      +funcp->scopep()->nameVlSym()
+                                                                      +")", 64)),
 						returnp, NULL);
 			newfuncp->addStmtsp(ifp);
 		    } else {
@@ -234,13 +229,13 @@ private:
 	m_modp = nodep;
 	m_modFuncs.clear();
         m_modSingleton = modIsSingleton(m_modp);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	makePublicFuncWrappers();
 	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep) {
 	m_scopep = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_scopep = NULL;
     }
     virtual void visit(AstVarScope* nodep) {
@@ -249,7 +244,7 @@ private:
 	pushDeletep(nodep);
     }
     virtual void visit(AstNodeVarRef* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Convert the hierch name
 	if (!m_scopep) nodep->v3fatalSrc("Node not under scope");
 	bool hierThis;
@@ -259,7 +254,7 @@ private:
     }
     virtual void visit(AstCCall* nodep) {
 	//UINFO(9,"       "<<nodep<<endl);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Convert the hierch name
 	if (!m_scopep) nodep->v3fatalSrc("Node not under scope");
 	if (!nodep->funcp()->scopep()) nodep->v3fatalSrc("CFunc not under scope");
@@ -271,7 +266,7 @@ private:
     virtual void visit(AstCFunc* nodep) {
 	if (!nodep->user1()) {
 	    m_needThis = false;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    nodep->user1(true);
 	    if (m_needThis) {
                 nodep->isStatic(false);
@@ -292,7 +287,7 @@ private:
     }
     virtual void visit(AstVar*) {}
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
@@ -301,7 +296,7 @@ public:
           m_scopep(NULL),
           m_modSingleton(false),
           m_needThis(false) {
-        nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~DescopeVisitor() {}
 };

src/V3EmitCBase.h

@@ -66,12 +66,12 @@ public:
 	v3Global.rootp()->addFilesp(cfilep);
 	return cfilep;
     }
-    string cFuncArgs(AstCFunc* nodep) {
+    string cFuncArgs(const AstCFunc* nodep) {
 	// Return argument list for given C function
 	string args = nodep->argTypes();
 	// Might be a user function with argument list.
-	for (AstNode* stmtp = nodep->argsp(); stmtp; stmtp=stmtp->nextp()) {
-	    if (AstVar* portp = stmtp->castVar()) {
+        for (const AstNode* stmtp = nodep->argsp(); stmtp; stmtp=stmtp->nextp()) {
+            if (const AstVar* portp = VN_CAST_CONST(stmtp, Var)) {
 		if (portp->isIO() && !portp->isFuncReturn()) {
 		    if (args != "") args+= ", ";
 		    if (nodep->dpiImport() || nodep->dpiExportWrapper())
@@ -102,13 +102,13 @@ private:
     // VISITORS
     virtual void visit(AstNode* nodep) {
 	m_count++;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
     explicit EmitCBaseCounterVisitor(AstNode* nodep) {
 	m_count = 0;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~EmitCBaseCounterVisitor() {}
     int count() const { return m_count; }

src/V3EmitCInlines.cpp

@@ -51,13 +51,13 @@ class EmitCInlines : EmitCBaseVisitor {
     virtual void visit(AstNodeStmt*) {}
     // Default
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //---------------------------------------
     // ACCESSORS
 public:
     explicit EmitCInlines(AstNetlist* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
 	if (v3Global.needHInlines()) {
 	    emitInt();
 	}

src/V3EmitCSyms.cpp

@@ -57,18 +57,18 @@ class EmitCSyms : EmitCBaseVisitor {
 	ScopeVarData(const string& scopeName, const string& varBasePretty, AstVar* varp, AstNodeModule* modp, AstScope* scopep)
 	    : m_scopeName(scopeName), m_varBasePretty(varBasePretty), m_varp(varp), m_modp(modp), m_scopep(scopep) {}
     };
-    typedef map<string,ScopeFuncData> ScopeFuncs;
-    typedef map<string,ScopeVarData> ScopeVars;
-    typedef map<string,ScopeNameData> ScopeNames;
-    typedef pair<AstScope*,AstNodeModule*> ScopeModPair;
-    typedef pair<AstNodeModule*,AstVar*> ModVarPair;
+    typedef std::map<string,ScopeFuncData> ScopeFuncs;
+    typedef std::map<string,ScopeVarData> ScopeVars;
+    typedef std::map<string,ScopeNameData> ScopeNames;
+    typedef std::pair<AstScope*,AstNodeModule*> ScopeModPair;
+    typedef std::pair<AstNodeModule*,AstVar*> ModVarPair;
     struct CmpName {
-	inline bool operator () (const ScopeModPair& lhsp, const ScopeModPair& rhsp) const {
+        inline bool operator() (const ScopeModPair& lhsp, const ScopeModPair& rhsp) const {
 	    return lhsp.first->name() < rhsp.first->name();
 	}
     };
     struct CmpDpi {
-	inline bool operator () (const AstCFunc* lhsp, const AstCFunc* rhsp) const {
+        inline bool operator() (const AstCFunc* lhsp, const AstCFunc* rhsp) const {
 	    if (lhsp->dpiImport() != rhsp->dpiImport()) {
 		// cppcheck-suppress comparisonOfFuncReturningBoolError
 		return lhsp->dpiImport() < rhsp->dpiImport();
@@ -80,9 +80,9 @@ class EmitCSyms : EmitCBaseVisitor {
     // STATE
     AstCFunc*		m_funcp;	// Current function
     AstNodeModule*	m_modp;		// Current module
-    vector<ScopeModPair>  m_scopes;	// Every scope by module
-    vector<AstCFunc*>	m_dpis;		// DPI functions
-    vector<ModVarPair>	m_modVars;	// Each public {mod,var}
+    std::vector<ScopeModPair> m_scopes; // Every scope by module
+    std::vector<AstCFunc*>    m_dpis;   // DPI functions
+    std::vector<ModVarPair>   m_modVars;  // Each public {mod,var}
     ScopeNames		m_scopeNames;	// Each unique AstScopeName
     ScopeFuncs		m_scopeFuncs;	// Each {scope,dpi-export-func}
     ScopeVars		m_scopeVars;	// Each {scope,public-var}
@@ -113,9 +113,9 @@ class EmitCSyms : EmitCBaseVisitor {
 	// We didn'e have all m_scopes loaded when we encountered variables, so expand them now
 	// It would be less code if each module inserted its own variables.
 	// Someday.  For now public isn't common.
-	for (vector<ScopeModPair>::iterator itsc = m_scopes.begin(); itsc != m_scopes.end(); ++itsc) {
+        for (std::vector<ScopeModPair>::iterator itsc = m_scopes.begin(); itsc != m_scopes.end(); ++itsc) {
 	    AstScope* scopep = itsc->first;  AstNodeModule* smodp = itsc->second;
-	    for (vector<ModVarPair>::iterator it = m_modVars.begin(); it != m_modVars.end(); ++it) {
+            for (std::vector<ModVarPair>::iterator it = m_modVars.begin(); it != m_modVars.end(); ++it) {
 		AstNodeModule* modp = it->first;
 		AstVar* varp = it->second;
 		if (modp == smodp) {
@@ -166,7 +166,7 @@ class EmitCSyms : EmitCBaseVisitor {
     // VISITORS
     virtual void visit(AstNetlist* nodep) {
 	// Collect list of scopes
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	varsExpand();
 
 	// Sort by names, so line/process order matters less
@@ -185,7 +185,7 @@ class EmitCSyms : EmitCBaseVisitor {
 	nameCheck(nodep);
 	m_modp = nodep;
 	m_labelNum = 0;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep) {
@@ -210,7 +210,7 @@ class EmitCSyms : EmitCBaseVisitor {
     }
     virtual void visit(AstVar* nodep) {
 	nameCheck(nodep);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (nodep->isSigUserRdPublic()
 	    && !nodep->isParam()) {  // The VPI functions require a pointer to allow modification, but parameters are constants
 	    m_modVars.push_back(make_pair(m_modp, nodep));
@@ -224,7 +224,7 @@ class EmitCSyms : EmitCBaseVisitor {
     }
     virtual void visit(AstJumpLabel* nodep) {
 	nodep->labelNum(++m_labelNum);
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstCFunc* nodep) {
 	nameCheck(nodep);
@@ -232,14 +232,14 @@ class EmitCSyms : EmitCBaseVisitor {
 	    m_dpis.push_back(nodep);
 	}
 	m_funcp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_funcp = NULL;
     }
     // NOPs
     virtual void visit(AstConst*) {}
     // Default
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //---------------------------------------
     // ACCESSORS
@@ -249,7 +249,7 @@ public:
 	m_modp = NULL;
 	m_coverBins = 0;
 	m_labelNum = 0;
-	nodep->accept(*this);
+        iterate(nodep);
     }
 };
 
@@ -279,13 +279,13 @@ void EmitCSyms::emitSymHdr() {
 
     // for
     puts("\n// INCLUDE MODULE CLASSES\n");
-    for (AstNodeModule* nodep = v3Global.rootp()->modulesp(); nodep; nodep=nodep->nextp()->castNodeModule()) {
+    for (AstNodeModule* nodep = v3Global.rootp()->modulesp(); nodep; nodep=VN_CAST(nodep->nextp(), NodeModule)) {
 	puts("#include \""+modClassName(nodep)+".h\"\n");
     }
 
     if (v3Global.dpi()) {
-	puts ("\n// DPI TYPES for DPI Export callbacks (Internal use)\n");
-	map<string,int> types;  // Remove duplicates and sort
+        puts("\n// DPI TYPES for DPI Export callbacks (Internal use)\n");
+        std::map<string,int> types;  // Remove duplicates and sort
 	for (ScopeFuncs::iterator it = m_scopeFuncs.begin(); it != m_scopeFuncs.end(); ++it) {
 	    AstCFunc* funcp = it->second.m_funcp;
 	    if (funcp->dpiExport()) {
@@ -293,7 +293,7 @@ void EmitCSyms::emitSymHdr() {
 		types["typedef void (*"+cbtype+") ("+cFuncArgs(funcp)+");\n"] = 1;
 	    }
 	}
-	for (map<string,int>::iterator it = types.begin(); it != types.end(); ++it) {
+        for (std::map<string,int>::iterator it = types.begin(); it != types.end(); ++it) {
 	    puts(it->first);
 	}
     }
@@ -310,7 +310,7 @@ void EmitCSyms::emitSymHdr() {
     puts("bool __Vm_didInit;\n");
 
     puts("\n// SUBCELL STATE\n");
-    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
+    for (std::vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
 	if (modp->isTop()) {
 	    ofp()->printf("%-30s ", (modClassName(modp)+"*").c_str());
@@ -370,7 +370,7 @@ void EmitCSyms::emitSymImp() {
 
     // Includes
     puts("#include \""+symClassName()+".h\"\n");
-    for (AstNodeModule* nodep = v3Global.rootp()->modulesp(); nodep; nodep=nodep->nextp()->castNodeModule()) {
+    for (AstNodeModule* nodep = v3Global.rootp()->modulesp(); nodep; nodep=VN_CAST(nodep->nextp(), NodeModule)) {
 	puts("#include \""+modClassName(nodep)+".h\"\n");
     }
 
@@ -386,7 +386,7 @@ void EmitCSyms::emitSymImp() {
     puts("\t, __Vm_didInit(false)\n");
     puts("\t// Setup submodule names\n");
     char comma=',';
-    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
+    for (std::vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
 	if (modp->isTop()) {
 	} else {
@@ -404,7 +404,7 @@ void EmitCSyms::emitSymImp() {
     puts("// Pointer to top level\n");
     puts("TOPp = topp;\n");
     puts("// Setup each module's pointers to their submodules\n");
-    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
+    for (std::vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
 	if (!modp->isTop()) {
 	    string arrow = scopep->name();
@@ -421,7 +421,7 @@ void EmitCSyms::emitSymImp() {
 
     puts("// Setup each module's pointer back to symbol table (for public functions)\n");
     puts("TOPp->__Vconfigure(this, true);\n");
-    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
+    for (std::vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
 	if (!modp->isTop()) {
 	    // first is used by AstCoverDecl's call to __vlCoverInsert
@@ -482,10 +482,10 @@ void EmitCSyms::emitSymImp() {
 		}
 		for (AstNodeDType* dtypep=varp->dtypep(); dtypep; ) {
 		    dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-		    if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
+                    if (const AstNodeArrayDType* adtypep = VN_CAST(dtypep, NodeArrayDType)) {
 			bounds += " ,"; bounds += cvtToStr(adtypep->msb());
 			bounds += ","; bounds += cvtToStr(adtypep->lsb());
-			if (dtypep->castPackArrayDType()) pdim++; else udim++;
+                        if (VN_IS(dtypep, PackArrayDType)) pdim++; else udim++;
 			dtypep = adtypep->subDTypep();
 		    }
 		    else break; // AstBasicDType - nothing below, 1
@@ -534,7 +534,7 @@ void EmitCSyms::emitSymImp() {
 	    }
 	    puts(   "os"+op+"__Vm_didInit;\n");
 	    puts(   "// SUBCELL STATE\n");
-	    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
+            for (std::vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 		AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
 		if (!modp->isTop()) {
 		    puts(   scopep->nameDotless()+"."+funcname+"(os);\n");
@@ -571,7 +571,7 @@ void EmitCSyms::emitDpiHdr() {
 
     int firstExp = 0;
     int firstImp = 0;
-    for (vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
+    for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
 	AstCFunc* nodep = *it;
 	if (nodep->dpiExportWrapper()) {
 	    if (!firstExp++) puts("\n// DPI EXPORTS\n");
@@ -619,7 +619,7 @@ void EmitCSyms::emitDpiImp() {
     puts("#include \""+topClassName()+".h\"\n");
     puts("\n");
 
-    for (vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
+    for (std::vector<AstCFunc*>::iterator it = m_dpis.begin(); it != m_dpis.end(); ++it) {
 	AstCFunc* nodep = *it;
 	if (nodep->dpiExportWrapper()) {
 	    puts("#ifndef _VL_DPIDECL_"+nodep->name()+"\n");
@@ -629,7 +629,7 @@ void EmitCSyms::emitDpiImp() {
 	    puts("return "+topClassName()+"::"+nodep->name()+"(");
 	    string args;
 	    for (AstNode* stmtp = nodep->argsp(); stmtp; stmtp=stmtp->nextp()) {
-		if (AstVar* portp = stmtp->castVar()) {
+                if (const AstVar* portp = VN_CAST(stmtp, Var)) {
 		    if (portp->isIO() && !portp->isFuncReturn()) {
 			if (args != "") args+= ", ";
 			args += portp->name();

src/V3EmitMk.cpp

@@ -40,11 +40,7 @@ class EmitMkVisitor : public EmitCBaseVisitor {
 public:
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     void putMakeClassEntry(V3OutMkFile& of, const string& name) {
 	of.puts("\t"+V3Os::filenameNonDirExt(name)+" \\\n");
@@ -93,16 +89,23 @@ public:
 			putMakeClassEntry(of, "verilated_cov.cpp");
 		    }
 		    if (v3Global.opt.trace()) {
-			putMakeClassEntry(of, "verilated_vcd_c.cpp");
+                        putMakeClassEntry(of, v3Global.opt.traceSourceName()+"_c.cpp");
 			if (v3Global.opt.systemC()) {
-			    putMakeClassEntry(of, "verilated_vcd_sc.cpp");
+                            if (v3Global.opt.traceFormat() != TraceFormat::VCD) {
+                                v3error("Unsupported: This trace format is not supported in SystemC, use VCD format.");
+                            } else {
+                                putMakeClassEntry(of, v3Global.opt.traceSourceName()+"_sc.cpp");
+                            }
 			}
 		    }
+                    if (v3Global.opt.mtasks()) {
+                        putMakeClassEntry(of, "verilated_threads.cpp");
+                    }
 		}
 		else if (support==2 && slow) {
 		}
 		else {
-		    for (AstCFile* nodep = v3Global.rootp()->filesp(); nodep; nodep=nodep->nextp()->castCFile()) {
+                    for (AstCFile* nodep = v3Global.rootp()->filesp(); nodep; nodep=VN_CAST(nodep->nextp(), CFile)) {
 			if (nodep->source() && nodep->slow()==(slow!=0) && nodep->support()==(support!=0)) {
 			    putMakeClassEntry(of, nodep->name());
 			}
@@ -206,7 +209,7 @@ public:
 		string cppfile = *it;
 		string basename = V3Os::filenameNonExt(cppfile);
 		of.puts(basename+".o: "+cppfile+"\n");
-		of.puts("\t$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<\n");
+		of.puts("\t$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<\n");
 	    }
 
 	    of.puts("\n### Link rules... (from --exe)\n");

src/V3EmitV.cpp

@@ -41,11 +41,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     AstSenTree*	m_sensesp;
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     virtual void puts(const string& str) = 0;
     virtual void putbs(const string& str) = 0;
@@ -63,11 +59,11 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 
     // VISITORS
     virtual void visit(AstNetlist* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNodeModule* nodep) {
 	putfs(nodep, nodep->verilogKwd()+" "+modClassName(nodep)+";\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	putqs(nodep, "end"+nodep->verilogKwd()+"\n");
     }
     virtual void visit(AstNodeFTask* nodep) {
@@ -76,7 +72,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	puts(nodep->prettyName());
 	puts(";\n");
 	putqs(nodep, "begin\n");  // Only putfs the first time for each visitor; later for same node is putqs
-	nodep->stmtsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->stmtsp());
 	putqs(nodep, "end\n");
     }
 
@@ -86,64 +82,64 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	} else {
 	    putbs("begin : "+nodep->name()+"\n");
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	puts("end\n");
     }
     virtual void visit(AstGenerate* nodep) {
 	putfs(nodep, "generate\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	putqs(nodep, "end\n");
     }
     virtual void visit(AstFinal* nodep) {
 	putfs(nodep, "final begin\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	putqs(nodep, "end\n");
     }
     virtual void visit(AstInitial* nodep) {
 	putfs(nodep,"initial begin\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	putqs(nodep, "end\n");
     }
     virtual void visit(AstAlways* nodep) {
 	putfs(nodep,"always ");
-	if (m_sensesp) m_sensesp->iterateAndNext(*this);  // In active
-	else nodep->sensesp()->iterateAndNext(*this);
+        if (m_sensesp) iterateAndNextNull(m_sensesp);  // In active
+        else iterateAndNextNull(nodep->sensesp());
 	putbs(" begin\n");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	putqs(nodep,"end\n");
     }
     virtual void visit(AstAlwaysPublic* nodep) {
 	putfs(nodep,"/*verilator public_flat_rw ");
-	if (m_sensesp) m_sensesp->iterateAndNext(*this);  // In active
-	else nodep->sensesp()->iterateAndNext(*this);
+        if (m_sensesp) iterateAndNextNull(m_sensesp);  // In active
+        else iterateAndNextNull(nodep->sensesp());
 	putqs(nodep," ");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	putqs(nodep,"*/\n");
     }
     virtual void visit(AstNodeAssign* nodep) {
-	nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
 	putfs(nodep," "+nodep->verilogKwd()+" ");
-	nodep->rhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->rhsp());
 	if (!m_suppressSemi) puts(";\n");
     }
     virtual void visit(AstAssignDly* nodep) {
-	nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
 	putfs(nodep," <= ");
-	nodep->rhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->rhsp());
 	puts(";\n");
     }
     virtual void visit(AstAssignAlias* nodep) {
 	putbs("alias ");
-	nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
 	putfs(nodep," = ");
-	nodep->rhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->rhsp());
 	if (!m_suppressSemi) puts(";\n");
     }
     virtual void visit(AstAssignW* nodep) {
 	putfs(nodep,"assign ");
-	nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
 	putbs(" = ");
-	nodep->rhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->rhsp());
 	if (!m_suppressSemi) puts(";\n");
     }
     virtual void visit(AstBreak* nodep) {
@@ -154,7 +150,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	// AstSenItem is called for dumping in isolation by V3Order
 	putfs(nodep,"@(");
 	for (AstNode* expp=nodep->sensesp(); expp; expp = expp->nextp()) {
-	    expp->accept(*this);
+            iterate(expp);
 	    if (expp->nextp()) putqs(expp->nextp()," or ");
 	}
 	puts(")");
@@ -166,40 +162,40 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	putfs(nodep,"");
 	puts(nodep->edgeType().verilogKwd());
 	if (nodep->sensp()) puts(" ");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstNodeCase* nodep) {
 	putfs(nodep,"");
-	if (AstCase* casep = nodep->castCase()) {
+        if (const AstCase* casep = VN_CAST(nodep, Case)) {
 	    if (casep->priorityPragma()) puts("priority ");
 	    if (casep->uniquePragma()) puts("unique ");
 	    if (casep->unique0Pragma()) puts("unique0 ");
 	}
 	puts(nodep->verilogKwd());
 	puts(" (");
-	nodep->exprp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->exprp());
 	puts(")\n");
-	if (AstCase* casep = nodep->castCase()) {
+        if (const AstCase* casep = VN_CAST(nodep, Case)) {
 	    if (casep->fullPragma() || casep->parallelPragma()) {
 		puts(" // synopsys");
 		if (casep->fullPragma()) puts(" full_case");
 		if (casep->parallelPragma()) puts(" parallel_case");
 	    }
 	}
-	nodep->itemsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->itemsp());
 	putqs(nodep,"endcase\n");
     }
     virtual void visit(AstCaseItem* nodep) {
 	if (nodep->condsp()) {
-	    nodep->condsp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->condsp());
 	} else putbs("default");
 	putfs(nodep,": begin ");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	putqs(nodep,"end\n");
     }
     virtual void visit(AstComment* nodep) {
 	puts((string)"// "+nodep->name()+"\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstContinue* nodep) {
 	putbs("continue");
@@ -212,11 +208,11 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     void visitNodeDisplay(AstNode* nodep, AstNode* fileOrStrgp, const string& text, AstNode* exprsp) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	if (fileOrStrgp) { fileOrStrgp->iterateAndNext(*this); putbs(","); }
+        if (fileOrStrgp) { iterateAndNextNull(fileOrStrgp); putbs(","); }
 	putsQuoted(text);
 	for (AstNode* expp=exprsp; expp; expp = expp->nextp()) {
 	    puts(",");
-	    expp->iterateAndNext(*this);
+            iterateAndNextNull(expp);
 	}
 	puts(");\n");
     }
@@ -241,23 +237,23 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     virtual void visit(AstFOpen* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
+        if (nodep->filep()) iterateAndNextNull(nodep->filep());
 	putbs(",");
-	if (nodep->filenamep()) nodep->filenamep()->iterateAndNext(*this);
+        if (nodep->filenamep()) iterateAndNextNull(nodep->filenamep());
 	putbs(",");
-	if (nodep->modep()) nodep->modep()->iterateAndNext(*this);
+        if (nodep->modep()) iterateAndNextNull(nodep->modep());
 	puts(");\n");
     }
     virtual void visit(AstFClose* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
+        if (nodep->filep()) iterateAndNextNull(nodep->filep());
 	puts(");\n");
     }
     virtual void visit(AstFFlush* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	if (nodep->filep()) nodep->filep()->iterateAndNext(*this);
+        if (nodep->filep()) iterateAndNextNull(nodep->filep());
 	puts(");\n");
     }
     virtual void visit(AstJumpGo* nodep) {
@@ -265,80 +261,80 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     }
     virtual void visit(AstJumpLabel* nodep) {
 	putbs("begin : "+cvtToStr((void*)(nodep))+"\n");
-	if (nodep->stmtsp()) nodep->stmtsp()->iterateAndNext(*this);
+        if (nodep->stmtsp()) iterateAndNextNull(nodep->stmtsp());
 	puts("end\n");
     }
     virtual void visit(AstNodeReadWriteMem* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	if (nodep->filenamep()) nodep->filenamep()->iterateAndNext(*this);
+        if (nodep->filenamep()) iterateAndNextNull(nodep->filenamep());
 	putbs(",");
-	if (nodep->memp()) nodep->memp()->iterateAndNext(*this);
-	if (nodep->lsbp()) { putbs(","); nodep->lsbp()->iterateAndNext(*this); }
-	if (nodep->msbp()) { putbs(","); nodep->msbp()->iterateAndNext(*this); }
+        if (nodep->memp()) iterateAndNextNull(nodep->memp());
+        if (nodep->lsbp()) { putbs(","); iterateAndNextNull(nodep->lsbp()); }
+        if (nodep->msbp()) { putbs(","); iterateAndNextNull(nodep->msbp()); }
 	puts(");\n");
     }
     virtual void visit(AstSysFuncAsTask* nodep) {
-        nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
         puts(";\n");
     }
     virtual void visit(AstSysIgnore* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
-	nodep->exprsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->exprsp());
 	puts(");\n");
     }
     virtual void visit(AstNodeFor* nodep) {
 	putfs(nodep,"for (");
 	m_suppressSemi = true;
-	nodep->initsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->initsp());
 	puts(";");
-	nodep->condp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->condp());
 	puts(";");
-	nodep->incsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->incsp());
 	m_suppressSemi = false;
 	puts(") begin\n");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	putqs(nodep,"end\n");
     }
     virtual void visit(AstRepeat* nodep) {
 	putfs(nodep,"repeat (");
-	nodep->countp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->countp());
 	puts(") begin\n");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	putfs(nodep,"end\n");
     }
     virtual void visit(AstWhile* nodep) {
-	nodep->precondsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->precondsp());
 	putfs(nodep,"while (");
-	nodep->condp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->condp());
 	puts(") begin\n");
-	nodep->bodysp()->iterateAndNext(*this);
-	nodep->incsp()->iterateAndNext(*this);
-	nodep->precondsp()->iterateAndNext(*this);  // Need to recompute before next loop
+        iterateAndNextNull(nodep->bodysp());
+        iterateAndNextNull(nodep->incsp());
+        iterateAndNextNull(nodep->precondsp());  // Need to recompute before next loop
 	putfs(nodep,"end\n");
     }
     virtual void visit(AstNodeIf* nodep) {
 	putfs(nodep,"");
-	if (AstIf* ifp = nodep->castIf()) {
+        if (const AstIf* ifp = VN_CAST(nodep, If)) {
 	    if (ifp->priorityPragma()) puts("priority ");
 	    if (ifp->uniquePragma()) puts("unique ");
 	    if (ifp->unique0Pragma()) puts("unique0 ");
 	}
 	puts("if (");
-	nodep->condp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->condp());
 	puts(") begin\n");
-	nodep->ifsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->ifsp());
 	if (nodep->elsesp()) {
 	    putqs(nodep,"end\n");
 	    putqs(nodep,"else begin\n");
-	    nodep->elsesp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->elsesp());
 	}
 	putqs(nodep,"end\n");
     }
     virtual void visit(AstReturn* nodep) {
 	putfs(nodep,"return ");
-	nodep->lhsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->lhsp());
 	puts(";\n");
     }
     virtual void visit(AstStop* nodep) {
@@ -354,22 +350,22 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     }
     virtual void visit(AstCStmt* nodep) {
 	putfs(nodep,"$_CSTMT(");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	puts(");\n");
     }
     virtual void visit(AstCMath* nodep) {
 	putfs(nodep,"$_CMATH(");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	puts(");\n");
     }
     virtual void visit(AstUCStmt* nodep) {
 	putfs(nodep,"$c(");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	puts(");\n");
     }
     virtual void visit(AstUCFunc* nodep) {
 	putfs(nodep,"$c(");
-	nodep->bodysp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->bodysp());
 	puts(")");
     }
 
@@ -399,22 +395,22 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 		case 'k': putbs("");  break;
 		case 'l': {
 		    if (!lhsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
-		    else lhsp->iterateAndNext(*this);
+                    else iterateAndNextNull(lhsp);
 		    break;
 		}
 		case 'r': {
 		    if (!rhsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
-		    else rhsp->iterateAndNext(*this);
+                    else iterateAndNextNull(rhsp);
 		    break;
 		}
 		case 't': {
 		    if (!thsp) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
-		    else thsp->iterateAndNext(*this);
+                    else iterateAndNextNull(thsp);
 		    break;
 		}
 		case 'd': {
 		    if (!nodep->dtypep()) { nodep->v3fatalSrc("emitVerilog() references undef node"); }
-		    else nodep->dtypep()->iterateAndNext(*this);
+                    else iterateAndNextNull(nodep->dtypep());
 		    break;
 		}
 		default:
@@ -439,10 +435,10 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     }
     virtual void visit(AstAttrOf* nodep) {
 	putfs(nodep,"$_ATTROF(");
-	nodep->fromp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->fromp());
 	if (nodep->dimp()) {
 	    putbs(",");
-	    nodep->dimp()->iterateAndNext(*this);
+            iterateAndNextNull(nodep->dimp());
 	}
 	puts(")");
     }
@@ -453,83 +449,83 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	    int index = nodep->posIndex(pos);
 	    puts(cvtToStr(index));
 	    puts(":");
-	    itemp->accept(*this);
+            iterate(itemp);
 	    if (itemp->nextp()) putbs(",");
 	}
 	puts("}");
     }
     virtual void visit(AstNodeCond* nodep) {
 	putbs("(");
-	nodep->condp()->iterateAndNext(*this); putfs(nodep," ? ");
-	nodep->expr1p()->iterateAndNext(*this); putbs(" : ");
-	nodep->expr2p()->iterateAndNext(*this); puts(")");
+        iterateAndNextNull(nodep->condp()); putfs(nodep," ? ");
+        iterateAndNextNull(nodep->expr1p()); putbs(" : ");
+        iterateAndNextNull(nodep->expr2p()); puts(")");
     }
     virtual void visit(AstRange* nodep) {
 	puts("[");
-	if (nodep->msbp()->castConst() && nodep->lsbp()->castConst()) {
+        if (VN_IS(nodep->msbp(), Const) && VN_IS(nodep->lsbp(), Const)) {
 	    // Looks nicer if we print [1:0] rather than [32'sh1:32sh0]
-	    puts(cvtToStr(nodep->leftp()->castConst()->toSInt())); puts(":");
-	    puts(cvtToStr(nodep->rightp()->castConst()->toSInt())); puts("]");
+            puts(cvtToStr(VN_CAST(nodep->leftp(), Const)->toSInt())); puts(":");
+            puts(cvtToStr(VN_CAST(nodep->rightp(), Const)->toSInt())); puts("]");
 	} else {
-	    nodep->leftp()->iterateAndNext(*this); puts(":");
-	    nodep->rightp()->iterateAndNext(*this); puts("]");
+            iterateAndNextNull(nodep->leftp()); puts(":");
+            iterateAndNextNull(nodep->rightp()); puts("]");
 	}
     }
     virtual void visit(AstSel* nodep) {
-	nodep->fromp()->iterateAndNext(*this); puts("[");
-	if (nodep->lsbp()->castConst()) {
+        iterateAndNextNull(nodep->fromp()); puts("[");
+        if (VN_IS(nodep->lsbp(), Const)) {
 	    if (nodep->widthp()->isOne()) {
-		if (nodep->lsbp()->castConst()) {
-		    puts(cvtToStr(nodep->lsbp()->castConst()->toSInt()));
+                if (VN_IS(nodep->lsbp(), Const)) {
+                    puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()));
 		} else {
-		    nodep->lsbp()->iterateAndNext(*this);
+                    iterateAndNextNull(nodep->lsbp());
 		}
 	    } else {
-		puts(cvtToStr(nodep->lsbp()->castConst()->toSInt()
-			      +nodep->widthp()->castConst()->toSInt()
-			      -1));
+                puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()
+                              + VN_CAST(nodep->widthp(), Const)->toSInt()
+                              - 1));
 		puts(":");
-		puts(cvtToStr(nodep->lsbp()->castConst()->toSInt()));
+                puts(cvtToStr(VN_CAST(nodep->lsbp(), Const)->toSInt()));
 	    }
 	} else {
-	    nodep->lsbp()->iterateAndNext(*this); putfs(nodep,"+:");
-	    nodep->widthp()->iterateAndNext(*this); puts("]");
+            iterateAndNextNull(nodep->lsbp()); putfs(nodep,"+:");
+            iterateAndNextNull(nodep->widthp()); puts("]");
 	}
 	puts("]");
     }
     virtual void visit(AstSliceSel* nodep) {
-        nodep->fromp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->fromp());
         puts(cvtToStr(nodep->declRange()));
     }
     virtual void visit(AstTypedef* nodep) {
 	putfs(nodep,"typedef ");
-	nodep->dtypep()->iterateAndNext(*this); puts(" ");
+        iterateAndNextNull(nodep->dtypep()); puts(" ");
 	puts(nodep->prettyName());
 	puts(";\n");
     }
     virtual void visit(AstBasicDType* nodep) {
 	if (nodep->isSigned()) putfs(nodep,"signed ");
 	putfs(nodep,nodep->prettyName());
-	if (nodep->rangep()) { puts(" "); nodep->rangep()->iterateAndNext(*this); puts(" "); }
+        if (nodep->rangep()) { puts(" "); iterateAndNextNull(nodep->rangep()); puts(" "); }
 	else if (nodep->isRanged()) { puts(" ["); puts(cvtToStr(nodep->msb())); puts(":0] "); }
     }
     virtual void visit(AstConstDType* nodep) {
 	putfs(nodep,"const ");
-	nodep->subDTypep()->accept(*this);
+        iterate(nodep->subDTypep());
     }
     virtual void visit(AstNodeArrayDType* nodep) {
-	nodep->subDTypep()->accept(*this);
-	nodep->rangep()->iterateAndNext(*this);
+        iterate(nodep->subDTypep());
+        iterateAndNextNull(nodep->rangep());
     }
     virtual void visit(AstNodeClassDType* nodep) {
 	puts(nodep->verilogKwd()+" ");
 	if (nodep->packed()) puts("packed ");
 	puts("\n");
-	nodep->membersp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->membersp());
 	puts("}");
     }
     virtual void visit(AstMemberDType* nodep) {
-	nodep->subDTypep()->accept(*this);
+        iterate(nodep->subDTypep());
 	puts(" ");
 	puts(nodep->name());
 	puts("}");
@@ -538,11 +534,11 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	if (nodep->dotted()!="") { putfs(nodep,nodep->dotted()); puts("."); puts(nodep->prettyName()); }
 	else { putfs(nodep,nodep->prettyName()); }
 	puts("(");
-	nodep->pinsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->pinsp());
 	puts(")");
     }
     virtual void visit(AstArg* nodep) {
-	nodep->exprp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->exprp());
     }
     // Terminals
     virtual void visit(AstVarRef* nodep) {
@@ -564,21 +560,21 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 
     // Just iterate
     virtual void visit(AstTopScope* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstScope* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstVar* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	puts(" ");
-	nodep->dtypep()->iterate(*this); puts(" ");
+        iterate(nodep->dtypep()); puts(" ");
 	puts(nodep->prettyName());
 	puts(";\n");
     }
     virtual void visit(AstActive* nodep) {
 	m_sensesp = nodep->sensesp();
-	nodep->stmtsp()->iterateAndNext(*this);
+        iterateAndNextNull(nodep->stmtsp());
 	m_sensesp = NULL;
     }
     virtual void visit(AstVarScope*) {}
@@ -591,7 +587,7 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
     // Default
     virtual void visit(AstNode* nodep) {
 	puts((string)"\n???? // "+nodep->prettyTypeName()+"\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// Not v3fatalSrc so we keep processing
 	nodep->v3error("Internal: Unknown node type reached emitter: "<<nodep->prettyTypeName());
     }
@@ -620,7 +616,7 @@ class EmitVFileVisitor : public EmitVBaseVisitor {
 public:
     EmitVFileVisitor(AstNode* nodep, V3OutFile* ofp) {
 	m_ofp = ofp;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~EmitVFileVisitor() {}
 };
@@ -630,7 +626,7 @@ public:
 
 class EmitVStreamVisitor : public EmitVBaseVisitor {
     // MEMBERS
-    ostream&	m_os;
+    std::ostream&       m_os;
     // METHODS
     virtual void putsNoTracking(const string& str) { m_os<<str; }
     virtual void puts(const string& str) { putsNoTracking(str); }
@@ -638,9 +634,9 @@ class EmitVStreamVisitor : public EmitVBaseVisitor {
     virtual void putfs(AstNode*, const string& str) { putbs(str); }
     virtual void putqs(AstNode*, const string& str) { putbs(str); }
 public:
-    EmitVStreamVisitor(AstNode* nodep, ostream& os)
+    EmitVStreamVisitor(AstNode* nodep, std::ostream& os)
 	: m_os(os) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~EmitVStreamVisitor() {}
 };
@@ -649,7 +645,7 @@ public:
 // Emit to a stream (perhaps stringstream)
 
 class EmitVPrefixedFormatter : public V3OutFormatter {
-    ostream&	m_os;
+    std::ostream&       m_os;
     string	m_prefix;	// What to print at beginning of each line
     int		m_flWidth;	// Padding of fileline
     int		m_column;	// Rough location; need just zero or non-zero
@@ -675,7 +671,7 @@ public:
     void prefixFl(FileLine* fl) { m_prefixFl = fl; }
     FileLine* prefixFl() const { return m_prefixFl; }
     int column() const { return m_column; }
-    EmitVPrefixedFormatter(ostream& os, const string& prefix, int flWidth)
+    EmitVPrefixedFormatter(std::ostream& os, const string& prefix, int flWidth)
 	: V3OutFormatter("__STREAM", V3OutFormatter::LA_VERILOG)
 	, m_os(os), m_prefix(prefix), m_flWidth(flWidth) {
 	m_column = 0;
@@ -707,11 +703,11 @@ class EmitVPrefixedVisitor : public EmitVBaseVisitor {
     }
 
 public:
-    EmitVPrefixedVisitor(AstNode* nodep, ostream& os, const string& prefix, int flWidth,
+    EmitVPrefixedVisitor(AstNode* nodep, std::ostream& os, const string& prefix, int flWidth,
 			 AstSenTree* domainp, bool user3mark)
 	: EmitVBaseVisitor(domainp), m_formatter(os, prefix, flWidth) {
 	if (user3mark) { AstUser3InUse::check(); }
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~EmitVPrefixedVisitor() {}
 };
@@ -729,7 +725,7 @@ void V3EmitV::emitv() {
 	EmitVFileVisitor visitor (v3Global.rootp(), &of);
     } else {
 	// Process each module in turn
-	for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castNodeModule()) {
+        for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=VN_CAST(modp->nextp(), NodeModule)) {
 	    V3OutVFile of (v3Global.opt.makeDir()
 			   +"/"+EmitCBaseVisitor::modClassName(modp)+"__Vout.v");
 	    of.putsHeader();
@@ -738,11 +734,11 @@ void V3EmitV::emitv() {
     }
 }
 
-void V3EmitV::verilogForTree(AstNode* nodep, ostream& os) {
+void V3EmitV::verilogForTree(AstNode* nodep, std::ostream& os) {
     EmitVStreamVisitor(nodep, os);
 }
 
-void V3EmitV::verilogPrefixedTree(AstNode* nodep, ostream& os, const string& prefix, int flWidth,
+void V3EmitV::verilogPrefixedTree(AstNode* nodep, std::ostream& os, const string& prefix, int flWidth,
 				  AstSenTree* domainp, bool user3mark) {
     EmitVPrefixedVisitor(nodep, os, prefix, flWidth, domainp, user3mark);
 }

src/V3EmitV.h

@@ -30,8 +30,8 @@
 class V3EmitV {
 public:
     static void emitv();
-    static void verilogForTree(AstNode* nodep, ostream& os=cout);
-    static void verilogPrefixedTree(AstNode* nodep, ostream& os, const string& prefix, int flWidth,
+    static void verilogForTree(AstNode* nodep, std::ostream& os=std::cout);
+    static void verilogPrefixedTree(AstNode* nodep, std::ostream& os, const string& prefix, int flWidth,
 				    AstSenTree* domainp, bool user3percent);
 };
 

src/V3EmitXml.cpp

@@ -46,11 +46,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
     uint64_t	m_id;
 
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     // Outfile methods
     V3OutFile*	ofp() const { return m_ofp; }
@@ -76,10 +72,10 @@ class EmitXmlFileVisitor : public AstNVisitor {
     void outputTag(AstNode* nodep, string tag) {
 	if (tag=="") tag = VString::downcase(nodep->typeName());
 	puts("<"+tag+" "+nodep->fileline()->xml());
-	if (nodep->castNodeDType()) { puts(" id="); outputId(nodep); }
+        if (VN_IS(nodep, NodeDType)) { puts(" id="); outputId(nodep); }
 	if (nodep->name()!="") { puts(" name="); putsQuoted(nodep->prettyName()); }
 	if (nodep->tag()!="") { puts(" tag="); putsQuoted(nodep->tag()); }
-	if (AstNodeDType* dtp = nodep->castNodeDType()) {
+        if (AstNodeDType* dtp = VN_CAST(nodep, NodeDType)) {
 	    if (dtp->subDTypep()) { puts(" sub_dtype_id="); outputId(dtp->subDTypep()->skipRefp()); }
 	} else {
 	    if (nodep->dtypep()) { puts(" dtype_id="); outputId(nodep->dtypep()->skipRefp()); }
@@ -89,7 +85,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
 	if (tag=="") tag = VString::downcase(nodep->typeName());
 	if (nodep->op1p() || nodep->op2p() || nodep->op3p() || nodep->op4p()) {
 	    puts(">\n");
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	    puts("</"+tag+">\n");
 	} else {
 	    puts("/>\n");
@@ -108,7 +104,7 @@ class EmitXmlFileVisitor : public AstNVisitor {
     }
     virtual void visit(AstNetlist* nodep) {
 	puts("<netlist>\n");
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	puts("</netlist>\n");
     }
     virtual void visit(AstNodeModule* nodep) {
@@ -154,7 +150,7 @@ public:
     EmitXmlFileVisitor(AstNode* nodep, V3OutFile* ofp) {
 	m_ofp = ofp;
 	m_id = 0;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~EmitXmlFileVisitor() {}
 };

src/V3Error.cpp

@@ -38,7 +38,7 @@ int V3Error::s_debugDefault = 0;
 int V3Error::s_errorLimit = V3Error::MAX_ERRORS;
 bool V3Error::s_warnFatal = true;
 int V3Error::s_tellManual = 0;
-ostringstream V3Error::s_errorStr;		// Error string being formed
+std::ostringstream V3Error::s_errorStr;  // Error string being formed
 V3ErrorCode V3Error::s_errorCode = V3ErrorCode::EC_FATAL;
 bool V3Error::s_errorSuppressed = false;
 bool V3Error::s_describedEachWarn[V3ErrorCode::_ENUM_MAX];
@@ -80,11 +80,11 @@ void V3Error::init() {
     }
 }
 
-string V3Error::lineStr (const char* filename, int lineno) {
-    ostringstream out;
-    const char* fnslashp = strrchr (filename, '/');
+string V3Error::lineStr(const char* filename, int lineno) {
+    std::ostringstream out;
+    const char* fnslashp = strrchr(filename, '/');
     if (fnslashp) filename = fnslashp+1;
-    out<<filename<<":"<<dec<<lineno<<":";
+    out<<filename<<":"<<std::dec<<lineno<<":";
     const char* const spaces = "                    ";
     size_t numsp = out.str().length(); if (numsp>20) numsp = 20;
     out<<(spaces + numsp);
@@ -94,18 +94,18 @@ string V3Error::lineStr (const char* filename, int lineno) {
 void V3Error::incErrors() {
     s_errCount++;
     if (errorCount() == errorLimit()) {  // Not >= as would otherwise recurse
-	v3fatal ("Exiting due to too many errors encountered; --error-limit="<<errorCount()<<endl);
+        v3fatal("Exiting due to too many errors encountered; --error-limit="<<errorCount()<<endl);
     }
 }
 
 void V3Error::abortIfWarnings() {
     bool exwarn = warnFatal() && warnCount();
     if (errorCount() && exwarn) {
-	v3fatal ("Exiting due to "<<dec<<errorCount()<<" error(s), "<<warnCount()<<" warning(s)\n");
+        v3fatal("Exiting due to "<<std::dec<<errorCount()<<" error(s), "<<warnCount()<<" warning(s)\n");
     } else if (errorCount()) {
-	v3fatal ("Exiting due to "<<dec<<errorCount()<<" error(s)\n");
+        v3fatal("Exiting due to "<<std::dec<<errorCount()<<" error(s)\n");
     } else if (exwarn) {
-	v3fatal ("Exiting due to "<<dec<<warnCount()<<" warning(s)\n");
+        v3fatal("Exiting due to "<<std::dec<<warnCount()<<" warning(s)\n");
     }
 }
 
@@ -137,9 +137,9 @@ string V3Error::msgPrefix() {
 //======================================================================
 // Abort/exit
 
-void V3Error::vlAbort () {
+void V3Error::vlAbort() {
     if (V3Error::debugDefault()) {
-	cerr<<msgPrefix()<<"Aborting since under --debug"<<endl;
+        std::cerr<<msgPrefix()<<"Aborting since under --debug"<<endl;
 	abort();
     } else {
 	exit(10);
@@ -162,7 +162,7 @@ string V3Error::warnMore() {
     return msgPrefix();
 }
 
-void V3Error::v3errorEnd (ostringstream& sstr) {
+void V3Error::v3errorEnd(std::ostringstream& sstr) {
 #if defined(__COVERITY__) || defined(__cppcheck__)
     if (s_errorCode==V3ErrorCode::EC_FATAL) __coverity_panic__(x);
 #endif
@@ -176,20 +176,20 @@ void V3Error::v3errorEnd (ostringstream& sstr) {
     if (s_messages.find(msg) != s_messages.end()) return;
     s_messages.insert(msg);
     // Output
-    cerr<<msg;
+    std::cerr<<msg;
     if (!s_errorSuppressed && !(s_errorCode==V3ErrorCode::EC_INFO
 				|| s_errorCode==V3ErrorCode::USERINFO)) {
 	if (!s_describedEachWarn[s_errorCode]
 	    && !s_pretendError[s_errorCode]) {
 	    s_describedEachWarn[s_errorCode] = true;
 	    if (s_errorCode>=V3ErrorCode::EC_FIRST_WARN && !s_describedWarnings) {
-		cerr<<msgPrefix()<<"Use \"/* verilator lint_off "<<s_errorCode.ascii()
-		    <<" */\" and lint_on around source to disable this message."<<endl;
+                std::cerr<<msgPrefix()<<"Use \"/* verilator lint_off "<<s_errorCode.ascii()
+                         <<" */\" and lint_on around source to disable this message."<<endl;
 		s_describedWarnings = true;
 	    }
 	    if (s_errorCode.dangerous()) {
-		cerr<<msgPrefix()<<"*** See the manual before disabling this,"<<endl;
-		cerr<<msgPrefix()<<"else you may end up with different sim results."<<endl;
+                std::cerr<<msgPrefix()<<"*** See the manual before disabling this,"<<endl;
+                std::cerr<<msgPrefix()<<"else you may end up with different sim results."<<endl;
 	    }
 	}
 	// If first warning is not the user's fault (internal/unsupported) then give the website
@@ -210,7 +210,7 @@ void V3Error::v3errorEnd (ostringstream& sstr) {
 	    if (!inFatal) {
 		inFatal = true;
 		if (s_tellManual==1) {
-		    cerr<<msgPrefix()<<"See the manual and http://www.veripool.org/verilator for more assistance."<<endl;
+                    std::cerr<<msgPrefix()<<"See the manual and http://www.veripool.org/verilator for more assistance."<<endl;
 		    s_tellManual = 2;
 		}
 #ifndef _V3ERROR_NO_GLOBAL_

src/V3Error.h

@@ -97,6 +97,7 @@ public:
 	UNDRIVEN,	// No drivers
 	UNOPT,		// Unoptimizable block
 	UNOPTFLAT,	// Unoptimizable block after flattening
+        UNOPTTHREADS,   // Thread partitioner unable to fill all requested threads
 	UNPACKED,	// Unsupported unpacked
 	UNSIGNED,	// Comparison is constant due to unsigned arithmetic
 	UNUSED,		// No receivers
@@ -111,12 +112,12 @@ public:
 	// ***Add new elements below also***
     };
     enum en m_e;
-    inline V3ErrorCode () : m_e(EC_MIN) {}
+    inline V3ErrorCode() : m_e(EC_MIN) {}
     // cppcheck-suppress noExplicitConstructor
-    inline V3ErrorCode (en _e) : m_e(_e) {}
-    explicit V3ErrorCode (const char* msgp);	// Matching code or ERROR
-    explicit inline V3ErrorCode (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline V3ErrorCode(en _e) : m_e(_e) {}
+    explicit V3ErrorCode(const char* msgp);  // Matching code or ERROR
+    explicit inline V3ErrorCode(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
     const char* ascii() const {
 	const char* names[] = {
 	    // Leading spaces indicate it can't be disabled.
@@ -130,7 +131,7 @@ public:
 	    "ALWCOMBORDER", "ASSIGNDLY", "ASSIGNIN",
 	    "BLKANDNBLK", "BLKLOOPINIT", "BLKSEQ", "BSSPACE",
 	    "CASEINCOMPLETE", "CASEOVERLAP", "CASEWITHX", "CASEX", "CDCRSTLOGIC", "CLKDATA",
-	    "CMPCONST", "COLONPLUS", "COMBDLY", "DEFPARAM", "DECLFILENAME",
+            "CMPCONST", "COLONPLUS", "COMBDLY", "DEFPARAM", "DECLFILENAME",
 	    "ENDLABEL", "GENCLK",
 	    "IFDEPTH", "IMPERFECTSCH", "IMPLICIT", "IMPURE",
             "INCABSPATH", "INFINITELOOP", "INITIALDLY",
@@ -139,7 +140,8 @@ public:
 	    "PINMISSING", "PINNOCONNECT", "PINCONNECTEMPTY",
 	    "REALCVT", "REDEFMACRO",
 	    "SELRANGE", "STMTDLY", "SYMRSVDWORD", "SYNCASYNCNET",
-	    "UNDRIVEN", "UNOPT", "UNOPTFLAT", "UNPACKED", "UNSIGNED", "UNUSED",
+            "UNDRIVEN", "UNOPT", "UNOPTFLAT", "UNOPTTHREADS",
+            "UNPACKED", "UNSIGNED", "UNUSED",
 	    "USERERROR", "USERFATAL", "USERINFO", "USERWARN",
 	    "VARHIDDEN", "WIDTH", "WIDTHCONCAT",
 	    " MAX"
@@ -154,7 +156,7 @@ public:
     // Later -Werror- options may make more of these.
     bool pretendError() const { return ( m_e==ASSIGNIN || m_e==BLKANDNBLK
 					 || m_e==BLKLOOPINIT
-					 || m_e==IMPURE || m_e==MODDUP); }
+					 || m_e==IMPURE); }
     // Warnings to mention manual
     bool mentionManual() const { return ( m_e==EC_FATALSRC || m_e==SYMRSVDWORD
 					  || pretendError() ); }
@@ -189,14 +191,14 @@ public:
   inline bool operator== (V3ErrorCode lhs, V3ErrorCode rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (V3ErrorCode lhs, V3ErrorCode::en rhs) { return (lhs.m_e == rhs); }
   inline bool operator== (V3ErrorCode::en lhs, V3ErrorCode rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, V3ErrorCode rhs) { return os<<rhs.ascii(); }
+  inline std::ostream& operator<<(std::ostream& os, V3ErrorCode rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
 class V3Error {
     // Base class for any object that wants debugging and error reporting
 
-    typedef set<string> MessagesSet;
+    typedef std::set<string> MessagesSet;
     typedef void (*ErrorExitCb)(void);
 
   private:
@@ -209,7 +211,7 @@ class V3Error {
     static int		s_errCount;		// Error count
     static int		s_warnCount;		// Warning count
     static int 		s_tellManual;		// Tell user to see manual, 0=not yet, 1=doit, 2=disable
-    static ostringstream s_errorStr;		// Error string being formed
+    static std::ostringstream s_errorStr;       // Error string being formed
     static V3ErrorCode	s_errorCode;		// Error string being formed will abort
     static bool		s_errorSuppressed;	// Error being formed should be suppressed
     static MessagesSet	s_messages;		// What errors we've outputted
@@ -217,7 +219,7 @@ class V3Error {
 
     enum MaxErrors { 	MAX_ERRORS = 50 };	// Fatal after this may errors
 
-    V3Error() { cerr<<("Static class"); abort(); }
+    V3Error() { std::cerr<<("Static class"); abort(); }
 
   public:
     // CONSTRUCTORS
@@ -241,8 +243,8 @@ class V3Error {
     static void		suppressThisWarning();	// Suppress next %Warn if user has it off
     static void		pretendError(V3ErrorCode code, bool flag) { s_pretendError[code]=flag; }
     static bool		isError(V3ErrorCode code, bool supp);
-    static string	lineStr (const char* filename, int lineno);
-    static V3ErrorCode	errorCode() { return s_errorCode; }
+    static string lineStr(const char* filename, int lineno);
+    static V3ErrorCode errorCode() { return s_errorCode; }
     static void		errorExitCb(ErrorExitCb cb) { s_errorExitCb = cb; }
 
     // When printing an error/warning, print prefix for multiline message
@@ -252,15 +254,15 @@ class V3Error {
     // Error end takes the string stream to output, be careful to seek() as needed
     static void v3errorPrep(V3ErrorCode code) {
 	s_errorStr.str(""); s_errorCode=code; s_errorSuppressed=false; }
-    static ostringstream& v3errorStr() { return s_errorStr; }
+    static std::ostringstream& v3errorStr() { return s_errorStr; }
     static void	vlAbort();
-    static void	v3errorEnd(ostringstream& sstr);	// static, but often overridden in classes.
+    static void v3errorEnd(std::ostringstream& sstr);  // static, but often overridden in classes.
 };
 
 // Global versions, so that if the class doesn't define a operator, we get the functions anyways.
 inline int debug() { return V3Error::debugDefault(); }
-inline void v3errorEnd(ostringstream& sstr) { V3Error::v3errorEnd(sstr); }
-inline void v3errorEndFatal(ostringstream& sstr) { V3Error::v3errorEnd(sstr); assert(0); VL_UNREACHABLE }
+inline void v3errorEnd(std::ostringstream& sstr) { V3Error::v3errorEnd(sstr); }
+inline void v3errorEndFatal(std::ostringstream& sstr) { V3Error::v3errorEnd(sstr); assert(0); VL_UNREACHABLE }
 
 // Theses allow errors using << operators: v3error("foo"<<"bar");
 // Careful, you can't put () around msg, as you would in most macro definitions
@@ -276,7 +278,11 @@ inline void v3errorEndFatal(ostringstream& sstr) { V3Error::v3errorEnd(sstr); as
 #define v3error(msg) v3warnCode(V3ErrorCode::EC_ERROR, msg)
 #define v3fatal(msg) v3warnCodeFatal(V3ErrorCode::EC_FATAL, msg)
 // Use this instead of fatal() to mention the source code line.
-#define v3fatalSrc(msg) v3warnCodeFatal(V3ErrorCode::EC_FATALSRC, __FILE__<<":"<<dec<<__LINE__<<": "<<msg)
+#define v3fatalSrc(msg) v3warnCodeFatal(V3ErrorCode::EC_FATALSRC, __FILE__<<":"<<std::dec<<__LINE__<<": "<<msg)
+// Use this when normal v3fatal is called in static method that overrides fileline.
+#define v3fatalStatic(msg) \
+    ::v3errorEndFatal((V3Error::v3errorPrep(V3ErrorCode::EC_FATAL), \
+                       (V3Error::v3errorStr()<<msg), V3Error::v3errorStr()));
 
 #define UINFO(level,stmsg) {if(VL_UNLIKELY(debug()>=(level))) { cout<<"- "<<V3Error::lineStr(__FILE__,__LINE__)<<stmsg; }}
 #define UINFONL(level,stmsg) {if(VL_UNLIKELY(debug()>=(level))) { cout<<stmsg; } }
@@ -289,15 +295,31 @@ inline void v3errorEndFatal(ostringstream& sstr) { V3Error::v3errorEnd(sstr); as
 
 #define UASSERT(condition,stmsg) { if (VL_UNLIKELY(!(condition))) { v3fatalSrc(stmsg); }}
 // For use in V3Ast static functions only
-#define UASSERT_STATIC(condition,stmsg) { if (VL_UNLIKELY(!(condition))) { \
-            cerr<<"Internal Error: "<<__FILE__<<":"<<dec<<__LINE__<<":"<<(stmsg)<<endl; abort(); } }
+#define UASSERT_STATIC(condition,stmsg) \
+    { if (VL_UNLIKELY(!(condition))) { \
+            std::cerr<<"Internal Error: "<<__FILE__<<":"<<std::dec<<__LINE__<<":"<<(stmsg)<<std::endl; abort(); } }
+// Check self test values for expected value.  Safe from side-effects.
+// Type argument can be removed when go to C++11 (use auto).
+#define UASSERT_SELFTEST(Type,got,exp) \
+    do { Type g = (got); Type e = (exp); \
+         UASSERT(g==e, "Self-test failed '" #got "==" #exp "'"" got=" \
+                 <<g<<" expected="<<e); } while(0)
 
 #define V3ERROR_NA { v3error("Internal: Unexpected Call"); v3fatalSrc("Unexpected Call"); }
 
+/// Declare a convenience debug() routine that may be added to any class in
+/// Verilator so that --debugi-<srcfile> will work to control UINFOs in
+/// that class:
+#define VL_DEBUG_FUNC static int debug() { \
+        static int level = -1; \
+        if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__); \
+        return level; \
+    }
+
 //----------------------------------------------------------------------
 
-template< class T> std::string cvtToStr (const T& t) {
-    ostringstream os; os<<t; return os.str();
+template< class T> std::string cvtToStr(const T& t) {
+    std::ostringstream os; os<<t; return os.str();
 }
 
 inline uint32_t cvtToHash(const void* vp) {

src/V3File.cpp

@@ -97,8 +97,8 @@ class V3FileDependImp {
     };
 
     // MEMBERS
-    set<string>		m_filenameSet;		// Files generated (elim duplicates)
-    set<DependFile>	m_filenameList;		// Files sourced/generated
+    std::set<string> m_filenameSet;  // Files generated (elim duplicates)
+    std::set<DependFile> m_filenameList;  // Files sourced/generated
 
     static string stripQuotes(const string& in) {
 	string pretty = in;
@@ -120,7 +120,7 @@ public:
     void addTgtDepend(const string& filename) {
 	if (m_filenameSet.find(filename) == m_filenameSet.end()) {
 	    m_filenameSet.insert(filename);
-	    m_filenameList.insert(DependFile (filename, true));
+            m_filenameList.insert(DependFile(filename, true));
 	}
     }
     void writeDepend(const string& filename);
@@ -134,10 +134,10 @@ V3FileDependImp  dependImp;	// Depend implementation class
 // V3FileDependImp
 
 inline void V3FileDependImp::writeDepend(const string& filename) {
-    const vl_unique_ptr<ofstream> ofp (V3File::new_ofstream(filename));
-    if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
+    const vl_unique_ptr<std::ofstream> ofp (V3File::new_ofstream(filename));
+    if (ofp->fail()) v3fatal("Can't write "<<filename);
 
-    for (set<DependFile>::iterator iter=m_filenameList.begin();
+    for (std::set<DependFile>::iterator iter=m_filenameList.begin();
 	 iter!=m_filenameList.end(); ++iter) {
 	if (iter->target()) {
 	    *ofp<<iter->filename()<<" ";
@@ -149,7 +149,7 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
     *ofp<<V3PreShell::dependFiles();
     *ofp<<"  ";
 
-    for (set<DependFile>::iterator iter=m_filenameList.begin();
+    for (std::set<DependFile>::iterator iter=m_filenameList.begin();
 	 iter!=m_filenameList.end(); ++iter) {
 	if (!iter->target()) {
 	    *ofp<<iter->filename()<<" ";
@@ -160,7 +160,7 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
 
     if (v3Global.opt.makePhony()) {
 	*ofp<<endl;
-	for (set<DependFile>::iterator iter=m_filenameList.begin();
+        for (std::set<DependFile>::iterator iter=m_filenameList.begin();
 	     iter!=m_filenameList.end(); ++iter) {
 	    if (!iter->target()) {
 		*ofp<<iter->filename()<<":"<<endl;
@@ -170,14 +170,14 @@ inline void V3FileDependImp::writeDepend(const string& filename) {
 }
 
 inline void V3FileDependImp::writeTimes(const string& filename, const string& cmdlineIn) {
-    const vl_unique_ptr<ofstream> ofp (V3File::new_ofstream(filename));
-    if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
+    const vl_unique_ptr<std::ofstream> ofp (V3File::new_ofstream(filename));
+    if (ofp->fail()) v3fatal("Can't write "<<filename);
 
     string cmdline = stripQuotes(cmdlineIn);
     *ofp<<"# DESCR"<<"IPTION: Verilator output: Timestamp data for --skip-identical.  Delete at will."<<endl;
     *ofp<<"C \""<<cmdline<<"\""<<endl;
 
-    for (set<DependFile>::iterator iter=m_filenameList.begin();
+    for (std::set<DependFile>::iterator iter=m_filenameList.begin();
 	 iter!=m_filenameList.end(); ++iter) {
 	// Read stats of files we create after we're done making them (execpt for this file, of course)
 	DependFile* dfp = (DependFile*)&(*iter);
@@ -188,19 +188,19 @@ inline void V3FileDependImp::writeTimes(const string& filename, const string& cm
 	if (dfp->filename() == filename) { showSize=0; showIno=0; }  // We're writing it, so need to ignore it
 
 	*ofp<<(iter->target()?"T":"S")<<" ";
-	*ofp<<" "<<setw(8)<<showSize;
-	*ofp<<" "<<setw(8)<<showIno;
-	*ofp<<" "<<setw(11)<<iter->cstime();
-	*ofp<<" "<<setw(11)<<iter->cnstime();
-	*ofp<<" "<<setw(11)<<iter->mstime();
-	*ofp<<" "<<setw(11)<<iter->mnstime();
+        *ofp<<" "<<std::setw(8)<<showSize;
+        *ofp<<" "<<std::setw(8)<<showIno;
+        *ofp<<" "<<std::setw(11)<<iter->cstime();
+        *ofp<<" "<<std::setw(11)<<iter->cnstime();
+        *ofp<<" "<<std::setw(11)<<iter->mstime();
+        *ofp<<" "<<std::setw(11)<<iter->mnstime();
 	*ofp<<" \""<<iter->filename()<<"\"";
 	*ofp<<endl;
     }
 }
 
 inline bool V3FileDependImp::checkTimes(const string& filename, const string& cmdlineIn) {
-    const vl_unique_ptr<ifstream> ifp (V3File::new_ifstream_nodepend(filename));
+    const vl_unique_ptr<std::ifstream> ifp (V3File::new_ifstream_nodepend(filename));
     if (ifp->fail()) {
 	UINFO(2,"   --check-times failed: no input "<<filename<<endl);
 	return false;
@@ -299,7 +299,7 @@ void V3File::createMakeDir() {
 // V3InFilterImp
 
 class V3InFilterImp {
-    typedef map<string,string> FileContentsMap;
+    typedef std::map<string,string> FileContentsMap;
     typedef V3InFilter::StrList StrList;
 
     FileContentsMap	m_contentsMap;	// Cache of file contents
@@ -316,18 +316,14 @@ class V3InFilterImp {
 
 private:
     // METHODS
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 
     bool readContents(const string& filename, StrList& outl) {
 	if (m_pid) return readContentsFilter(filename,outl);
 	else return readContentsFile(filename,outl);
     }
     bool readContentsFile(const string& filename, StrList& outl) {
-	int fd = open (filename.c_str(), O_RDONLY);
+        int fd = open(filename.c_str(), O_RDONLY);
 	if (fd<0) return false;
 	m_readEof = false;
 	readBlocks(fd, -1, outl);
@@ -373,7 +369,7 @@ private:
 	    ssize_t todo = INFILTER_IPC_BUFSIZ;
 	    if (size>0 && size<todo) todo = size;
 	    errno = 0;
-	    ssize_t got = read (fd, buf, todo);
+            ssize_t got = read(fd, buf, todo);
 	    //UINFO(9,"RD GOT g "<< got<<" e "<<errno<<" "<<strerror(errno)<<endl);  usleep(50*1000);
 	    if (got>0) {
 		outl.push_back(string(buf, got));
@@ -415,7 +411,7 @@ private:
 	unsigned offset = 0;
 	while (!m_readEof && out.length()>offset) {
 	    errno = 0;
-	    int got = write (m_writeFd, (out.c_str())+offset, out.length()-offset);
+            int got = write(m_writeFd, (out.c_str())+offset, out.length()-offset);
 	    //UINFO(9,"WR GOT g "<< got<<" e "<<errno<<" "<<strerror(errno)<<endl);  usleep(50*1000);
 	    if (got>0) offset += got;
 	    else if (errno == EINTR || errno == EAGAIN
@@ -633,7 +629,7 @@ bool V3OutFormatter::tokenEnd(const char* cp) {
 	    || tokenStart(cp,"endmodule"));
 }
 
-int V3OutFormatter::endLevels (const char *strg) {
+int V3OutFormatter::endLevels(const char *strg) {
     int levels=m_indentLevel;
     {
 	const char* cp=strg;
@@ -678,14 +674,14 @@ int V3OutFormatter::endLevels (const char *strg) {
     return (levels);
 }
 
-void V3OutFormatter::puts (const char *strg) {
+void V3OutFormatter::puts(const char *strg) {
     if (m_prependIndent) {
 	putsNoTracking(indentStr(endLevels(strg)));
 	m_prependIndent = false;
     }
     bool wordstart = true;
     for (const char* cp=strg; *cp; cp++) {
-	putcNoTracking (*cp);
+        putcNoTracking(*cp);
 	switch (*cp) {
 	case '\n':
 	    m_lineno++;
@@ -768,12 +764,12 @@ void V3OutFormatter::puts (const char *strg) {
     }
 }
 
-void V3OutFormatter::putBreakExpr () {
+void V3OutFormatter::putBreakExpr() {
     if (!m_parenVec.empty()) putBreak();
 }
 
 // Add a line break if too wide
-void V3OutFormatter::putBreak () {
+void V3OutFormatter::putBreak() {
     if (!m_nobreak) {
 	//char s[1000]; sprintf(s,"{%d,%d}",m_column,m_parenVec.top()); putsNoTracking(s);
 	if (exceededWidth()) {
@@ -789,18 +785,18 @@ void V3OutFormatter::putsQuoted(const string& strg) {
     putcNoTracking('"');
     string quoted = V3Number::quoteNameControls(strg);
     for (string::const_iterator cp=quoted.begin(); cp!=quoted.end(); ++cp) {
-    	putcNoTracking (*cp);
+        putcNoTracking(*cp);
     }
     putcNoTracking('"');
 }
-void V3OutFormatter::putsNoTracking (const string& strg) {
+void V3OutFormatter::putsNoTracking(const string& strg) {
     // Don't track {}'s, probably because it's a $display format string
     for (string::const_iterator cp=strg.begin(); cp!=strg.end(); ++cp) {
-	putcNoTracking (*cp);
+        putcNoTracking(*cp);
     }
 }
 
-void V3OutFormatter::putcNoTracking (char chr) {
+void V3OutFormatter::putcNoTracking(char chr) {
     switch (chr) {
     case '\n':
 	m_lineno++;
@@ -821,13 +817,13 @@ void V3OutFormatter::putcNoTracking (char chr) {
 	m_nobreak=false;
 	break;
     }
-    putcOutput (chr);
+    putcOutput(chr);
 }
 
 //----------------------------------------------------------------------
 // Simple wrappers
 
-void V3OutFormatter::printf (const char *fmt...) {
+void V3OutFormatter::printf(const char *fmt...) {
     char sbuff[5000];
     va_list ap;
     va_start(ap,fmt);

src/V3File.h

@@ -34,23 +34,23 @@
 
 class V3File {
 public:
-    static ifstream* new_ifstream(const string& filename) {
+    static std::ifstream* new_ifstream(const string& filename) {
 	addSrcDepend(filename);
-	return new_ifstream_nodepend (filename);
+        return new_ifstream_nodepend(filename);
     }
-    static ifstream* new_ifstream_nodepend(const string& filename) {
-	return new ifstream(filename.c_str());
+    static std::ifstream* new_ifstream_nodepend(const string& filename) {
+        return new std::ifstream(filename.c_str());
     }
-    static ofstream* new_ofstream(const string& filename, bool append=false) {
+    static std::ofstream* new_ofstream(const string& filename, bool append=false) {
 	addTgtDepend(filename);
-	return new_ofstream_nodepend (filename, append);
+        return new_ofstream_nodepend(filename, append);
     }
-    static ofstream* new_ofstream_nodepend(const string& filename, bool append=false) {
+    static std::ofstream* new_ofstream_nodepend(const string& filename, bool append=false) {
 	if (filename != VL_DEV_NULL) createMakeDir();
 	if (append) {
-	    return new ofstream(filename.c_str(), ios::app);
+            return new std::ofstream(filename.c_str(), std::ios::app);
 	} else {
-	    return new ofstream(filename.c_str());
+            return new std::ofstream(filename.c_str());
 	}
     }
     static FILE* new_fopen_w(const string& filename) {
@@ -78,7 +78,7 @@ class V3InFilterImp;
 class V3InFilter {
 public:
     // TYPES
-    typedef list<string> StrList;
+    typedef std::list<string> StrList;
 
 private:
     V3InFilterImp* m_impp;
@@ -123,7 +123,7 @@ private:
     int		m_nobreak;	// Basic operator or begin paren, don't break next
     bool	m_prependIndent;
     int		m_indentLevel;	// Current {} indentation
-    stack<int>	m_parenVec;	// Stack of columns where last ( was
+    std::stack<int> m_parenVec;  // Stack of columns where last ( was
 
     int		endLevels(const char* strg);
     const char* indentStr(int levels);
@@ -152,7 +152,7 @@ public:
     void indentInc() { m_indentLevel += m_blockIndent; }
     void indentDec() {
 	m_indentLevel -= m_blockIndent;
-	UASSERT(m_indentLevel>=0, ": "<<m_filename<<": Underflow of indentation\n");
+        UASSERT(m_indentLevel>=0, ": "<<m_filename<<": Underflow of indentation");
     }
     void blockInc() { m_parenVec.push(m_indentLevel + m_blockIndent); }
     void blockDec() { if (!m_parenVec.empty()) m_parenVec.pop(); }

src/V3FileLine.cpp

@@ -71,7 +71,7 @@ int FileLineSingleton::nameToNumber(const string& filename) {
 //! Support XML output
 
 //! Experimental. Updated to also put out the language.
-void FileLineSingleton::fileNameNumMapDumpXml(ostream& os) {
+void FileLineSingleton::fileNameNumMapDumpXml(std::ostream& os) {
     os<<"<files>\n";
     for (FileNameNumMap::const_iterator it = m_namemap.begin(); it != m_namemap.end(); ++it) {
 	os<<"<file id=\""<<filenameLetters(it->second)
@@ -184,8 +184,8 @@ const string FileLine::profileFuncname() const {
 string FileLine::ascii() const {
     return filename()+":"+cvtToStr(lineno());
 }
-ostream& operator<<(ostream& os, FileLine* fileline) {
-    os <<fileline->ascii()<<": "<<hex;
+std::ostream& operator<<(std::ostream& os, FileLine* fileline) {
+    os <<fileline->ascii()<<": "<<std::hex;
     return(os);
 }
 
@@ -237,9 +237,9 @@ void FileLine::modifyStateInherit(const FileLine* fromp) {
     }
 }
 
-void FileLine::v3errorEnd(ostringstream& str) {
+void FileLine::v3errorEnd(std::ostringstream& str) {
     if (m_lineno) {
-	ostringstream nsstr;
+        std::ostringstream nsstr;
 	nsstr<<this<<str.str();
 	if (warnIsOff(V3Error::errorCode())) V3Error::suppressThisWarning();
 	V3Error::v3errorEnd(nsstr);

src/V3FileLine.h

@@ -43,12 +43,12 @@ class FileLine;
 //! source file (each with its own unique filename number).
 class FileLineSingleton {
     // TYPES
-    typedef map<string,int> FileNameNumMap;
-    typedef map<string,V3LangCode> FileLangNumMap;
+    typedef std::map<string,int> FileNameNumMap;
+    typedef std::map<string,V3LangCode> FileLangNumMap;
     // MEMBERS
     FileNameNumMap	m_namemap;	// filenameno for each filename
-    deque<string>	m_names;	// filename text for each filenameno
-    deque<V3LangCode>	m_languages;	// language for each filenameno
+    std::deque<string>  m_names;        // filename text for each filenameno
+    std::deque<V3LangCode>      m_languages;    // language for each filenameno
     // COSNTRUCTORS
     FileLineSingleton() { }
     ~FileLineSingleton() { }
@@ -60,7 +60,7 @@ protected:
     const V3LangCode numberToLang(int filenameno) const { return m_languages[filenameno]; }
     void numberToLang(int filenameno, const V3LangCode& l) { m_languages[filenameno] = l; }
     void clear() { m_namemap.clear(); m_names.clear(); m_languages.clear(); }
-    void fileNameNumMapDumpXml(ostream& os);
+    void fileNameNumMapDumpXml(std::ostream& os);
     static const string filenameLetters(int fileno);
 };
 
@@ -72,7 +72,7 @@ protected:
 class FileLine {
     int		m_lineno;
     int		m_filenameno;
-    bitset<V3ErrorCode::_ENUM_MAX>	m_warnOn;
+    std::bitset<V3ErrorCode::_ENUM_MAX> m_warnOn;
 
 private:
     struct EmptySecret {};
@@ -92,19 +92,19 @@ protected:
     friend class V3PreLex;
     friend class V3PreProcImp;
     void lineno(int num) { m_lineno = num; }
-    void language (V3LangCode lang) { singleton().numberToLang(m_filenameno, lang); }
+    void language(V3LangCode lang) { singleton().numberToLang(m_filenameno, lang); }
     void filename(const string& name) { m_filenameno = singleton().nameToNumber(name); }
     void lineDirective(const char* textp, int& enterExitRef);
     void linenoInc() { m_lineno++; }
     void linenoIncInPlace() { m_lineno++; }
     FileLine* copyOrSameFileLine();
 public:
-    FileLine (const string& filename, int lineno) {
+    FileLine(const string& filename, int lineno) {
 	m_lineno=lineno; m_filenameno = singleton().nameToNumber(filename);
 	m_warnOn=defaultFileLine().m_warnOn; }
-    explicit FileLine (FileLine* fromp) {
+    explicit FileLine(FileLine* fromp) {
 	m_lineno=fromp->m_lineno; m_filenameno = fromp->m_filenameno; m_warnOn=fromp->m_warnOn; }
-    explicit FileLine (EmptySecret);
+    explicit FileLine(EmptySecret);
     ~FileLine() { }
     FileLine* create(const string& filename, int lineno) { return new FileLine(filename,lineno); }
     FileLine* create(int lineno) { return create(filename(), lineno); }
@@ -114,13 +114,13 @@ public:
     static void operator delete(void* obj, size_t size);
 #endif
 
-    int lineno () const { return m_lineno; }
-    V3LangCode language () const { return singleton().numberToLang(m_filenameno); }
+    int lineno() const { return m_lineno; }
+    V3LangCode language() const { return singleton().numberToLang(m_filenameno); }
     string ascii() const;
-    const string filename () const { return singleton().numberToName(m_filenameno); }
+    const string filename() const { return singleton().numberToName(m_filenameno); }
     const string filenameLetters() const { return singleton().filenameLetters(m_filenameno); }
-    const string filebasename () const;
-    const string filebasenameNoExt () const;
+    const string filebasename() const;
+    const string filebasenameNoExt() const;
     const string profileFuncname() const;
     const string xml() const { return "fl=\""+filenameLetters()+cvtToStr(lineno())+"\""; }
     string lineDirectiveStrg(int enter_exit_level) const;
@@ -148,7 +148,7 @@ public:
 	defaultFileLine().warnOff(code, flag); }
     static bool globalWarnOff(const string& code, bool flag) {
 	return defaultFileLine().warnOff(code, flag); }
-    static void fileNameNumMapDumpXml(ostream& os) {
+    static void fileNameNumMapDumpXml(std::ostream& os) {
 	singleton().fileNameNumMapDumpXml(os); }
 
     // METHODS - Called from netlist
@@ -160,17 +160,17 @@ public:
     void modifyWarnOff(V3ErrorCode code, bool flag) { warnOff(code,flag); }
 
     // OPERATORS
-    void v3errorEnd(ostringstream& str);
-    void v3errorEndFatal(ostringstream& str);
+    void v3errorEnd(std::ostringstream& str);
+    void v3errorEndFatal(std::ostringstream& str);
     string warnMore() const;
     inline bool operator==(FileLine rhs) const {
 	return (m_lineno==rhs.m_lineno && m_filenameno==rhs.m_filenameno && m_warnOn==rhs.m_warnOn);
     }
 private:
-    void v3errorEndFatalGuts(ostringstream& str);
+    void v3errorEndFatalGuts(std::ostringstream& str);
 };
-ostream& operator<<(ostream& os, FileLine* fileline);
+std::ostream& operator<<(std::ostream& os, FileLine* fileline);
 
-inline void FileLine::v3errorEndFatal(ostringstream& str) { v3errorEnd(str); assert(0); }
+inline void FileLine::v3errorEndFatal(std::ostringstream& str) { v3errorEnd(str); assert(0); }
 
 #endif // Guard

src/V3Gate.cpp

@@ -45,7 +45,7 @@
 #include "V3Stats.h"
 #include "V3Hashed.h"
 
-typedef list<AstNodeVarRef*> GateVarRefList;
+typedef std::list<AstNodeVarRef*> GateVarRefList;
 
 #define GATE_DEDUP_MAX_DEPTH  20
 
@@ -53,11 +53,7 @@ typedef list<AstNodeVarRef*> GateVarRefList;
 
 class GateBaseVisitor : public AstNVisitor {
 public:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 //######################################################################
@@ -176,6 +172,7 @@ public:
     // ACCESSORS
     virtual string name() const { return (cvtToStr((void*)m_nodep)+"@"+scopep()->prettyName()); }
     virtual string dotColor() const { return "yellow"; }
+    virtual FileLine* fileline() const { return nodep()->fileline(); }
     AstNode* nodep() const { return m_nodep; }
     AstActive* activep() const { return m_activep; }
     bool	slow() const { return m_slow; }
@@ -207,7 +204,7 @@ private:
     // VISITORS
     virtual void visit(AstNodeVarRef* nodep) {
         ++m_ops;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	// We only allow a LHS ref for the var being set, and a RHS ref for something else being read.
 	if (nodep->varScopep()->varp()->isSc()) {
 	    clearSimple("SystemC sig");  // Don't want to eliminate the VL_ASSIGN_SI's
@@ -234,19 +231,19 @@ private:
     }
     virtual void visit(AstNodeAssign* nodep) {
 	m_substTreep = nodep->rhsp();
-	if (!nodep->lhsp()->castNodeVarRef())
+        if (!VN_IS(nodep->lhsp(), NodeVarRef))
 	    clearSimple("ASSIGN(non-VARREF)");
-	else nodep->iterateChildren(*this);
+        else iterateChildren(nodep);
 	// We don't push logic other then assignments/NOTs into SenItems
 	// This avoids a mess in computing what exactly a POSEDGE is
 	// V3Const cleans up any NOTs by flipping the edges for us
 	if (m_buffersOnly
-	    && !(nodep->rhsp()->castVarRef()
+            && !(VN_IS(nodep->rhsp(), VarRef)
 		 // Avoid making non-clocked logic into clocked,
 		 // as it slows down the verilator_sim_benchmark
-		 || (nodep->rhsp()->castNot()
-		     && nodep->rhsp()->castNot()->lhsp()->castVarRef()
-		     && nodep->rhsp()->castNot()->lhsp()->castVarRef()->varp()->isUsedClock())
+                 || (VN_IS(nodep->rhsp(), Not)
+                     && VN_IS(VN_CAST(nodep->rhsp(), Not)->lhsp(), VarRef)
+                     && VN_CAST(VN_CAST(nodep->rhsp(), Not)->lhsp(), VarRef)->varp()->isUsedClock())
 		)) {
 	    clearSimple("Not a buffer (goes to a clock)");
 	}
@@ -265,7 +262,7 @@ private:
 	    UINFO(5, "Non optimizable type: "<<nodep<<endl);
 	    clearSimple("Non optimizable type");
 	}
-	else nodep->iterateChildren(*this);
+        else iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -277,7 +274,7 @@ public:
 	m_dedupe = dedupe;
         m_ops = 0;
 	// Iterate
-	nodep->accept(*this);
+        iterate(nodep);
 	// Check results
 	if (!m_substTreep) {
 	    clearSimple("No assignment found\n");
@@ -312,7 +309,7 @@ private:
     // {statement}Node::user1p	-> GateLogicVertex* for this statement
     // AstVarScope::user2	-> bool: Signal used in SenItem in *this* always statement
     // AstVar::user2		-> bool: Warned about SYNCASYNCNET
-    // AstVarNodeRef::user2	-> bool: ConcatOffset visited
+    // AstNodeVarRef::user2     -> bool: ConcatOffset visited
     AstUser1InUse	m_inuser1;
     AstUser2InUse	m_inuser2;
 
@@ -342,8 +339,8 @@ private:
 		m_logicVertexp->clearReducible("Block Unreducible");  // Sequential logic is dedupable
 	    }
 	    if (consumeReason) m_logicVertexp->setConsumed(consumeReason);
-	    if (nodep->castSenItem()) m_logicVertexp->setConsumed("senItem");
-	    nodep->iterateChildren(*this);
+            if (VN_IS(nodep, SenItem)) m_logicVertexp->setConsumed("senItem");
+            iterateChildren(nodep);
 	    m_logicVertexp = NULL;
 	}
     }
@@ -384,7 +381,7 @@ private:
 
     // VISITORS
     virtual void visit(AstNetlist* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	//if (debug()>6) m_graph.dump();
 	if (debug()>6) m_graph.dumpDotFilePrefixed("gate_pre");
 	warnSignals();  // Before loss of sync/async pointers
@@ -411,14 +408,14 @@ private:
     virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_activeReducible = true;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_modp = NULL;
     }
     virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVertexp = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_scopep = NULL;
     }
     virtual void visit(AstActive* nodep) {
@@ -427,7 +424,7 @@ private:
 	m_activeReducible = !(nodep->hasClocked());  // Seq logic outputs aren't reducible
 	m_activep = nodep;
 	AstNode::user2ClearTree();
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	AstNode::user2ClearTree();
 	m_activep = NULL;
 	m_activeReducible = true;
@@ -475,7 +472,7 @@ private:
 	// The gating term of a AstSenGate is normal logic
 	m_inSenItem = true;
 	if (m_logicVertexp) {  // Already under logic; presumably a SenGate
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	} else {  // Standalone item, probably right under a SenTree
 	    iterateNewStmt(nodep, NULL, NULL);
 	}
@@ -508,16 +505,16 @@ private:
 	m_inSlow = lastslow;
     }
     virtual void visit(AstConcat* nodep) {
-	if (nodep->backp()->castNodeAssign() && nodep->backp()->castNodeAssign()->lhsp()==nodep) {
+        if (VN_IS(nodep->backp(), NodeAssign) && VN_CAST(nodep->backp(), NodeAssign)->lhsp()==nodep) {
 	    nodep->v3fatalSrc("Concat on LHS of assignment; V3Const should have deleted it");
 	}
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     //--------------------
     // Default
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	if (nodep->isOutputter() && m_logicVertexp) m_logicVertexp->setConsumed("outputter");
     }
 
@@ -532,7 +529,7 @@ public:
 	m_activeReducible = true;
 	m_inSenItem = false;
 	m_inSlow = false;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~GateVisitor() {
 	V3Stats::addStat("Optimizations, Gate sigs deleted", m_statSigs);
@@ -702,33 +699,33 @@ void GateVisitor::replaceAssigns() {
 	    // Take the Comments/assigns that were moved to the VarScope and change them to a
 	    // simple value assignment
 	    AstVarScope* vscp = vvertexp->varScp();
-	    if (vscp->valuep() && !vscp->valuep()->castNodeMath()) {
+            if (vscp->valuep() && !VN_IS(vscp->valuep(), NodeMath)) {
 		//if (debug()>9) vscp->dumpTree(cout, "-vscPre:  ");
-		while (AstNode* delp=vscp->valuep()->castComment()) {
+                while (AstNode* delp=VN_CAST(vscp->valuep(), Comment)) {
 		    delp->unlinkFrBack()->deleteTree(); VL_DANGLING(delp);
 		}
-		if (AstInitial* delp=vscp->valuep()->castInitial()) {
+                if (AstInitial* delp=VN_CAST(vscp->valuep(), Initial)) {
 		    AstNode* bodyp=delp->bodysp();
 		    bodyp->unlinkFrBackWithNext();
 		    delp->replaceWith(bodyp);
 		    delp->deleteTree(); VL_DANGLING(delp);
 		}
-		if (AstAlways* delp=vscp->valuep()->castAlways()) {
+                if (AstAlways* delp=VN_CAST(vscp->valuep(), Always)) {
 		    AstNode* bodyp=delp->bodysp();
 		    bodyp->unlinkFrBackWithNext();
 		    delp->replaceWith(bodyp);
 		    delp->deleteTree(); VL_DANGLING(delp);
 		}
-		if (AstNodeAssign* delp=vscp->valuep()->castNodeAssign()) {
+                if (AstNodeAssign* delp=VN_CAST(vscp->valuep(), NodeAssign)) {
 		    AstNode* rhsp=delp->rhsp();
 		    rhsp->unlinkFrBack();
 		    delp->replaceWith(rhsp);
 		    delp->deleteTree(); VL_DANGLING(delp);
 		}
 		//if (debug()>9) {vscp->dumpTree(cout, "-vscDone: "); cout<<endl;}
-		if (!vscp->valuep()->castNodeMath()
+                if (!VN_IS(vscp->valuep(), NodeMath)
 		    || vscp->valuep()->nextp()) {
-		    vscp->dumpTree(cerr, "vscStrange: ");
+                    vscp->dumpTree(std::cerr, "vscStrange: ");
 		    vscp->v3fatalSrc("Value of varscope not mathematical");
 		}
 	    }
@@ -829,8 +826,8 @@ private:
 	    m_didReplace = true;
 	    if (nodep->lvalue()) nodep->v3fatalSrc("Can't replace lvalue assignments with const var");
 	    AstNode* substp = m_replaceTreep->cloneTree(false);
-	    if (nodep->castNodeVarRef()
-		&& substp->castNodeVarRef()
+            if (VN_IS(nodep, NodeVarRef)
+                && VN_IS(substp, NodeVarRef)
 		&& nodep->same(substp)) {
 		// Prevent a infinite loop...
 		substp->v3fatalSrc("Replacing node with itself; perhaps circular logic?");
@@ -840,15 +837,15 @@ private:
 	    // IE what we're replacing with.
 	    // However a VARREF should point to the original as it's otherwise confusing
 	    // to throw warnings that point to a PIN rather than where the pin us used.
-	    if (substp->castVarRef()) substp->fileline(nodep->fileline());
+            if (VN_IS(substp, VarRef)) substp->fileline(nodep->fileline());
 	    // Make the substp an rvalue like nodep. This facilitate the hashing in dedupe.
-	    if (AstNodeVarRef* varrefp = substp->castNodeVarRef()) varrefp->lvalue(false);
+            if (AstNodeVarRef* varrefp = VN_CAST(substp, NodeVarRef)) varrefp->lvalue(false);
 	    nodep->replaceWith(substp);
 	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -857,7 +854,7 @@ public:
 	m_didReplace = false;
 	m_elimVarScp = varscp;
 	m_replaceTreep = replaceTreep;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     bool didReplace() const { return m_didReplace; }
 };
@@ -929,7 +926,7 @@ public:
 	// So dupit is either a different, duplicate rhsp, or the end of the hash.
 	if (dupit != m_hashed.end()) {
 	    m_hashed.erase(inserted);
-	    return m_hashed.iteratorNodep(dupit)->user2p()->castNodeAssign();
+            return VN_CAST(m_hashed.iteratorNodep(dupit)->user2p(), NodeAssign);
 	}
 	return NULL;
     }
@@ -971,7 +968,7 @@ private:
 	if (m_dedupable) {
 	    if (!m_always) {
 		m_always = true;
-		alwaysp->bodysp()->iterateAndNext(*this);
+                iterateAndNextNull(alwaysp->bodysp());
 	    } else {
 		m_dedupable = false;
 	    }
@@ -985,7 +982,7 @@ private:
 	if (m_dedupable) {
 	    if (m_always && !m_ifCondp && !ifp->elsesp()) {  //we're under an always, this is the first IF,  and there's no else
 		m_ifCondp = ifp->condp();
-		ifp->ifsp()->iterateAndNext(*this);
+                iterateAndNextNull(ifp->ifsp());
 	    } else {
 		m_dedupable = false;
 	    }
@@ -1013,11 +1010,11 @@ public:
 	m_ifCondp = NULL;
 	m_always = false;
 	m_dedupable = true;
-	nodep->accept(*this);
+        iterate(nodep);
 	if (m_dedupable && m_assignp) {
 	    AstNode* lhsp = m_assignp->lhsp();
 	    // Possible todo, handle more complex lhs expressions
-	    if (AstNodeVarRef* lhsVarRefp = lhsp->castNodeVarRef()) {
+            if (AstNodeVarRef* lhsVarRefp = VN_CAST(lhsp, NodeVarRef)) {
 		if (lhsVarRefp->varScopep() != consumerVarScopep) consumerVarScopep->v3fatalSrc("Consumer doesn't match lhs of assign");
 		if (AstNodeAssign* dup =  m_hash.hashAndFindDupe(m_assignp,activep,m_ifCondp)) {
 		    return (AstNodeVarRef*) dup->lhsp();
@@ -1157,13 +1154,13 @@ private:
 
     // assemble two Sel into one if possible
     AstSel* merge(AstSel* pre, AstSel* cur) {
-	AstVarRef* preVarRefp = pre->fromp()->castVarRef();
-	AstVarRef* curVarRefp = cur->fromp()->castVarRef();
+        AstVarRef* preVarRefp = VN_CAST(pre->fromp(), VarRef);
+        AstVarRef* curVarRefp = VN_CAST(cur->fromp(), VarRef);
 	if (!preVarRefp || !curVarRefp || !curVarRefp->same(preVarRefp)) return NULL; // not the same var
-	AstConst* pstart = pre->lsbp()->castConst();
-	AstConst* pwidth = pre->widthp()->castConst();
-	AstConst* cstart = cur->lsbp()->castConst();
-	AstConst* cwidth = cur->widthp()->castConst();
+        const AstConst* pstart = VN_CAST(pre->lsbp(), Const);
+        const AstConst* pwidth = VN_CAST(pre->widthp(), Const);
+        const AstConst* cstart = VN_CAST(cur->lsbp(), Const);
+        const AstConst* cwidth = VN_CAST(cur->widthp(), Const);
 	if (!pstart || !pwidth || !cstart || !cwidth) return NULL; // too complicated
 	if (cur->lsbConst()+cur->widthConst() == pre->lsbConst())
 	    return new AstSel(curVarRefp->fileline(), curVarRefp->cloneTree(false), cur->lsbConst(), pre->widthConst()+cur->widthConst());
@@ -1175,10 +1172,10 @@ private:
 	    V3GraphEdge* oldedgep = edgep;
 	    edgep = edgep->inNextp();  // for recursive since the edge could be deleted
 	    if (GateLogicVertex* lvertexp = dynamic_cast<GateLogicVertex*>(oldedgep->fromp())) {
-		if (AstNodeAssign* assignp = lvertexp->nodep()->castNodeAssign()) {
-		    //if (lvertexp->outSize1() && assignp->lhsp()->castSel()) {
-		    if (assignp->lhsp()->castSel() && lvertexp->outSize1()) {
-			UINFO(9, "assing to the nodep["<<assignp->lhsp()->castSel()->lsbConst()<<"]"<<endl);
+                if (AstNodeAssign* assignp = VN_CAST(lvertexp->nodep(), NodeAssign)) {
+                    //if (lvertexp->outSize1() && VN_IS(assignp->lhsp(), Sel)) {
+                    if (VN_IS(assignp->lhsp(), Sel) && lvertexp->outSize1()) {
+                        UINFO(9, "assing to the nodep["<<VN_CAST(assignp->lhsp(), Sel)->lsbConst()<<"]"<<endl);
 			// first assign with Sel-lhs
 			if (!m_activep) m_activep = lvertexp->activep();
 			if (!m_logicvp) m_logicvp = lvertexp;
@@ -1192,8 +1189,8 @@ private:
 			    continue;
 			}
 
-			AstSel* preselp = m_assignp->lhsp()->castSel();
-			AstSel* curselp = assignp->lhsp()->castSel();
+                        AstSel* preselp = VN_CAST(m_assignp->lhsp(), Sel);
+                        AstSel* curselp = VN_CAST(assignp->lhsp(), Sel);
 			if (!preselp || !curselp) continue;
 
 			if (AstSel* newselp = merge(preselp, curselp)) {
@@ -1292,13 +1289,13 @@ private:
     }
     virtual void visit(AstConcat* nodep) {
 	UINFO(9,"CLK DECOMP Concat search (off = "<<m_offset<<") - "<<nodep<<endl);
-	nodep->rhsp()->iterate(*this);
-	nodep->lhsp()->iterate(*this);
+        iterate(nodep->rhsp());
+        iterate(nodep->lhsp());
     }
     //--------------------
     // Default
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTUCTORS
@@ -1315,7 +1312,7 @@ public:
 	m_offset = 0;
 	m_found = false;
 	// Iterate
-	concatp->accept(*this);
+        iterate(concatp);
 	UINFO(9,"CLK DECOMP Concat Offset (found = "<<m_found<<") ("<<m_found_offset<<") - "<<concatp<<" : "<<vscp<<endl);
 	offsetr = m_found_offset;
 	return m_found;
@@ -1370,10 +1367,10 @@ private:
     virtual VNUser visit(GateLogicVertex* lvertexp, VNUser vu) {
 	GateClkDecompState* currState = (GateClkDecompState*) vu.c();
 	int clk_offset = currState->m_offset;
-	if (AstAssignW* assignp = lvertexp->nodep()->castAssignW()) {
+        if (const AstAssignW* assignp = VN_CAST(lvertexp->nodep(), AssignW)) {
 	    UINFO(9,"CLK DECOMP Logic (off = "<<clk_offset<<") - "<<lvertexp<<" : "<<m_clk_vsp<<endl);
-	    if (AstSel* rselp = assignp->rhsp()->castSel()) {
-		if (rselp->lsbp()->castConst() && rselp->widthp()->castConst()) {
+            if (AstSel* rselp = VN_CAST(assignp->rhsp(), Sel)) {
+                if (VN_IS(rselp->lsbp(), Const) && VN_IS(rselp->widthp(), Const)) {
 		    if (clk_offset < rselp->lsbConst() || clk_offset > rselp->msbConst()) {
 			UINFO(9,"CLK DECOMP Sel [ "<<rselp->msbConst()<<" : "<<rselp->lsbConst()<<" ] dropped clock ("<<clk_offset<<")"<<endl);
 			return VNUser(0);
@@ -1382,7 +1379,7 @@ private:
 		} else {
 		    return VNUser(0);
 		}
-	    } else if (AstConcat* catp = assignp->rhsp()->castConcat()) {
+            } else if (AstConcat* catp = VN_CAST(assignp->rhsp(), Concat)) {
 		UINFO(9,"CLK DECOMP Concat searching - "<<assignp->lhsp()<<endl);
 		int concat_offset;
 		if (!m_concat_visitor.concatOffset(catp, currState->m_last_vsp, concat_offset)) {
@@ -1390,13 +1387,13 @@ private:
 		}
 		clk_offset += concat_offset;
 	    }
-	    if (AstSel* lselp = assignp->lhsp()->castSel()) {
-		if (lselp->lsbp()->castConst() && lselp->widthp()->castConst()) {
+            if (const AstSel* lselp = VN_CAST(assignp->lhsp(), Sel)) {
+                if (VN_IS(lselp->lsbp(), Const) && VN_IS(lselp->widthp(), Const)) {
 		    clk_offset += lselp->lsbConst();
 		} else {
 		    return VNUser(0);
 		}
-	    } else if (AstVarRef* vrp = assignp->lhsp()->castVarRef()) {
+            } else if (const AstVarRef* vrp = VN_CAST(assignp->lhsp(), VarRef)) {
 		if (vrp->dtypep()->width() == 1 && m_seen_clk_vectors) {
 		    if (clk_offset != 0) {
 			UINFO(9,"Should only make it here with clk_offset = 0"<<endl);
@@ -1468,7 +1465,7 @@ class GateDeassignVisitor : public GateBaseVisitor {
 private:
     // VISITORS
     virtual void visit(AstVarScope* nodep) {
-	if (AstNodeAssign* assp = nodep->valuep()->castNodeAssign()) {
+        if (AstNodeAssign* assp = VN_CAST(nodep->valuep(), NodeAssign)) {
 	    UINFO(5," Removeassign "<<assp<<endl);
 	    AstNode* valuep = assp->rhsp();
 	    valuep->unlinkFrBack();
@@ -1480,13 +1477,13 @@ private:
     virtual void visit(AstVar* nodep) {}
     virtual void visit(AstActive* nodep) {}
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
 public:
     // CONSTUCTORS
     explicit GateDeassignVisitor(AstNode* nodep) {
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~GateDeassignVisitor() {}
 };

src/V3GenClk.cpp

@@ -38,11 +38,7 @@
 
 class GenClkBaseVisitor : public AstNVisitor {
 protected:
-    static int debug() {
-	static int level = -1;
-	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
-	return level;
-    }
+    VL_DEBUG_FUNC;  // Declare debug()
 };
 
 //######################################################################
@@ -65,20 +61,20 @@ private:
     // METHODS
     AstVarScope* genInpClk(AstVarScope* vscp) {
 	if (vscp->user2p()) {
-	    return vscp->user2p()->castVarScope();
+            return VN_CAST(vscp->user2p(), VarScope);
 	} else {
 	    AstVar* varp = vscp->varp();
 	    string newvarname = "__VinpClk__"+vscp->scopep()->nameDotless()+"__"+varp->name();
 	    // Create:  VARREF(inpclk)
 	    //          ...
 	    //          ASSIGN(VARREF(inpclk), VARREF(var))
-	    AstVar* newvarp = new AstVar (varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
+            AstVar* newvarp = new AstVar(varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
 	    m_topModp->addStmtp(newvarp);
 	    AstVarScope* newvscp = new AstVarScope(vscp->fileline(), m_scopetopp, newvarp);
 	    m_scopetopp->addVarp(newvscp);
-	    AstAssign* asninitp = new AstAssign (vscp->fileline(),
-						 new AstVarRef(vscp->fileline(), newvscp, true),
-						 new AstVarRef(vscp->fileline(), vscp, false));
+            AstAssign* asninitp = new AstAssign(vscp->fileline(),
+                                                new AstVarRef(vscp->fileline(), newvscp, true),
+                                                new AstVarRef(vscp->fileline(), vscp, false));
 	    m_scopetopp->addFinalClkp(asninitp);
 	    //
 	    vscp->user2p(newvscp);
@@ -94,7 +90,7 @@ private:
 	if (!scopep) nodep->v3fatalSrc("No scope found on top level");
 	m_scopetopp = scopep;
 
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //----
     virtual void visit(AstVarRef* nodep) {
@@ -115,17 +111,18 @@ private:
     }
     virtual void visit(AstActive* nodep) {
 	m_activep = nodep;
-	nodep->sensesp()->iterateChildren(*this);  // iterateAndNext?
+        if (!nodep->sensesp()) nodep->v3fatalSrc("Unlinked");
+        iterateChildren(nodep->sensesp());  // iterateAndNext?
 	m_activep = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     virtual void visit(AstCFunc* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     //-----
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
@@ -133,7 +130,7 @@ public:
 	m_topModp = topModp;
 	m_scopetopp = NULL;
 	m_activep = NULL;
-	nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~GenClkRenameVisitor() {}
 };
@@ -157,7 +154,7 @@ private:
     // VISITORS
     virtual void visit(AstTopScope* nodep) {
 	AstNode::user1ClearTree();	// user1p() used on entire tree
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	{
 	    // Make the new clock signals and replace any activate references
 	    // See rename, it does some AstNode::userClearTree()'s
@@ -168,15 +165,15 @@ private:
 	// Only track the top scopes, not lower level functions
 	if (nodep->isTop()) {
 	    m_topModp = nodep;
-	    nodep->iterateChildren(*this);
+            iterateChildren(nodep);
 	}
     }
     virtual void visit(AstCCall* nodep) {
-        nodep->iterateChildren(*this);
+        iterateChildren(nodep);
         if (!nodep->funcp()->entryPoint()) {
             // Enter the function and trace it
             m_tracingCall = true;
-            nodep->funcp()->accept(*this);
+            iterate(nodep->funcp());
         }
     }
     virtual void visit(AstCFunc* nodep) {
@@ -187,7 +184,7 @@ private:
             return;
         }
         m_tracingCall = false;
-        nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
     //----
 
@@ -209,21 +206,22 @@ private:
     virtual void visit(AstNodeAssign* nodep) {
 	//UINFO(8,"ASS "<<nodep<<endl);
 	m_assignp = nodep;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
 	m_assignp = NULL;
     }
     virtual void visit(AstActive* nodep) {
 	UINFO(8,"ACTIVE "<<nodep<<endl);
 	m_activep = nodep;
-	nodep->sensesp()->iterateChildren(*this);  // iterateAndNext?
+        if (!nodep->sensesp()) nodep->v3fatalSrc("Unlinked");
+        iterateChildren(nodep->sensesp());  // iterateAndNext?
 	m_activep = NULL;
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 
     //-----
     virtual void visit(AstVar*) {}	// Don't want varrefs under it
     virtual void visit(AstNode* nodep) {
-	nodep->iterateChildren(*this);
+        iterateChildren(nodep);
     }
 public:
     // CONSTRUCTORS
@@ -232,7 +230,7 @@ public:
         , m_tracingCall(false)
         , m_assignp(NULL)
         , m_topModp(NULL) {
-        nodep->accept(*this);
+        iterate(nodep);
     }
     virtual ~GenClkReadVisitor() {}
 };

src/V3Global.h

@@ -22,6 +22,10 @@
 #define _V3GLOBAL_H_ 1
 
 #include "config_build.h"
+#ifndef HAVE_CONFIG_BUILD
+# error "Something failed during ./configure as config_build.h is incomplete. Perhaps you used autoreconf, don't."
+#endif
+
 #include "verilatedos.h"
 #include <string>
 
@@ -45,11 +49,11 @@ public:
 	VERILOG_WIDTH
     };
     enum en m_e;
-    inline VWidthMinUsage () : m_e(LINT_WIDTH) {}
+    inline VWidthMinUsage() : m_e(LINT_WIDTH) {}
     // cppcheck-suppress noExplicitConstructor
-    inline VWidthMinUsage (en _e) : m_e(_e) {}
-    explicit inline VWidthMinUsage (int _e) : m_e(static_cast<en>(_e)) {}
-    operator en () const { return m_e; }
+    inline VWidthMinUsage(en _e) : m_e(_e) {}
+    explicit inline VWidthMinUsage(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
   };
   inline bool operator== (VWidthMinUsage lhs, VWidthMinUsage rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (VWidthMinUsage lhs, VWidthMinUsage::en rhs) { return (lhs.m_e == rhs); }

src/V3Graph.cpp

@@ -33,7 +33,7 @@
 #include "V3Graph.h"
 
 int V3Graph::s_debug = 0;
-int V3Graph::debug() { return max(V3Error::debugDefault(), s_debug); }
+int V3Graph::debug() { return std::max(V3Error::debugDefault(), s_debug); }
 
 //######################################################################
 //######################################################################
@@ -81,9 +81,9 @@ void V3GraphVertex::rerouteEdges(V3Graph* graphp) {
     // Make new edges for each from/to pair
     for (V3GraphEdge* iedgep = inBeginp(); iedgep; iedgep=iedgep->inNextp()) {
 	for (V3GraphEdge* oedgep = outBeginp(); oedgep; oedgep=oedgep->outNextp()) {
-	    new V3GraphEdge (graphp, iedgep->fromp(), oedgep->top(),
-			     min(iedgep->weight(),oedgep->weight()),
-			     iedgep->cutable() && oedgep->cutable());
+            new V3GraphEdge(graphp, iedgep->fromp(), oedgep->top(),
+                            std::min(iedgep->weight(),oedgep->weight()),
+                            iedgep->cutable() && oedgep->cutable());
 	}
     }
     // Remove old edges
@@ -118,7 +118,41 @@ uint32_t V3GraphVertex::outHash() const {
     return hash;
 }
 
-ostream& operator<<(ostream& os, V3GraphVertex* vertexp) {
+V3GraphEdge* V3GraphVertex::findConnectingEdgep(GraphWay way,
+                                                const V3GraphVertex* waywardp) {
+    // O(edges) linear search. Searches search both nodes' edge lists in
+    // parallel.  The lists probably aren't _both_ huge, so this is
+    // unlikely to blow up even on fairly nasty graphs.
+    GraphWay inv = way.invert();
+    V3GraphEdge* aedgep = this->beginp(way);
+    V3GraphEdge* bedgep = waywardp->beginp(inv);
+    while (aedgep && bedgep) {
+        if (aedgep->furtherp(way) == waywardp) return aedgep;
+        if (bedgep->furtherp(inv) == this) return bedgep;
+        aedgep = aedgep->nextp(way);
+        bedgep = bedgep->nextp(inv);
+    }
+    return NULL;
+}
+
+void V3GraphVertex::v3errorEnd(std::ostringstream& str) const {
+    std::ostringstream nsstr;
+    nsstr<<str.str();
+    if (debug()) {
+        nsstr<<endl;
+        nsstr<<"-vertex: "<<this<<endl;
+    }
+    if (!fileline()) {
+        V3Error::v3errorEnd(nsstr);
+    } else {
+        fileline()->v3errorEnd(nsstr);
+    }
+}
+void V3GraphVertex::v3errorEndFatal(std::ostringstream& str) const {
+    v3errorEnd(str); assert(0);
+}
+
+std::ostream& operator<<(std::ostream& os, V3GraphVertex* vertexp) {
     os<<"  VERTEX="<<vertexp->name();
     if (vertexp->rank()) os<<" r"<<vertexp->rank();
     if (vertexp->fanout()!=0.0) os<<" f"<<vertexp->fanout();
@@ -133,8 +167,8 @@ ostream& operator<<(ostream& os, V3GraphVertex* vertexp) {
 void V3GraphEdge::init(V3Graph* graphp,
 		       V3GraphVertex* fromp, V3GraphVertex* top, int weight,
 		       bool cutable) {
-    UASSERT(fromp, "Null from pointer\n");
-    UASSERT(top, "Null to pointer\n");
+    UASSERT(fromp, "Null from pointer");
+    UASSERT(top, "Null to pointer");
     m_fromp = fromp;
     m_top = top;
     m_weight = weight;
@@ -239,12 +273,16 @@ void V3Graph::clearColors() {
 //======================================================================
 // Dumping
 
-void V3Graph::loopsVertexCb(V3GraphVertex* vertexp) {
-    // Needed here as V3GraphVertex<< isn't defined until later in header
-    cerr<<"-Info-Loop: "<<(void*)(vertexp)<<" "<<vertexp<<endl;
+void V3Graph::loopsMessageCb(V3GraphVertex* vertexp) {
+    vertexp->v3fatalSrc("Loops detected in graph: "<<vertexp);
 }
 
-void V3Graph::dump(ostream& os) {
+void V3Graph::loopsVertexCb(V3GraphVertex* vertexp) {
+    // Needed here as V3GraphVertex<< isn't defined until later in header
+    std::cerr<<"-Info-Loop: "<<(void*)(vertexp)<<" "<<vertexp<<endl;
+}
+
+void V3Graph::dump(std::ostream& os) {
     // This generates a file used by graphviz, http://www.graphviz.org
     os<<" Graph:\n";
     // Print vertices
@@ -254,15 +292,15 @@ void V3Graph::dump(ostream& os) {
 	os<<endl;
 	// Print edges
 	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep=edgep->inNextp()) {
-	    dumpEdge (os, vertexp, edgep);
+            dumpEdge(os, vertexp, edgep);
 	}
 	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
-	    dumpEdge (os, vertexp, edgep);
+            dumpEdge(os, vertexp, edgep);
 	}
     }
 }
 
-void V3Graph::dumpEdge(ostream& os, V3GraphVertex* vertexp, V3GraphEdge* edgep) {
+void V3Graph::dumpEdge(std::ostream& os, V3GraphVertex* vertexp, V3GraphEdge* edgep) {
     if (edgep->weight()
 	&& (edgep->fromp() == vertexp
 	    || edgep->top() == vertexp)) {
@@ -288,8 +326,8 @@ void V3Graph::dumpDotFilePrefixedAlways(const string& nameComment, bool colorAsS
 void V3Graph::dumpDotFile(const string& filename, bool colorAsSubgraph) const {
     // This generates a file used by graphviz, http://www.graphviz.org
     // "hardcoded" parameters:
-    const vl_unique_ptr<ofstream> logp (V3File::new_ofstream(filename));
-    if (logp->fail()) v3fatalSrc("Can't write "<<filename);
+    const vl_unique_ptr<std::ofstream> logp (V3File::new_ofstream(filename));
+    if (logp->fail()) v3fatal("Can't write "<<filename);
 
     // Header
     *logp<<"digraph v3graph {\n";
@@ -299,7 +337,7 @@ void V3Graph::dumpDotFile(const string& filename, bool colorAsSubgraph) const {
     *logp<<"\t\t rankdir="<<dotRankDir()<<"];\n";
 
     // List of all possible subgraphs
-    typedef multimap<string,V3GraphVertex*> SubgraphMmap;
+    typedef std::multimap<string,V3GraphVertex*> SubgraphMmap;
     SubgraphMmap subgraphs;
     for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	string vertexSubgraph = (colorAsSubgraph && vertexp->color()) ? cvtToStr(vertexp->color()) : "";
@@ -308,7 +346,7 @@ void V3Graph::dumpDotFile(const string& filename, bool colorAsSubgraph) const {
 
     // We use a map here, as we don't want to corrupt anything (userp) in the graph,
     // and we don't care if this is slow.
-    map<V3GraphVertex*,int>  numMap;
+    std::map<V3GraphVertex*,int>  numMap;
 
     // Print vertices
     int n=0;

src/V3Graph.h

@@ -24,10 +24,10 @@
 #include "verilatedos.h"
 #include "V3Error.h"
 #include "V3List.h"
-#include "V3Ast.h"
 #include <vector>
 #include <algorithm>
 
+class FileLine;
 class V3Graph;
 class V3GraphVertex;
 class V3GraphEdge;
@@ -41,6 +41,38 @@ class OrderLogicVertex;
 
 typedef bool (*V3EdgeFuncP)(const V3GraphEdge* edgep);
 
+//=============================================================================
+// When the Graph represents a directional acyclical graph (DAG), following
+// the to() edges is forward, and back() is reverse.  However, sometimes
+// it's useful to have algorithms that can walk in either direction, hence
+// some methods take GraphWay to programmatically select the direction.
+
+class GraphWay {
+public:
+    enum en { FORWARD=0,
+              REVERSE=1,
+              NUM_WAYS=2  // NUM_WAYS is not an actual way, it's typically
+              //          // an array dimension or loop bound.
+    };
+    enum en m_e;
+    inline GraphWay() : m_e(FORWARD) {}
+    // cppcheck-suppress noExplicitConstructor
+    inline GraphWay(en _e) : m_e(_e) {}
+    explicit inline GraphWay(int _e) : m_e(static_cast<en>(_e)) {}
+    operator en() const { return m_e; }
+    const char* ascii() const {
+        static const char* const names[] = { "FORWARD", "REVERSE" };
+        return names[m_e];
+    };
+    // METHODS unique to this class
+    GraphWay invert() const { return m_e == FORWARD ? REVERSE : FORWARD; }
+    bool forward() const { return m_e == FORWARD; }
+    bool reverse() const { return m_e != FORWARD; }
+};
+inline bool operator==(GraphWay lhs, GraphWay rhs) { return (lhs.m_e == rhs.m_e); }
+inline bool operator==(GraphWay lhs, GraphWay::en rhs) { return (lhs.m_e == rhs); }
+inline bool operator==(GraphWay::en lhs, GraphWay rhs) { return (lhs == rhs.m_e); }
+
 //============================================================================
 
 class V3Graph {
@@ -57,7 +89,7 @@ protected:
     void acyclicCut();
     void acyclicLoop(V3GraphVertex* vertexp, int depth);
     double orderDFSIterate(V3GraphVertex* vertexp);
-    void dumpEdge(ostream& os, V3GraphVertex* vertexp, V3GraphEdge* edgep);
+    void dumpEdge(std::ostream& os, V3GraphVertex* vertexp, V3GraphEdge* edgep);
     void verticesUnlink() { m_vertices.reset(); }
     // ACCESSORS
     static int debug();
@@ -102,8 +134,13 @@ public:
     /// Order all vertices by rank and fanout, lowest first
     /// Sort all vertices by rank and fanout, lowest first
     /// Sort all edges by weight, lowest first
+    /// Side-effect: assigns ranks to every node.
     void order();
 
+    // Similar to order() but does not assign ranks. Caller must
+    // ensure that the graph has been ranked ahead of the call.
+    void orderPreRanked();
+
     /// Make acyclical (into a tree) by breaking a minimal subset of cutable edges.
     void acyclic(V3EdgeFuncP edgeFuncp);
 
@@ -119,6 +156,12 @@ public:
     /// Remove any redundant edges, weights become SUM of any other weight
     void removeRedundantEdgesSum(V3EdgeFuncP edgeFuncp);
 
+    /// Remove any transitive edges.  E.g. if have edges A->B, B->C, and A->C
+    /// then A->C is a "transitive" edge; it's implied by the first two
+    /// (assuming the DAG is a dependency graph.)
+    /// This algorithm can be expensive.
+    void removeTransitiveEdges();
+
     /// Call loopsVertexCb on any one loop starting where specified
     void reportLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp);
 
@@ -126,7 +169,7 @@ public:
     void subtreeLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp, V3Graph* loopGraphp);
 
     /// Debugging
-    void dump(ostream& os=cout);
+    void dump(std::ostream& os=std::cout);
     void dumpDotFile(const string& filename, bool colorAsSubgraph) const;
     void dumpDotFilePrefixed(const string& nameComment, bool colorAsSubgraph=false) const;
     void dumpDotFilePrefixedAlways(const string& nameComment, bool colorAsSubgraph=false) const;
@@ -135,7 +178,7 @@ public:
     static void selfTest();
 
     // CALLBACKS
-    virtual void loopsMessageCb(V3GraphVertex* vertexp) { v3fatalSrc("Loops detected in graph: "<<vertexp); }
+    virtual void loopsMessageCb(V3GraphVertex* vertexp);
     virtual void loopsVertexCb(V3GraphVertex* vertexp);
 };
 
@@ -160,7 +203,6 @@ protected:
     void verticesPushBack(V3Graph* graphp);
     // ACCESSORS
     void fanout(double fanout) { m_fanout = fanout; }
-    void rank(uint32_t rank) { m_rank = rank; }
     void inUnlink() { m_ins.reset(); }	 // Low level; normally unlinkDelete is what you want
     void outUnlink() { m_outs.reset(); } // Low level; normally unlinkDelete is what you want
 protected:
@@ -182,6 +224,7 @@ public:
     virtual string dotStyle() const { return ""; }
     virtual string dotName() const { return ""; }
     virtual uint32_t rankAdder() const { return 1; }
+    virtual FileLine* fileline() const { return NULL; }  // NULL for unknown
     virtual int sortCmp(const V3GraphVertex* rhsp) const {
 	// LHS goes first if of lower rank, or lower fanout
 	if (m_rank < rhsp->m_rank) return -1;
@@ -193,6 +236,7 @@ public:
     uint32_t	color() const { return m_color; }
     void	color(uint32_t color) { m_color = color; }
     uint32_t	rank() const { return m_rank; }
+    void        rank(uint32_t rank) { m_rank = rank; }
     double	fanout() const { return m_fanout; }
     void	user(uint32_t user) { m_user = user; }
     uint32_t	user() const { return m_user; }
@@ -208,11 +252,20 @@ public:
     bool 	 outEmpty() const { return outBeginp()==NULL; }
     bool 	 outSize1() const;
     uint32_t	 outHash() const;
+    V3GraphEdge* beginp(GraphWay way) const {
+        return way.forward() ? outBeginp() : inBeginp(); }
     // METHODS
-    void	rerouteEdges(V3Graph* graphp);	///< Edges are routed around this vertex to point from "from" directly to "to"
+    /// Error reporting
+    void v3errorEnd(std::ostringstream& str) const;
+    void v3errorEndFatal(std::ostringstream& str) const;
+    /// Edges are routed around this vertex to point from "from" directly to "to"
+    void rerouteEdges(V3Graph* graphp);
+    /// Find the edge connecting ap and bp, where bp is wayward from ap.
+    /// If edge is not found returns NULL. O(edges) performance.
+    V3GraphEdge* findConnectingEdgep(GraphWay way, const V3GraphVertex* waywardp);
 };
 
-ostream& operator<<(ostream& os, V3GraphVertex* vertexp);
+std::ostream& operator<<(std::ostream& os, V3GraphVertex* vertexp);
 
 //============================================================================
 
@@ -274,14 +327,18 @@ public:
     void*	userp() const { return m_userp; }
     void 	user(uint32_t user) { m_user = user; }
     uint32_t	user() const { return m_user; }
-    V3GraphVertex*	fromp() const { return m_fromp; }
-    V3GraphVertex*	top() const { return m_top; }
+    V3GraphVertex* fromp() const { return m_fromp; }
+    V3GraphVertex* top() const { return m_top; }
+    V3GraphVertex* closerp(GraphWay way) const { return way.forward() ? fromp() : top(); }
+    V3GraphVertex* furtherp(GraphWay way) const { return way.forward() ? top() : fromp(); }
     // STATIC ACCESSORS
-    static bool	followNotCutable(const V3GraphEdge* edgep) { return !edgep->m_cutable; }
-    static bool	followAlwaysTrue(const V3GraphEdge*) { return true; }
+    static bool followNotCutable(const V3GraphEdge* edgep) { return !edgep->m_cutable; }
+    static bool followAlwaysTrue(const V3GraphEdge*) { return true; }
     // ITERATORS
     V3GraphEdge* outNextp() const { return m_outs.nextp(); }
     V3GraphEdge* inNextp() const { return m_ins.nextp(); }
+    V3GraphEdge* nextp(GraphWay way) const {
+        return way.forward() ? outNextp() : inNextp(); }
 };
 
 //============================================================================

src/V3GraphAcyc.cpp

@@ -56,6 +56,7 @@ public:
     bool isDelete() const { return m_deleted; }
     virtual string name() const { return m_origVertexp->name(); }
     virtual string dotColor() const { return m_origVertexp->dotColor(); }
+    virtual FileLine* fileline() const { return m_origVertexp->fileline(); }
 };
 
 //--------------------------------------------------------------------
@@ -63,7 +64,7 @@ public:
 class GraphAcycEdge : public V3GraphEdge {
     // userp() is always used to point to the head original graph edge
 private:
-    typedef list<V3GraphEdge*>	OrigEdgeList;	// List of orig edges, see also GraphAcyc's decl
+    typedef std::list<V3GraphEdge*> OrigEdgeList;  // List of orig edges, see also GraphAcyc's decl
     V3GraphEdge*	origEdgep() const {
 	OrigEdgeList* oEListp = ((OrigEdgeList*)userp());
 	if (!oEListp) v3fatalSrc("No original edge associated with acyc edge "<<this<<endl);
@@ -81,7 +82,7 @@ public:
 //--------------------------------------------------------------------
 
 struct GraphAcycEdgeCmp {
-    inline bool operator () (const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
+    inline bool operator() (const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
 	if (lhsp->weight() > rhsp->weight()) return 1;  // LHS goes first
 	if (lhsp->weight() < rhsp->weight()) return 0;  // RHS goes first
 	return 0;
@@ -93,7 +94,7 @@ struct GraphAcycEdgeCmp {
 // CLASSES
 class GraphAcyc {
 private:
-    typedef list<V3GraphEdge*>	OrigEdgeList;	// List of orig edges, see also GraphAcycEdge's decl
+    typedef std::list<V3GraphEdge*> OrigEdgeList;  // List of orig edges, see also GraphAcycEdge's decl
     // GRAPH USERS
     //  origGraph
     //    GraphVertex::user() 	GraphAycVerted*	New graph node
@@ -104,22 +105,22 @@ private:
     V3Graph*		m_origGraphp;		// Original graph
     V3Graph		m_breakGraph;		// Graph with only breakable edges represented
     V3List<GraphAcycVertex*>	m_work;		// List of vertices with optimization work left
-    vector<OrigEdgeList*>	m_origEdgeDelp;	// List of deletions to do when done
+    std::vector<OrigEdgeList*> m_origEdgeDelp;  // List of deletions to do when done
     V3EdgeFuncP		m_origEdgeFuncp;	// Function that says we follow this edge (in original graph)
     uint32_t		m_placeStep;		// Number that user() must be equal to to indicate processing
 
     static int debug() { return V3Graph::debug(); }
 
     // METHODS
-    void buildGraph (V3Graph* origGraphp);
-    void buildGraphIterate (V3GraphVertex* overtexp, GraphAcycVertex* avertexp);
-    void simplify (bool allowCut);
-    void simplifyNone (GraphAcycVertex* vertexp);
-    void simplifyOne (GraphAcycVertex* vertexp);
-    void simplifyOut (GraphAcycVertex* vertexp);
-    void simplifyDup (GraphAcycVertex* vertexp);
-    void cutBasic (GraphAcycVertex* vertexp);
-    void cutBackward (GraphAcycVertex* vertexp);
+    void buildGraph(V3Graph* origGraphp);
+    void buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* avertexp);
+    void simplify(bool allowCut);
+    void simplifyNone(GraphAcycVertex* vertexp);
+    void simplifyOne(GraphAcycVertex* vertexp);
+    void simplifyOut(GraphAcycVertex* vertexp);
+    void simplifyDup(GraphAcycVertex* vertexp);
+    void cutBasic(GraphAcycVertex* vertexp);
+    void cutBackward(GraphAcycVertex* vertexp);
     void deleteMarked();
     void place();
     void placeTryEdge(V3GraphEdge* edgep);
@@ -128,14 +129,14 @@ private:
     inline bool origFollowEdge(V3GraphEdge* edgep) {
 	return (edgep->weight() && (m_origEdgeFuncp)(edgep));
     }
-    V3GraphEdge* edgeFromEdge (V3GraphEdge* oldedgep, V3GraphVertex* fromp, V3GraphVertex* top) {
+    V3GraphEdge* edgeFromEdge(V3GraphEdge* oldedgep, V3GraphVertex* fromp, V3GraphVertex* top) {
 	// Make new breakGraph edge, with old edge as a template
-	GraphAcycEdge* newEdgep = new GraphAcycEdge (&m_breakGraph, fromp, top,
-						     oldedgep->weight(), oldedgep->cutable());
+        GraphAcycEdge* newEdgep = new GraphAcycEdge(&m_breakGraph, fromp, top,
+                                                    oldedgep->weight(), oldedgep->cutable());
 	newEdgep->userp(oldedgep->userp());	// Keep pointer to OrigEdgeList
 	return newEdgep;
     }
-    void addOrigEdgep (V3GraphEdge* toEdgep, V3GraphEdge* addEdgep) {
+    void addOrigEdgep(V3GraphEdge* toEdgep, V3GraphEdge* addEdgep) {
 	// Add addEdge (or it's list) to list of edges that break edge represents
 	// Note addEdge may already have a bunch of similar linked edge representations.  Yuk.
 	UASSERT(addEdgep, "Adding NULL");
@@ -154,7 +155,7 @@ private:
 	    oEListp->push_back(addEdgep);
 	}
     }
-    void cutOrigEdge (V3GraphEdge* breakEdgep, const char* why) {
+    void cutOrigEdge(V3GraphEdge* breakEdgep, const char* why) {
 	// From the break edge, cut edges in original graph it represents
 	UINFO(8,why<<" CUT "<<breakEdgep->fromp()<<endl);
 	breakEdgep->cut();
@@ -189,7 +190,7 @@ public:
 	m_placeStep = 0;
     }
     ~GraphAcyc() {
-	for (vector<OrigEdgeList*>::iterator it = m_origEdgeDelp.begin(); it != m_origEdgeDelp.end(); ++it) {
+        for (std::vector<OrigEdgeList*>::iterator it = m_origEdgeDelp.begin(); it != m_origEdgeDelp.end(); ++it) {
 	    delete (*it);
 	}
 	m_origEdgeDelp.clear();
@@ -199,7 +200,7 @@ public:
 
 //--------------------------------------------------------------------
 
-void GraphAcyc::buildGraph (V3Graph* origGraphp) {
+void GraphAcyc::buildGraph(V3Graph* origGraphp) {
     // Presumes the graph has been strongly ordered,
     // and thus there's a unique color if there are loops in this subgraph.
 
@@ -222,7 +223,7 @@ void GraphAcyc::buildGraph (V3Graph* origGraphp) {
     }
 }
 
-void GraphAcyc::buildGraphIterate (V3GraphVertex* overtexp, GraphAcycVertex* avertexp) {
+void GraphAcyc::buildGraphIterate(V3GraphVertex* overtexp, GraphAcycVertex* avertexp) {
     // Make new edges
     for (V3GraphEdge* edgep = overtexp->outBeginp(); edgep; edgep=edgep->outNextp()) {
 	if (origFollowEdge(edgep)) { // not cut
@@ -233,13 +234,13 @@ void GraphAcyc::buildGraphIterate (V3GraphVertex* overtexp, GraphAcycVertex* ave
 		// There may be multiple edges between same pairs of vertices
 		V3GraphEdge* breakEdgep = new GraphAcycEdge
 		    (&m_breakGraph, avertexp, toAVertexp, edgep->weight(), edgep->cutable());
-		addOrigEdgep (breakEdgep, edgep);  // So can find original edge
+                addOrigEdgep(breakEdgep, edgep);  // So can find original edge
 	    }
 	}
     }
 }
 
-void GraphAcyc::simplify (bool allowCut) {
+void GraphAcyc::simplify(bool allowCut) {
     // Add all nodes to list of work to do
     for (V3GraphVertex* vertexp = m_breakGraph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	workPush(vertexp);
@@ -263,7 +264,7 @@ void GraphAcyc::simplify (bool allowCut) {
     deleteMarked();
 }
 
-void GraphAcyc::deleteMarked () {
+void GraphAcyc::deleteMarked() {
     // Delete nodes marked for removal
     for (V3GraphVertex* nextp, *vertexp = m_breakGraph.verticesBeginp(); vertexp; vertexp=nextp) {
 	nextp = vertexp->verticesNextp();
@@ -274,7 +275,7 @@ void GraphAcyc::deleteMarked () {
     }
 }
 
-void GraphAcyc::simplifyNone (GraphAcycVertex* avertexp) {
+void GraphAcyc::simplifyNone(GraphAcycVertex* avertexp) {
     // Don't need any vertices with no inputs, There's no way they can have a loop.
     // Likewise, vertices with no outputs
     if (avertexp->isDelete()) return;
@@ -297,7 +298,7 @@ void GraphAcyc::simplifyNone (GraphAcycVertex* avertexp) {
     }
 }
 
-void GraphAcyc::simplifyOne (GraphAcycVertex* avertexp) {
+void GraphAcyc::simplifyOne(GraphAcycVertex* avertexp) {
     // If a node has one input and one output, we can remove it and change the edges
     if (avertexp->isDelete()) return;
     if (avertexp->inSize1() && avertexp->outSize1()) {
@@ -330,7 +331,7 @@ void GraphAcyc::simplifyOne (GraphAcycVertex* avertexp) {
     }
 }
 
-void GraphAcyc::simplifyOut (GraphAcycVertex* avertexp) {
+void GraphAcyc::simplifyOut(GraphAcycVertex* avertexp) {
     // If a node has one output that's not cutable, all its inputs can be reassigned
     // to the next node in the list
     if (avertexp->isDelete()) return;
@@ -366,7 +367,7 @@ void GraphAcyc::simplifyOut (GraphAcycVertex* avertexp) {
     }
 }
 
-void GraphAcyc::simplifyDup (GraphAcycVertex* avertexp) {
+void GraphAcyc::simplifyDup(GraphAcycVertex* avertexp) {
     // Remove redundant edges
     if (avertexp->isDelete()) return;
     // Clear marks
@@ -392,8 +393,8 @@ void GraphAcyc::simplifyDup (GraphAcycVertex* avertexp) {
 	    } else {
 		//  cutable duplicates prev  cutable: combine weights
 		UINFO(8,"    DelDupComb "<<avertexp<<" -> "<<edgep->top()<<endl);
-		prevEdgep->weight (prevEdgep->weight() + edgep->weight());
-		addOrigEdgep (prevEdgep, edgep);
+                prevEdgep->weight(prevEdgep->weight() + edgep->weight());
+                addOrigEdgep(prevEdgep, edgep);
 		edgep->unlinkDelete(); VL_DANGLING(edgep);
 	    }
 	    workPush(outVertexp);
@@ -405,20 +406,20 @@ void GraphAcyc::simplifyDup (GraphAcycVertex* avertexp) {
     }
 }
 
-void GraphAcyc::cutBasic (GraphAcycVertex* avertexp) {
+void GraphAcyc::cutBasic(GraphAcycVertex* avertexp) {
     // Detect and cleanup any loops from node to itself
     if (avertexp->isDelete()) return;
     for (V3GraphEdge* nextp, *edgep = avertexp->outBeginp(); edgep; edgep=nextp) {
 	nextp = edgep->outNextp();
 	if (edgep->cutable() && edgep->top()==avertexp) {
-	    cutOrigEdge (edgep, "  Cut Basic");
+            cutOrigEdge(edgep, "  Cut Basic");
 	    edgep->unlinkDelete(); VL_DANGLING(edgep);
 	    workPush(avertexp);
 	}
     }
 }
 
-void GraphAcyc::cutBackward (GraphAcycVertex* avertexp) {
+void GraphAcyc::cutBackward(GraphAcycVertex* avertexp) {
     // If a cutable edge is from A->B, and there's a non-cutable edge B->A, then must cut!
     if (avertexp->isDelete()) return;
     // Clear marks
@@ -432,7 +433,7 @@ void GraphAcyc::cutBackward (GraphAcycVertex* avertexp) {
     for (V3GraphEdge* nextp, *edgep = avertexp->outBeginp(); edgep; edgep=nextp) {
 	nextp = edgep->outNextp();
 	if (edgep->cutable() && edgep->top()->user()) {
-	    cutOrigEdge (edgep, "  Cut A->B->A");
+            cutOrigEdge(edgep, "  Cut A->B->A");
 	    edgep->unlinkDelete(); VL_DANGLING(edgep);
 	    workPush(avertexp);
 	}
@@ -453,7 +454,7 @@ void GraphAcyc::place() {
     }
     UINFO(4, "    Cutable edges = "<<numEdges<<endl);
 
-    vector<V3GraphEdge*>	edges;	// List of all edges to be processed
+    std::vector<V3GraphEdge*> edges;  // List of all edges to be processed
     edges.reserve(numEdges+1); // Make the vector properly sized right off the bat -- faster than reallocating
     for (V3GraphVertex* vertexp = m_breakGraph.verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	vertexp->user(0);	// Clear in prep of next step
@@ -469,7 +470,7 @@ void GraphAcyc::place() {
 
     // Process each edge in weighted order
     m_placeStep = 10;
-    for (vector<V3GraphEdge*>::iterator it = edges.begin(); it!=edges.end(); ++it) {
+    for (std::vector<V3GraphEdge*>::iterator it = edges.begin(); it!=edges.end(); ++it) {
 	V3GraphEdge* edgep = (*it);
 	placeTryEdge(edgep);
     }
@@ -496,7 +497,7 @@ void GraphAcyc::placeTryEdge(V3GraphEdge* edgep) {
     } else {
 	// Adding this edge would cause a loop, kill it
 	edgep->cutable(true);  // So graph still looks pretty
-	cutOrigEdge (edgep, "  Cut loop");
+        cutOrigEdge(edgep, "  Cut loop");
 	edgep->unlinkDelete(); VL_DANGLING(edgep);
 	// Backout the ranks we calculated
 	while (GraphAcycVertex* vertexp = workBeginp()) {
@@ -535,7 +536,7 @@ bool GraphAcyc::placeIterate(GraphAcycVertex* vertexp, uint32_t currentRank) {
 
 //----- Main algorithm entry point
 
-void GraphAcyc::main () {
+void GraphAcyc::main() {
     m_breakGraph.userClearEdges();
 
     // Color based on possible loops
@@ -545,7 +546,7 @@ void GraphAcyc::main () {
     // for each group of old vertices that are interconnected with unbreakable
     // edges (and thus can't represent loops - if we did the unbreakable
     // marking right, anyways)
-    buildGraph (m_origGraphp);
+    buildGraph(m_origGraphp);
     if (debug()>=6) m_breakGraph.dumpDotFilePrefixed("acyc_pre");
 
     // Perform simple optimizations before any cuttings

src/V3GraphAlg.cpp

@@ -30,6 +30,7 @@
 
 #include "V3Global.h"
 #include "V3GraphAlg.h"
+#include "V3GraphPathChecker.h"
 
 //######################################################################
 //######################################################################
@@ -74,7 +75,7 @@ void V3Graph::deleteCutableOnlyEdges() {
 //######################################################################
 // Algorithms - weakly connected components
 
-class GraphRemoveRedundant : GraphAlg {
+class GraphRemoveRedundant : GraphAlg<> {
     bool	m_sumWeights;		///< Sum, rather then maximize weights
 private:
     void main() {
@@ -121,24 +122,64 @@ private:
     }
 public:
     GraphRemoveRedundant(V3Graph* graphp, V3EdgeFuncP edgeFuncp, bool sumWeights)
-	: GraphAlg(graphp, edgeFuncp), m_sumWeights(sumWeights) {
+        : GraphAlg<>(graphp, edgeFuncp), m_sumWeights(sumWeights) {
 	main();
     }
     ~GraphRemoveRedundant() {}
 };
 
 void V3Graph::removeRedundantEdges(V3EdgeFuncP edgeFuncp) {
-    GraphRemoveRedundant (this, edgeFuncp, false);
+    GraphRemoveRedundant(this, edgeFuncp, false);
 }
 void V3Graph::removeRedundantEdgesSum(V3EdgeFuncP edgeFuncp) {
-    GraphRemoveRedundant (this, edgeFuncp, true);
+    GraphRemoveRedundant(this, edgeFuncp, true);
+}
+
+//######################################################################
+//######################################################################
+// Algorithms - remove transitive
+
+class GraphAlgRemoveTransitiveEdges : GraphAlg<> {
+public:
+    explicit GraphAlgRemoveTransitiveEdges(V3Graph* graphp)
+        : GraphAlg<>(graphp, NULL) {}
+    void go() {
+        GraphPathChecker checker(m_graphp);
+        for (V3GraphVertex* vxp = m_graphp->verticesBeginp();
+             vxp; vxp = vxp->verticesNextp()) {
+            V3GraphEdge* deletep = NULL;
+            for (V3GraphEdge* edgep = vxp->outBeginp();
+                 edgep; edgep = edgep->outNextp()) {
+                if (deletep) {
+                    deletep->unlinkDelete(); deletep = NULL;
+                }
+                // It should be safe to modify the graph, despite using
+                // the GraphPathChecker, as none of the modifications will
+                // change what can be reached from what, nor should they
+                // change the rank or CP of any node.
+                if (checker.isTransitiveEdge(edgep)) {
+                    deletep = edgep;
+                }
+            }
+            if (deletep) {
+                deletep->unlinkDelete(); VL_DANGLING(deletep);
+            }
+        }
+    }
+private:
+    VL_DEBUG_FUNC;  // Declare debug()
+    VL_UNCOPYABLE(GraphAlgRemoveTransitiveEdges);
+};
+
+void V3Graph::removeTransitiveEdges() {
+    GraphAlgRemoveTransitiveEdges(this).go();
 }
 
 //######################################################################
 //######################################################################
 // Algorithms - weakly connected components
 
-class GraphAlgWeakly : GraphAlg {
+class GraphAlgWeakly : GraphAlg<> {
 private:
     void main() {
 	// Initialize state
@@ -169,24 +210,24 @@ private:
     }
 public:
     GraphAlgWeakly(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	main();
     }
     ~GraphAlgWeakly() {}
 };
 
 void V3Graph::weaklyConnected(V3EdgeFuncP edgeFuncp) {
-    GraphAlgWeakly (this, edgeFuncp);
+    GraphAlgWeakly(this, edgeFuncp);
 }
 
 //######################################################################
 //######################################################################
 // Algorithms - strongly connected components
 
-class GraphAlgStrongly : GraphAlg {
+class GraphAlgStrongly : GraphAlg<> {
 private:
     uint32_t	m_currentDfs;		// DFS count
-    vector<V3GraphVertex*> m_callTrace;	// List of everything we hit processing so far
+    std::vector<V3GraphVertex*> m_callTrace;  // List of everything we hit processing so far
 
     void main() {
 	// Use Tarjan's algorithm to find the strongly connected subgraphs.
@@ -254,7 +295,7 @@ private:
     }
 public:
     GraphAlgStrongly(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	m_currentDfs = 0;
 	main();
     }
@@ -262,14 +303,14 @@ public:
 };
 
 void V3Graph::stronglyConnected(V3EdgeFuncP edgeFuncp) {
-    GraphAlgStrongly (this, edgeFuncp);
+    GraphAlgStrongly(this, edgeFuncp);
 }
 
 //######################################################################
 //######################################################################
 // Algorithms - ranking
 
-class GraphAlgRank : GraphAlg {
+class GraphAlgRank : GraphAlg<> {
 private:
     void main() {
 	// Rank each vertex, ignoring cutable edges
@@ -307,27 +348,27 @@ private:
     }
 public:
     GraphAlgRank(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	main();
     }
     ~GraphAlgRank() {}
 };
 
 void V3Graph::rank() {
-    GraphAlgRank (this, &V3GraphEdge::followAlwaysTrue);
+    GraphAlgRank(this, &V3GraphEdge::followAlwaysTrue);
 }
 
 void V3Graph::rank(V3EdgeFuncP edgeFuncp) {
-    GraphAlgRank (this, edgeFuncp);
+    GraphAlgRank(this, edgeFuncp);
 }
 
 //######################################################################
 //######################################################################
 // Algorithms - ranking
 
-class GraphAlgRLoops : GraphAlg {
+class GraphAlgRLoops : GraphAlg<> {
 private:
-    vector<V3GraphVertex*> m_callTrace;	// List of everything we hit processing so far
+    std::vector<V3GraphVertex*> m_callTrace;  // List of everything we hit processing so far
     bool		   m_done;	// Exit algorithm
 
     void main(V3GraphVertex* vertexp) {
@@ -365,7 +406,7 @@ private:
     }
 public:
     GraphAlgRLoops(V3Graph* graphp, V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	m_done = false;
 	main(vertexp);
     }
@@ -373,7 +414,7 @@ public:
 };
 
 void V3Graph::reportLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp) {
-    GraphAlgRLoops (this, edgeFuncp, vertexp);
+    GraphAlgRLoops(this, edgeFuncp, vertexp);
 }
 
 
@@ -381,7 +422,7 @@ void V3Graph::reportLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp) {
 //######################################################################
 // Algorithms - subtrees
 
-class GraphAlgSubtrees : GraphAlg {
+class GraphAlgSubtrees : GraphAlg<> {
 private:
     V3Graph* m_loopGraphp;
 
@@ -412,7 +453,7 @@ private:
 public:
     GraphAlgSubtrees(V3Graph* graphp, V3Graph* loopGraphp,
 		     V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp)
-	: GraphAlg(graphp, edgeFuncp), m_loopGraphp (loopGraphp) {
+        : GraphAlg<>(graphp, edgeFuncp), m_loopGraphp(loopGraphp) {
 	// Vertex::m_userp - New vertex if we have seen this vertex already
 	// Edge::m_userp - New edge if we have seen this edge already
 	m_graphp->userClearVertices();
@@ -425,7 +466,7 @@ public:
 //! Report the entire connected graph with a loop or loops
 void V3Graph::subtreeLoops(V3EdgeFuncP edgeFuncp, V3GraphVertex* vertexp,
 			   V3Graph* loopGraphp) {
-    GraphAlgSubtrees (this, loopGraphp, edgeFuncp, vertexp);
+    GraphAlgSubtrees(this, loopGraphp, edgeFuncp, vertexp);
 }
 
 //######################################################################
@@ -448,32 +489,32 @@ void V3Graph::makeEdgesNonCutable(V3EdgeFuncP edgeFuncp) {
 // Algorithms - sorting
 
 struct GraphSortVertexCmp {
-    inline bool operator () (const V3GraphVertex* lhsp, const V3GraphVertex* rhsp) const {
+    inline bool operator() (const V3GraphVertex* lhsp, const V3GraphVertex* rhsp) const {
 	return lhsp->sortCmp(rhsp) < 0;
     }
 };
 struct GraphSortEdgeCmp {
-    inline bool operator () (const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
+    inline bool operator() (const V3GraphEdge* lhsp, const V3GraphEdge* rhsp) const {
 	return lhsp->sortCmp(rhsp) < 0;
     }
 };
 
 void V3Graph::sortVertices() {
     // Sort list of vertices by rank, then fanout
-    vector<V3GraphVertex*> vertices;
+    std::vector<V3GraphVertex*> vertices;
     for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	vertices.push_back(vertexp);
     }
     std::stable_sort(vertices.begin(), vertices.end(), GraphSortVertexCmp());
     this->verticesUnlink();
-    for (vector<V3GraphVertex*>::iterator it = vertices.begin(); it!=vertices.end(); ++it) {
+    for (std::vector<V3GraphVertex*>::iterator it = vertices.begin(); it!=vertices.end(); ++it) {
 	(*it)->verticesPushBack(this);
     }
 }
 
 void V3Graph::sortEdges() {
     // Sort edges by rank then fanout of node they point to
-    vector<V3GraphEdge*> edges;
+    std::vector<V3GraphEdge*> edges;
     for (V3GraphVertex* vertexp = verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	// Make a vector
 	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
@@ -486,7 +527,7 @@ void V3Graph::sortEdges() {
 	// We know the vector contains all of the edges that were
 	// there originally (didn't delete or add)
 	vertexp->outUnlink();
-	for (vector<V3GraphEdge*>::const_iterator it = edges.begin(); it!=edges.end(); ++it) {
+        for (std::vector<V3GraphEdge*>::const_iterator it = edges.begin(); it!=edges.end(); ++it) {
 	    (*it)->outPushBack();
 	}
 	// Prep for next
@@ -507,7 +548,10 @@ void V3Graph::order() {
 
     // Compute rankings again
     rank(&V3GraphEdge::followAlwaysTrue);
+    orderPreRanked();
+}
 
+void V3Graph::orderPreRanked() {
     // Compute fanouts
     // Vertex::m_user begin: 1 indicates processing, 2 indicates completed
     userClearVertices();
@@ -529,7 +573,7 @@ double V3Graph::orderDFSIterate(V3GraphVertex* vertexp) {
     // Compute fanouts of each node
     // If forward edge, don't double count that fanout
     if (vertexp->user() == 2) return vertexp->fanout();  // Already processed it
-    if (vertexp->user() == 1) v3fatalSrc("Loop found, backward edges should be dead");
+    if (vertexp->user() == 1) vertexp->v3fatalSrc("Loop found, backward edges should be dead");
     vertexp->user(1);
     double fanout = 0;
     for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {

src/V3GraphAlg.h

@@ -30,17 +30,19 @@
 // Algorithms - common class
 // For internal use, most graph algorithms use this as a base class
 
+template <class T_Graph = V3Graph>  // Or sometimes const V3Graph
 class GraphAlg {
 protected:
-    V3Graph*	m_graphp;		// Graph we're operating upon
-    V3EdgeFuncP	m_edgeFuncp;		// Function that says we follow this edge
-
-    inline bool followEdge(V3GraphEdge* edgep) {
-	return (edgep->weight() && (m_edgeFuncp)(edgep));
-    }
-    GraphAlg(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: m_graphp(graphp), m_edgeFuncp(edgeFuncp) {}
+    T_Graph* m_graphp;  // Graph we're operating upon
+    V3EdgeFuncP m_edgeFuncp;  // Function that says we follow this edge
+    // CONSTRUCTORS
+    GraphAlg(T_Graph* graphp, V3EdgeFuncP edgeFuncp)
+        : m_graphp(graphp), m_edgeFuncp(edgeFuncp) {}
     ~GraphAlg() {}
+    // METHODS
+    inline bool followEdge(V3GraphEdge* edgep) {
+        return (edgep->weight() && (m_edgeFuncp)(edgep));
+    }
 };
 
 //============================================================================

src/V3GraphDfa.cpp

@@ -40,11 +40,11 @@ DfaVertex* DfaGraph::findStart() {
     for (V3GraphVertex* vertexp = this->verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	if (DfaVertex* vvertexp = dynamic_cast<DfaVertex*>(vertexp)) {
 	    if (vvertexp->start()) {
-		if (startp) v3fatalSrc("Multiple start points in NFA graph");
+                if (startp) vertexp->v3fatalSrc("Multiple start points in NFA graph");
 		startp = vvertexp;
 	    }
 	} else {
-	    v3fatalSrc("Non DfaVertex in DfaGraph");
+            vertexp->v3fatalSrc("Non DfaVertex in DfaGraph");
 	}
     }
     if (!startp) v3fatalSrc("No start point in NFA graph");
@@ -56,15 +56,15 @@ DfaVertex* DfaGraph::findStart() {
 // Algorithms - convert NFA to a DFA
 // Uses the Subset Construction Algorithm
 
-class GraphNfaToDfa : GraphAlg {
+class GraphNfaToDfa : GraphAlg<> {
     // We have two types of nodes in one graph, NFA and DFA nodes.
     // Edges from NFA to NFA come from the user, and indicate input or epsilon transitions
     // Edges from DFA to NFA indicate the NFA from which that DFA was formed.
     // Edges from DFA to DFA indicate a completed input transition
 private:
     // TYPES
-    typedef deque<DfaVertex*>		DfaStates;
-    typedef multimap<vluint64_t,DfaVertex*>	HashMap;
+    typedef std::deque<DfaVertex*> DfaStates;
+    typedef std::multimap<vluint64_t,DfaVertex*> HashMap;
 
     // MEMBERS
     uint32_t		m_step;		// Processing step, so we can avoid clearUser all the time
@@ -89,7 +89,7 @@ private:
     }
 
     DfaVertex* newDfaVertex(DfaVertex* nfaTemplatep=NULL) {
-	DfaVertex* vertexp = new DfaVertex (graphp());
+        DfaVertex* vertexp = new DfaVertex(graphp());
 	vertexp->color(1);  // Mark as dfa
 	if (nfaTemplatep && nfaTemplatep->start()) vertexp->start(true);
 	if (nfaTemplatep && nfaTemplatep->accepting()) vertexp->accepting(true);
@@ -116,7 +116,9 @@ private:
 		DfaVertex* nfaStatep = static_cast<DfaVertex*>(dfaEdgep->top());
 		hash ^= hashVertex(nfaStatep);
 		if (debug()) {
-		    if (nfaStatep->user()==m_step) v3fatalSrc("DFA state points to duplicate NFA state.");
+                    if (nfaStatep->user()==m_step) {
+                        nfaStatep->v3fatalSrc("DFA state points to duplicate NFA state.");
+                    }
 		    nfaStatep->user(m_step);
 		}
 	    }
@@ -174,7 +176,7 @@ private:
 	// The order of the nodes is not deterministic; the hash thus must not depend on order of edges
 	uint32_t hash = hashDfaOrigins(nfasWithInput);
 
-	pair <HashMap::iterator,HashMap::iterator> eqrange = m_hashMap.equal_range(hash);
+        std::pair<HashMap::iterator,HashMap::iterator> eqrange = m_hashMap.equal_range(hash);
 	for (HashMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
 	    DfaVertex* testp = it->second;
 	    if (compareDfaOrigins(nfasWithInput, testp)) {
@@ -280,7 +282,7 @@ private:
 	    UINFO(9,"  On dfaState "<<dfaStatep<<endl);
 
 	    // From this dfaState, what corresponding nfaStates have what inputs?
-	    set<int> inputs;
+            std::set<int> inputs;
 	    // Foreach NFA state (this DFA state was formed from)
 	    for (V3GraphEdge* dfaEdgep = dfaStatep->outBeginp(); dfaEdgep; dfaEdgep=dfaEdgep->outNextp()) {
 		if (nfaState(dfaEdgep->top())) {
@@ -299,7 +301,7 @@ private:
 	    }
 
 	    // Foreach input state (NFA inputs of this DFA state)
-	    for (set<int>::const_iterator inIt=inputs.begin(); inIt!=inputs.end(); ++inIt) {
+            for (std::set<int>::const_iterator inIt=inputs.begin(); inIt!=inputs.end(); ++inIt) {
 		DfaInput input = *inIt;
 		UINFO(9,"    ==="<<++i<<"=======================\n");
 		UINFO(9,"    On input "<<(void*)(input.toNodep())<<endl);
@@ -318,13 +320,13 @@ private:
 		    // Track what nfa's point to it.
 		    for (DfaStates::const_iterator nfaIt=nfasWithInput.begin(); nfaIt!=nfasWithInput.end(); ++nfaIt) {
 			UINFO(9,"          NewContainsNfa "<<*nfaIt<<endl);
-			new DfaEdge (graphp(), toDfaStatep, *nfaIt, DfaEdge::NA());
+                        new DfaEdge(graphp(), toDfaStatep, *nfaIt, DfaEdge::NA());
 			if ((*nfaIt)->accepting()) toDfaStatep->accepting(true);
 		    }
 		    insertDfaOrigins(toDfaStatep);
 		}
 		// Add input transition
-		new DfaEdge (graphp(), dfaStatep, toDfaStatep, input);
+                new DfaEdge(graphp(), dfaStatep, toDfaStatep, input);
 
 		if (debug()>=6) m_graphp->dumpDotFilePrefixed("step");
 	    }
@@ -346,7 +348,7 @@ private:
 
 public:
     GraphNfaToDfa(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	m_step = 0;
 	main();
     }
@@ -354,7 +356,7 @@ public:
 };
 
 void DfaGraph::nfaToDfa() {
-    GraphNfaToDfa (this, &V3GraphEdge::followAlwaysTrue);
+    GraphNfaToDfa(this, &V3GraphEdge::followAlwaysTrue);
 }
 
 //######################################################################
@@ -363,7 +365,7 @@ void DfaGraph::nfaToDfa() {
 //
 // Scan the DFA, cleaning up trailing states.
 
-class DfaGraphReduce : GraphAlg {
+class DfaGraphReduce : GraphAlg<> {
 private:
     // METHODS
     static int debug() { return 0; }
@@ -402,7 +404,7 @@ private:
 	m_graphp->userClearVertices();
 
 	DfaVertex* startp = graphp()->findStart();
-	stack<V3GraphVertex*> workps;  workps.push(startp);
+        std::stack<V3GraphVertex*> workps;  workps.push(startp);
 
 	// Mark all nodes connected to start
 	while (!workps.empty()) {
@@ -437,14 +439,14 @@ private:
 	m_graphp->userClearVertices();
 
 	// Find all dead vertexes
-	stack<DfaVertex*> workps;
+        std::stack<DfaVertex*> workps;
 	for (V3GraphVertex* vertexp = m_graphp->verticesBeginp(); vertexp; vertexp=vertexp->verticesNextp()) {
 	    if (DfaVertex* vvertexp = dynamic_cast<DfaVertex*>(vertexp)) {
 		workps.push(vvertexp);
 		vertexp->user(1);
 	    } else {
 		// If ever remove this, need dyn cast below
-		v3fatalSrc("Non DfaVertex in dfa graph");
+                vertexp->v3fatalSrc("Non DfaVertex in dfa graph");
 	    }
 	}
 
@@ -469,7 +471,7 @@ private:
     }
 public:
     DfaGraphReduce(V3Graph* graphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(graphp, edgeFuncp) {
+        : GraphAlg<>(graphp, edgeFuncp) {
 	if (debug()>=6) m_graphp->dumpDotFilePrefixed("opt_in");
 	optimize_accepting_out();
 	if (debug()>=6) m_graphp->dumpDotFilePrefixed("opt_acc");
@@ -482,7 +484,7 @@ public:
 };
 
 void DfaGraph::dfaReduce() {
-    DfaGraphReduce (this, &V3GraphEdge::followAlwaysTrue);
+    DfaGraphReduce(this, &V3GraphEdge::followAlwaysTrue);
 }
 
 //######################################################################
@@ -505,7 +507,7 @@ void DfaGraph::dfaReduce() {
 // The user's old accept is now the new accept.  This is imporant as
 // we want the virtual type of it to be intact.
 
-class DfaGraphComplement : GraphAlg {
+class DfaGraphComplement : GraphAlg<> {
 private:
     // MEMBERS
     DfaVertex* m_tempNewerReject;
@@ -547,7 +549,7 @@ private:
 			    // We make a edge for each value to OR, IE
 			    // edge(complemented,a) edge(complemented,b) means !(a | b)
 			    if (!tovertexp->accepting()) {  // Note we must include edges moved above to reject
-				DfaEdge* newp = new DfaEdge (graphp(), vvertexp, acceptp, vedgep);
+                                DfaEdge* newp = new DfaEdge(graphp(), vvertexp, acceptp, vedgep);
 				newp->complement(!newp->complement());
 				newp->user(1);
 			    }
@@ -559,7 +561,7 @@ private:
     }
 public:
     DfaGraphComplement(V3Graph* dfagraphp, V3EdgeFuncP edgeFuncp)
-	: GraphAlg(dfagraphp, edgeFuncp) {
+        : GraphAlg<>(dfagraphp, edgeFuncp) {
 	if (debug()>=6) m_graphp->dumpDotFilePrefixed("comp_in");
 
 	// Vertex::m_user begin: 1 indicates new edge, no more processing
@@ -576,5 +578,5 @@ public:
 };
 
 void DfaGraph::dfaComplement() {
-    DfaGraphComplement (this, &V3GraphEdge::followAlwaysTrue);
+    DfaGraphComplement(this, &V3GraphEdge::followAlwaysTrue);
 }

src/V3GraphDfa.h

@@ -24,6 +24,7 @@
 #include "verilatedos.h"
 #include <vector>
 
+#include "V3Ast.h"  // for VNUser
 #include "V3Global.h"
 #include "V3Graph.h"
 

src/V3GraphPathChecker.cpp

@@ -0,0 +1,167 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: DAG Path Checking
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2018 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.
+//
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+
+#include "V3GraphStream.h"
+#include "V3Global.h"
+#include "V3GraphPathChecker.h"
+
+//######################################################################
+// GraphPCNode
+
+struct GraphPCNode {
+    // User data for each node in GraphPathChecker.
+    //
+    // Like the LogicMTasks's, store before and after CPs for the nodes in
+    // the GraphPathChecker graph.
+    //
+    // Unlike the LogicMTasks's, we have no cost info for the generic graph
+    // accepted by GraphPathChecker, so assume each node has unit cost.
+    vluint32_t m_cp[GraphWay::NUM_WAYS];
+
+    // Detect if we've seen this node before in a given recursive
+    // operation. We'll use this in pathExistsInternal() to avoid checking
+    // the same node twice, and again in updateHalfCriticalPath() to assert
+    // there are no cycles.
+    vluint64_t m_seenAtGeneration;
+
+    // CONSTRUCTORS
+    GraphPCNode() : m_seenAtGeneration(0) {
+        for (int w = 0; w < GraphWay::NUM_WAYS; w++) m_cp[w] = 0;
+    }
+    ~GraphPCNode() { }
+};
+
+//######################################################################
+// GraphPathChecker implementation
+
+GraphPathChecker::GraphPathChecker(const V3Graph* graphp, V3EdgeFuncP edgeFuncp)
+    : GraphAlg<const V3Graph>(graphp, edgeFuncp)
+    , m_generation(0) {
+    for (V3GraphVertex* vxp = graphp->verticesBeginp();
+         vxp; vxp = vxp->verticesNextp()) {
+        // Setup tracking structure for each node.  If delete a vertex
+        // there would be a leak, but ok as accept only const V3Graph*'s.
+        vxp->userp(new GraphPCNode);
+    }
+    // Init critical paths in userp() for each vertex
+    initHalfCriticalPaths(GraphWay::FORWARD, false);
+    initHalfCriticalPaths(GraphWay::REVERSE, false);
+}
+
+GraphPathChecker::~GraphPathChecker() {
+    // Free every GraphPCNode
+    for (V3GraphVertex* vxp = m_graphp->verticesBeginp();
+         vxp; vxp = vxp->verticesNextp()) {
+        GraphPCNode* nodep = static_cast<GraphPCNode*>(vxp->userp());
+        delete nodep; VL_DANGLING(nodep);
+        vxp->userp(NULL);
+    }
+}
+
+void GraphPathChecker::initHalfCriticalPaths(GraphWay way, bool checkOnly) {
+    GraphStreamUnordered order(m_graphp, way);
+    GraphWay rev = way.invert();
+    while (const V3GraphVertex* vertexp = order.nextp()) {
+        unsigned critPathCost = 0;
+        for (V3GraphEdge* edgep = vertexp->beginp(rev);
+             edgep; edgep = edgep->nextp(rev)) {
+            if (!m_edgeFuncp(edgep)) continue;
+
+            V3GraphVertex* wrelativep = edgep->furtherp(rev);
+            GraphPCNode* wrelUserp = static_cast<GraphPCNode*>(wrelativep->userp());
+            critPathCost = std::max(critPathCost, wrelUserp->m_cp[way] + 1);
+        }
+
+        GraphPCNode* ourUserp = static_cast<GraphPCNode*>(vertexp->userp());
+        if (checkOnly) {
+            if (ourUserp->m_cp[way] != critPathCost) {
+                vertexp->v3fatalSrc("Validation of critical paths failed");
+            }
+        } else {
+            ourUserp->m_cp[way] = critPathCost;
+        }
+    }
+}
+
+bool GraphPathChecker::pathExistsInternal(const V3GraphVertex* ap,
+                                          const V3GraphVertex* bp,
+                                          unsigned* costp) {
+    GraphPCNode* auserp = static_cast<GraphPCNode*>(ap->userp());
+    GraphPCNode* buserp = static_cast<GraphPCNode*>(bp->userp());
+
+    // If have already searched this node on the current search, don't
+    // recurse through it again. Since we're still searching, we must not
+    // have found a path on the first go either.
+    if (auserp->m_seenAtGeneration == m_generation) {
+        if (costp) *costp = 0;
+        return false;
+    }
+    auserp->m_seenAtGeneration = m_generation;
+
+    if (costp) *costp = 1;  // count 'a' toward the search cost
+
+    if (ap == bp) return true;
+
+    // Rule out an a->b path based on their CPs
+    if (auserp->m_cp[GraphWay::REVERSE] < buserp->m_cp[GraphWay::REVERSE] + 1) {
+        return false;
+    }
+    if (buserp->m_cp[GraphWay::FORWARD] < auserp->m_cp[GraphWay::FORWARD] + 1) {
+        return false;
+    }
+
+    // Slow path; visit some extended family
+    bool foundPath = false;
+    for (V3GraphEdge* edgep = ap->outBeginp();
+         edgep && !foundPath; edgep = edgep->outNextp()) {
+        if (!m_edgeFuncp(edgep)) continue;
+
+        unsigned childCost;
+        if (pathExistsInternal(edgep->top(), bp, &childCost)) {
+            foundPath = true;
+        }
+        if (costp) *costp += childCost;
+    }
+
+    return foundPath;
+}
+
+bool GraphPathChecker::pathExistsFrom(const V3GraphVertex* fromp,
+                                      const V3GraphVertex* top) {
+    incGeneration();
+    return pathExistsInternal(fromp, top);
+}
+
+bool GraphPathChecker::isTransitiveEdge(const V3GraphEdge* edgep) {
+    const V3GraphVertex* fromp = edgep->fromp();
+    const V3GraphVertex* top = edgep->top();
+    incGeneration();
+    for (const V3GraphEdge* fromOutp = fromp->outBeginp();
+         fromOutp; fromOutp = fromOutp->outNextp()) {
+        if (fromOutp == edgep) continue;
+        if (pathExistsInternal(fromOutp->top(), top)) {
+            return true;
+        }
+    }
+    return false;
+}

src/V3GraphPathChecker.h

@@ -0,0 +1,68 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: DAG Path Checking
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2018 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.
+//
+//*************************************************************************
+
+#ifndef _V3GRAPHPATHCHECKER_H_
+#define _V3GRAPHPATHCHECKER_H_
+
+#include "V3Error.h"
+#include "V3Graph.h"
+#include "V3GraphAlg.h"
+
+//######################################################################
+
+/// Implement pathExistsFrom() with some caching to prune the search.
+/// Far more aggressive caching/pruning is possible; for now the use cases
+/// don't rely so heavily on this class that it's necessary.
+///
+/// The graph (or at least, the subset the algorithm sees through
+/// edgeFuncp) must not change during the lifetime of the checker.
+class GraphPathChecker : GraphAlg<const V3Graph> {
+    // Count "generations" which increases on operations that scan through
+    // the graph. Each node is marked with the last generation that scanned
+    // it, to enable asserting there are no cycles, and to avoid recursing
+    // through the same node twice while searching for a path.
+    vluint64_t m_generation;
+
+ public:
+    // CONSTRUCTORS
+    GraphPathChecker(const V3Graph* graphp,
+                     V3EdgeFuncP edgeFuncp = V3GraphEdge::followAlwaysTrue);
+    ~GraphPathChecker();
+
+    // METHODS
+    bool pathExistsFrom(const V3GraphVertex* fromp, const V3GraphVertex* top);
+
+    // If have edges A->B, B->C, and A->C then A->C is considered a
+    // "transitive" edge (implied by A->B and B->C) and it could be safely
+    // removed. Detect such an edge.
+    bool isTransitiveEdge(const V3GraphEdge* edgep);
+
+ private:
+    bool pathExistsInternal(const V3GraphVertex* ap,
+                            const V3GraphVertex* bp,
+                            unsigned* costp = NULL);
+    void initHalfCriticalPaths(GraphWay w, bool checkOnly);
+    void incGeneration() { ++m_generation; }
+
+    VL_DEBUG_FUNC;  // Declare debug()
+    VL_UNCOPYABLE(GraphPathChecker);
+};
+
+#endif  // Guard

src/V3GraphStream.h

@@ -0,0 +1,246 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Dependency graph iterator. Iterates over nodes
+//                         in any DAG, following dependency order.
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2018 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.
+//
+//*************************************************************************
+
+#ifndef _V3GRAPHSTREAM_H_
+#define _V3GRAPHSTREAM_H_
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <set>
+#include VL_INCLUDE_UNORDERED_MAP
+
+#include "V3Graph.h"
+
+//######################################################################
+// GraphStream
+//
+// Template 'T_Compare' is a tie-breaker for ordering nodes that the DAG
+// itself does not order. It must provide an operator() that does a logical
+// less-than on two V3GraphVertex*'s, with the same signature as
+// std::less<const V3GraphVertex*>::operator().  This does not default to
+// std::less<const V3GraphVertex*> because that is nondeterministic, and so
+// not generally safe. If you want a raw pointer compare, see
+// GraphStreamUnordered below.
+
+template <class T_Compare> class GraphStream {
+private:
+    // TYPES
+    class VxHolder {
+    public:
+        // MEMBERS
+        const V3GraphVertex* m_vxp;  // [mtask] Vertex
+        uint32_t m_pos;  // Sort position
+        uint32_t m_numBlockingEdges;  // Number of blocking edges
+        // CONSTRUCTORS
+        VxHolder(const V3GraphVertex* vxp, uint32_t pos, uint32_t numBlockingEdges)
+            : m_vxp(vxp)
+            , m_pos(pos)
+            , m_numBlockingEdges(numBlockingEdges) {}
+        // METHODS
+        const V3GraphVertex* vertexp() const { return m_vxp; }
+        // Decrement blocking edges count, return true if the vertex is
+        // newly unblocked
+        bool unblock() {
+            if (m_numBlockingEdges <= 0) vertexp()->v3fatalSrc("Underflow of blocking edges");
+            m_numBlockingEdges--;
+            return (m_numBlockingEdges == 0);
+        }
+    };
+
+    class VxHolderCmp {
+    public:
+        // MEMBERS
+        T_Compare m_lessThan;  // Sorting functor
+        // CONSTRUCTORS
+        explicit VxHolderCmp(const T_Compare& lessThan)
+            : m_lessThan(lessThan) {}
+        // METHODS
+        bool operator() (const VxHolder& a, const VxHolder& b) const {
+            if (m_lessThan.operator()(a.vertexp(), b.vertexp())) return true;
+            if (m_lessThan.operator()(b.vertexp(), a.vertexp())) return false;
+            return a.m_pos < b.m_pos;
+        }
+    private:
+        VL_UNCOPYABLE(VxHolderCmp);
+    };
+
+    typedef std::set<VxHolder, VxHolderCmp&> ReadyVertices;
+    typedef vl_unordered_map<const V3GraphVertex*, VxHolder> WaitingVertices;
+
+    // MEMBERS
+    VxHolderCmp m_vxHolderCmp;  // Vertext comparison functor
+    ReadyVertices m_readyVertices;  // List of ready verticies
+    WaitingVertices m_waitingVertices;  // List of wiating verticies
+    typename ReadyVertices::iterator m_last;  // Previously returned element
+    GraphWay m_way;  // FORWARD or REVERSE order of traversal
+
+public:
+    // CONSTRUCTORS
+    GraphStream(const V3Graph* graphp,
+                GraphWay way = GraphWay::FORWARD,
+                const T_Compare& lessThan = T_Compare())
+        // NOTE: Perhaps REVERSE way should also reverse the sense of the
+        // lessThan function? For now the only usage of REVERSE is not
+        // sensitive to its lessThan at all, so it doesn't matter.
+        : m_vxHolderCmp(lessThan)
+        , m_readyVertices(m_vxHolderCmp)
+        , m_last(m_readyVertices.end())
+        , m_way(way) {
+        uint32_t pos = 0;
+        for (const V3GraphVertex* vxp = graphp->verticesBeginp();
+             vxp; vxp=vxp->verticesNextp()) {
+            // Every vertex initially is waiting, or ready.
+            if (way == GraphWay::FORWARD) {
+                if (vxp->inEmpty()) {
+                    VxHolder newVx(vxp, pos++, 0);
+                    m_readyVertices.insert(newVx);
+                } else {
+                    uint32_t depCount = 0;
+                    for (V3GraphEdge* depp = vxp->inBeginp();
+                         depp; depp = depp->inNextp()) {
+                        depCount++;
+                    }
+                    VxHolder newVx(vxp, pos++, depCount);
+                    m_waitingVertices.insert(make_pair(vxp, newVx));
+                }
+            } else {  // REVERSE
+                if (vxp->outEmpty()) {
+                    VxHolder newVx(vxp, pos++, 0);
+                    m_readyVertices.insert(newVx);
+                } else {
+                    uint32_t depCount = 0;
+                    for (V3GraphEdge* depp = vxp->outBeginp();
+                         depp; depp = depp->outNextp()) {
+                        depCount++;
+                    }
+                    VxHolder newVx(vxp, pos++, depCount);
+                    m_waitingVertices.insert(make_pair(vxp, newVx));
+                }
+            }
+        }
+    }
+    ~GraphStream() {}
+
+    // METHODS
+
+    // Each call to nextp() returns a unique vertex in the graph, in
+    // dependency order.
+    //
+    // Dependencies alone don't fully specify the order. Usually a graph
+    // has many "ready" vertices, any of which might return next.
+    //
+    // To decide among the "ready" vertices, GraphStream keeps an ordered
+    // list of ready vertices, sorted first by lessThan and second by
+    // original graph order.
+    //
+    // You might expect that nextp() would return the first item from this
+    // sorted list -- but that's not what it does!  What nextp() actually
+    // does is to return the next item in the list, following the position
+    // where the previously-returned item would have been.  This maximizes
+    // locality: given an appropriate lessThan, nextp() will stay on a
+    // given domain (or domscope, or mtask, or whatever) for as long as
+    // possible before an unmet dependency forces us to switch to another
+    // one.
+    //
+    // Within a group of vertices that lessThan considers equivalent,
+    // nextp() returns them in the original graph order (presumably also
+    // good locality.) V3Order.cpp relies on this to order the logic
+    // vertices within a given mtask without jumping over domains too much.
+    const V3GraphVertex* nextp() {
+        const V3GraphVertex* resultp = NULL;
+
+        typename ReadyVertices::iterator curIt;
+        if (m_last == m_readyVertices.end()) {
+            // First call to nextp()
+            curIt = m_readyVertices.begin();
+        } else {
+            // Subsequent call to nextp()
+            curIt = m_last;
+            ++curIt;
+            // Remove previously-returned element
+            m_readyVertices.erase(m_last);
+            // Wrap curIt. Expect to wrap, and make another pass, to find
+            // newly-ready elements that could have appeared ahead of the
+            // m_last iterator
+            if (curIt == m_readyVertices.end()) {
+                curIt = m_readyVertices.begin();
+            }
+        }
+
+        if (curIt != m_readyVertices.end()) {
+            resultp = curIt->vertexp();
+            unblockDeps(resultp);
+        } else {
+            // No ready vertices; waiting should be empty too, otherwise we
+            // were fed a graph with cycles (which is not supported.)
+            UASSERT(m_waitingVertices.empty(), "DGS fed non-DAG");
+        }
+
+        m_last = curIt;
+        return resultp;
+    }
+
+private:
+    void unblockDeps(const V3GraphVertex* vertexp) {
+        if (m_way == GraphWay::FORWARD) {
+            for (V3GraphEdge* edgep = vertexp->outBeginp();
+                 edgep; edgep=edgep->outNextp()) {
+                V3GraphVertex* toVertexp = edgep->top();
+
+                typename WaitingVertices::iterator it =
+                    m_waitingVertices.find(toVertexp);
+                if (it == m_waitingVertices.end()) {
+                    toVertexp->v3fatalSrc("Found edge into vertex not in waiting list.");
+                }
+                if (it->second.unblock()) {
+                    m_readyVertices.insert(it->second);
+                    m_waitingVertices.erase(it);
+                }
+            }
+        } else {
+            for (V3GraphEdge* edgep = vertexp->inBeginp();
+                 edgep; edgep=edgep->inNextp()) {
+                V3GraphVertex* fromVertexp = edgep->fromp();
+
+                typename WaitingVertices::iterator it =
+                    m_waitingVertices.find(fromVertexp);
+                if (it == m_waitingVertices.end()) {
+                    fromVertexp->v3fatalSrc("Found edge into vertex not in waiting list.");
+                }
+                if (it->second.unblock()) {
+                    m_readyVertices.insert(it->second);
+                    m_waitingVertices.erase(it);
+                }
+            }
+        }
+    }
+
+    VL_UNCOPYABLE(GraphStream);
+};
+
+//######################################################################
+
+// GraphStreamUnordered is GraphStream using a plain pointer compare to
+// break ties in the graph order. This WILL return nodes in
+// nondeterministic order.
+typedef GraphStream<std::less<const V3GraphVertex*> > GraphStreamUnordered;
+
+#endif  // Guard