Version bump

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

.gitignore

@@ -24,3 +24,4 @@ internals.txt
 verilator.txt
 verilator_bin*
 verilator_coverage_bin*
+verilator.pc

Changes

@@ -1,9 +1,383 @@
 Revision history for Verilator
 
-The contributors that suggested a given feature are shown in [].  [by ...]
-indicates the contributor was also the author of the fix; Thanks!
+The contributors that suggested a given feature are shown in []. Thanks!
 
-* Verilator 3.867 devel
+* Verilator 3.910 2017-09-07
+
+***   SystemPerl mode (-sp-deprecated) has been removed.
+
+****  Update keyword warnings to include C++11 and others.
+
+
+* Verilator 3.908 2017-08-28
+
+****  Support x in $readmem, bug1180. [Arthur Kahlich]
+
+****  Support packed struct DPI imports, bug1190. [Rob Stoddard]
+
+****  Fix GCC 6 warnings.
+
+****  Fix compile error on unused VL_VALUEPLUSARGS_IW, bug1181. [Thomas J Whatson]
+
+****  Fix undefined VL_POW_WWI. [Clifford Wolf]
+
+****  Fix internal error on unconnected inouts, bug1187. [Rob Stoddard]
+
+
+* Verilator 3.906 2017-06-22
+
+***   Support set_time_unit/set_time_precision in C traces, msg2261.
+
+***   Fix extract of packed array with non-zero LSB, bug1172. [James Pallister]
+
+***   Fix shifts by more than 32-bit numbers, bug1174. [Clifford Wolf]
+
+***   Fix power operator on wide constants, bug761. [Clifford Wolf]
+
+***   Fix .* on interface pins, bug1176. [Maciej Piechotka]
+
+
+* Verilator 3.904 2017-05-30
+
+***   Fix non-cutable ordering loops on clock arrays, bug1009. [Todd Strader]
+
+***   Support ports of array of reals, bug1154. [J Briquet]
+
+***   Support arrayed parameter overrides, bug1153. [John Stevenson]
+
+***   Support $value$plusargs with variables, bug1165. [Wesley Terpstra]
+
+****  Support modport access to un-modport objects, bug1161. [Todd Strader]
+
+****  Add stack trace when can't optimize function, bug1158. [Todd Strader]
+
+****  Add warning on mis-sized literal, bug1156. [Todd Strader]
+
+****  Fix interface functions returning wrong parameters, bug996. [Todd Strader]
+
+****  Fix non-arrayed cells with interface arrays, bug1153. [John Stevenson]
+
+****  Fix --assert with complex case statements, bug1164. [Enzo Chi]
+
+
+* Verilator 3.902 2017-04-02
+
+**    Add -FI option to force includes,msg2146. [Amir Gonnen]
+
+**    Add --relative-includes. [Rob Stoddard]
+
+***   Add error on duplicate pattern assignments, bug1145. [Johan Bjork]
+
+****  Fix error on improperly widthed default function, bug984. [Todd Strader]
+
+****  Fix 2009 localparam syntax, msg2139. [Galen Seitz]
+
+****  Fix ugly interface-to-non-interface errors, bug1112. [Johan Bjork]
+
+****  Fix LDFLAGS and CFLAGS not preserving order, bug1130. [Olof Kindgren]
+
+****  Fix internal error on initializing parameter array, bug1131. [Jie Xu]
+
+****  Fix internal error on interface arrays, bug1135. [John Stevenson]
+
+****  Fix calling sformatf to display, and elab $displays, bug1139. [Johan Bjork]
+
+****  Fix realpath compile issue on MSVC++, bug1141. [Miodrag Milanovic]
+
+****  Fix missing error on interface size mismatch, bug1143.  [Johan Bjork]
+
+****  Fix error on parameters with dotted references, bug1146. [Johan Bjork]
+
+****  Fix wreal not handling continuous assign, bug1150. [J Briquet]
+
+****  Fix nested structure parameter selects, bug1150. [J Briquet]
+
+
+* Verilator 3.900 2017-01-15
+
+**    Internal code changes for improved compatibility and performance.
+
+***   Support old-style $display($time), bug467. [John Demme]
+
+****  With --bbox-unsup, suppress desassign and mixed edges, bug1120. [Galen Seitz]
+
+****  Fix parsing sensitivity with &&, bug934. [Luke Yang]
+
+****  Fix internal error on double-for loop unrolling, bug1044. [Jan Egil Ruud]
+
+****  Fix internal error on unique casez with --assert, bug1117. [Enzo Chi]
+
+****  Fix bad code when tracing array of structs, bug1122. [Andrew Bardsley]
+
+
+* Verilator 3.890 2016-11-25
+
+***   Honor --output-split on coverage constructors, bug1098. [Johan Bjork]
+
+****  Fix various issues when making outside of the kit.
+
+****  Fix flex 2.6.2 bug, bug1103. [Sergey Kvachonok]
+
+****  Fix error on bad interface name, bug1097. [Todd Strader]
+
+****  Fix error on referencing variable in parent, bug1099. [Ian Thompson]
+
+****  Fix type parameters with low optimization, bug1101. [Stefan Wallentowitz]
+
+
+* Verilator 3.888 2016-10-14
+
+**    Support foreach, bug1078. [Xuan Guo]
+
+***   Add --no-decoration to remove output comments, msg2015. [Frederic Requin]
+
+***   If VM_PARALLEL_BUILDS=1, use OPT_FAST and OPT_SLOW. [Frederic Requin]
+      Set VM_DEFAULT_RULES=0 for old behavior.
+
+****  Add error on DPI functions > 32 bits, msg1995. [Elliot Mednick]
+
+****  Fix SystemC compiles with VPI, bug1081. [Arthur Kahlich]
+
+****  Fix error on wide numbers that represent shifts, msg1991, bug1088. [Mandy Xu]
+
+****  Improve Verilation performance on internal strings, msg1975. [Johan Bjork]
+
+****  Improve Verilation performance on trace duplicates, bug1090. [Johan Bjork]
+
+
+* Verilator 3.886 2016-07-30
+
+****  Fix enum values of 11-16 bits wide using .next/.prev, bug1062. [Brian Flachs]
+
+****  Fix false warnings on non-power-2 enums using .next/.prev.
+
+****  Fix comparison of unpacked arrays, bug1071. [Andrew Bardsley]
+
+****  Fix compiler warning in GCC 6. [David Horton]
+
+
+* Verilator 3.884 2016-05-18
+
+**    Support parameter type, bug376. [Alan Hunter, et al]
+
+**    Support command-line -G/+pvalue param overrides, bug1045. [Stefan Wallentowitz]
+
+***   The default l2 scope name is now the same as the top-level module, bug1050.
+      Use "--l2-name v" for the historical behavior.
+
+***   Add --l2-name option for controlling "v" naming.
+
+****  Fix --output-split of constructors, bug1035. [Johan Bjork]
+
+****  Fix removal of empty packages, modules and cells, bug1034. [Johan Bjork]
+
+****  Fix core dump on Arch Linux/GCC 6.1.1, bug1058. [Jannis Harder]
+
+****  Fix $value$plusargs to string, msg1890. [Frederic Requin]
+
+
+* Verilator 3.882 2016-03-01
+
+****  Internal Verilation-time performance enhancements, bug1021. [Johan Bjork]
+
+****  Support inlining interfaces, bug1018. [Johan Bjork]
+
+****  Support SV strings to readmemh, bug1040. [Stefan Wallentowitz]
+
+****  Fix unrolling complicated for-loop bounds, bug677. [Johan Bjork]
+
+****  Fix stats file containing multiple unroll entries, bug1020. [Johan Bjork]
+
+****  Fix using short parameter names on negative params, bug1022. [Duraid Madina]
+
+****  Fix read-after-free error, bug1031. [Johan Bjork]
+
+****  Fix elaboration-time display warnings, bug1032. [Johan Bjork]
+
+****  Fix crash on very deep function trees, bug1028. [Jonathan Kimmitt]
+
+****  Fix slicing mix of big and little-endian, bug1033. [Geoff Barrett]
+
+****  Fix pattern assignment width propagation, bug1037. [Johan Bjork]
+
+
+* Verilator 3.880 2015-12-19
+
+***   Support display %u, %v, %p, %z, bug989. [Johan Bjork]
+
+****  Fix real parameters causing bad module names, bug992. [Johan Bjork]
+
+****  Fix size-changing cast on packed struct, bug993. [Johan Bjork]
+
+****  Fix function calls on arrayed interface, bug994. [Johan Bjork]
+
+****  Fix arrayed interfaces, bug879, bug1001. [Todd Strader]
+
+****  Fix constant function assigned to packed structs, bug997. [Johan Bjork]
+
+****  Fix interface inside generate, bug998. [Johan Bjork]
+
+****  Fix $signed casts under generates, bug999. [Clifford Wolf]
+
+****  Fix genvar constant propagation, bug1003. [Johan Bjork]
+
+****  Fix parameter constant propagation from package, bug1004. [Johan Bjork]
+
+****  Fix array slicing of non-const indexes, bug1006. [Johan Bjork]
+
+****  Fix dotted generated array error, bug1005. [Jeff Bush, Johan Bjork]
+
+****  Fix error instead of warning on large concat, msg1768. [Paul Rolfe]
+
+****  Fix $bitstoreal constant propagation, bug1012. [Jonathan Kimmitt]
+
+****  Fix model restore crash, bug1013. [Jason McMullan]
+
+****  Fix arrayed instances to unpacked of same size, bug1015. [Varun Koyyalagunta]
+
+****  Fix slices of unpacked arrays with non-zero LSBs.
+
+****  Fix ternary operation with unpacked array, bug1017. [Varun Koyyalagunta].
+
+
+* Verilator 3.878 2015-11-01
+
+**    Add --vpi flag, and fix VPI linkage, bug969. [Arthur Kahlich]
+
+**    Support genvar indexes into arrayed cells, bug517.  [Todd Strader]
+
+**    Support $sformatf, bug977. [Johan Bjork]
+
+***   Support elaboration assertions, bug973. [Johan Bjork]
+
+***   Support $display with non-format arguments, bug467. [Jamey Hicks]
+
+****  Add VerilatedScopeNameMap for introspection, bug966. [Todd Strader]
+
+****  Ignore %l in $display, bug983. [Todd Strader]
+
+****  Fix very long module names, bug937. [Todd Strader]
+
+****  Fix internal error on dotted refs into generates, bug958. [Jie Xu]
+
+****  Fix structure parameter constant propagation, bug968. [Todd Strader]
+
+****  Fix enum constant propagation, bug970. [Todd Strader]
+
+****  Fix mis-optimizing public DPI functions, bug963. [Wei Song]
+
+****  Fix package:scope.scope variable references.
+
+****  Fix $fwrite to constant stderr/stdout, bug961. [Wei Song]
+
+****  Fix struct.enum.name method calls, bug855. [Jonathon Donaldson]
+
+****  Fix dot indexing into arrayed inferfaces, bug978.  [Johan Bjork]
+
+****  Fix crash in commandArgsPlusMatch, bug987. [Jamie Iles]
+
+****  Fix error message on missing interface, bug985. [Todd Strader]
+
+
+* Verilator 3.876 2015-08-12
+
+***   Add tracing_on, etc to vlt files, bug932. [Frederic Requin]
+
+****  Support extraction of enum bits, bug951. [Jonathon Donaldson]
+
+****  Fix MinGW compiler error, bug927, bug929. [Hans Tichelaar]
+
+****  Fix .c files to be treated as .cpp, bug930. [Jonathon Donaldson]
+
+****  Fix string-to-int space conversion, bug931. [Fabrizio Ferrandi]
+
+****  Fix dpi imports inside generates. [Michael Tresidder]
+
+****  Fix rounding in trace $timescale, bug946. [Frederic Requin]
+
+****  Fix $fopen with SV string, bug947. [Sven Stucki]
+
+****  Fix hashed error with typedef inside block, bug948. [Sven Stucki]
+
+****  Fix makefile with --coverage, bug953. [Eivind Liland]
+
+****  Fix coverage documentation, bug954. [Thomas J Whatson]
+
+****  Fix parameters with function parameter arguments, bug952. [Jie Xu]
+
+****  Fix size casts as second argument of cast item, bug950. [Jonathon Donaldson]
+
+
+* Verilator 3.874 2015-06-06
+
+***   Add pkg-config .pc file, bug919. [Stefan Wallentowitz]
+
+****  Fix installing missing manpages, bug908. [Ahmed El-Mahmoudy]
+
+****  Fix sign extension in large localparams, bug910. [Mike Thyer]
+
+****  Fix core dump in sync-async warnings, bug911. [Sebastian Dressler]
+
+****  Fix truncation warning with -pins-bv, bug912. [Alfonso Martinez]
+
+****  Fix Cygwin uint32 compile, bug914. [Matthew Barr]
+
+****  Fix preprocessing stringified newline escapes, bug915. [Anton Rapp]
+
+****  Fix part-select in constant function, bug916. [Andrew Bardsley]
+
+****  Fix width extension on mis-width ports, bug918. [Patrick Maupin]
+
+****  Fix width propagation on sized casts, bug925. [Jonathon Donaldson]
+
+****  Fix MSVC++ compiler error, bug927. [Hans Tichelaar]
+
+
+* Verilator 3.872 2015-04-05
+
+***   Add VerilatedVcdFile to allow real-time waveforms, bug890. [HyungKi Jeong]
+
+***   Add --clk and related optimizations, msg1533. [Jie Xu]
+
+***   Fix order of C style arrays. [Duraid Madina]
+
+****  Add --dump-treei-<srcfile>, bug894. [Jie Xu]
+
+****  Fix comma-instantiations with parameters, bug884. [Franck Jullien]
+
+****  Fix SystemC arrayed bit vectors, bug886. [David Poole]
+
+****  Fix compile error on MinGW, bug887. [HyungKi Jeong]
+
+
+* Verilator 3.870 2015-02-12
+
+****  Suppress COMBDLY when inside always_latch, bug864. [Iztok Jeras]
+
+****  Support cast operator with expression size, bug865. [Iztok Jeras]
+
+****  Add warning on slice selection out of bounds, bug875. [Cong Van Nguyen].
+
+****  Fix member select error broke in 3.868, bug867. [Iztok Jeras]
+
+****  Fix $sccanf from string, bug866. [David Pierce]
+
+****  Fix VM_PARALLEL_BUILDS broke in 3.868, bug870. [Hiroki Honda]
+
+****  Fix non-ANSI modport instantiations, bug868. [Kevin Thompson]
+
+****  Fix UNOPTFLAT change detect on multidim arrays, bug872. [Andrew Bardsley]
+
+****  Fix slice connections of arrays to ports, bug880. [Varun Koyyalagunta]
+
+****  Fix mis-optimizing gate assignments in unopt blocks, bug881. [Mike Thyer]
+
+****  Fix sign extension of pattern members, bug882. [Iztok Jeras]
+
+****  Fix clang compile warnings.
+
+
+* Verilator 3.868 2014-12-20
 
 **    New verilator_coverage program added to replace SystemPerl's vcoverage.
 
@@ -2503,12 +2877,12 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs.  See C-h m [M-x describe-mode].
 
-Copyright 2001-2014 by Wilson Snyder.  This program is free software; you
+Copyright 2001-2017 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.
 
 Local variables:
 mode: outline
-paragraph-separate: "[ 	\f\n]*$"
+paragraph-separate: "[  \f\n]*$"
 end:

MANIFEST.SKIP

@@ -12,6 +12,7 @@
 .*\.tex
 .*\.key
 .*\.vcd
+.*\.1
 /obj_dir/
 /obj_dbg/
 /obj_opt/
@@ -27,6 +28,7 @@ config.cache$
 config.status$
 verilator.log
 verilator.tex
+verilator.pc$
 verilator_bin.*
 verilator_coverage_bin.*
 .vcsmx_rebuild$

Makefile.in

@@ -3,13 +3,11 @@
 #
 # This file is part of Verilator.
 #
-# Author: Wilson Snyder <[email protected]>
-#
 # Code available from: http://www.veripool.org/verilator
 #
 #*****************************************************************************
 #
-# Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+# Copyright 2003-2017 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.
@@ -44,9 +42,6 @@
 #      reconstructed with this Makefile.  This typically includes
 #      everything deleted by distclean, plus more: C source files
 #      produced by Bison, tags tables, info files, and so on.
-#
-# make extraclean
-#      Still more severe - delete backup and autosave files, too.
 
 #### Start of system configuration section. ####
 
@@ -73,7 +68,7 @@ exec_prefix = @exec_prefix@
 # Directory in which to install scripts.
 bindir = @bindir@
 
-# Directory in which to install scripts.
+# Directory in which to install manpages.
 mandir = @mandir@
 
 # Directory in which to install library files.
@@ -86,6 +81,10 @@ infodir = @infodir@
 # Generally ${prefix}/share/verilator
 pkgdatadir = @pkgdatadir@
 
+# Directory in which to install pkgconfig file
+# Generall ${prefix}/share/pkgconfig
+pkgconfigdir = @pkgconfigdir@
+
 # Directory in which to install data across multiple architectures
 datarootdir = @datarootdir@
 
@@ -98,13 +97,15 @@ PACKAGE_VERSION = @PACKAGE_VERSION@
 #### End of system configuration section. ####
 ######################################################################
 
+.SUFFIXES:
+
 SHELL = /bin/sh
 
 SUBDIRS = src test_verilated test_c test_sc test_regress
 
 INFOS = README README.html README.pdf internals.txt internals.html \
-        internals.pdf verilator.txt verilator.html verilator.1 verilator.pdf \
-	verilator_coverage.1
+        internals.pdf verilator.txt verilator.html verilator.pdf \
+	$(VL_INST_MAN_FILES)
 
 # Files that can be generated, but should be up to date for a distribution.
 DISTDEP = info Makefile
@@ -131,6 +132,8 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	test_verilated/vgen*.pl \
 	test_regress/t/t*/*.sv* \
 	test_regress/t/t*/*.v* \
+	test_regress/t/t*/*/*.sv* \
+	test_regress/t/t*/*/*.v* \
 	test_regress/t/*.cpp \
 	test_regress/t/*.h \
 	test_regress/t/*.dat \
@@ -209,10 +212,7 @@ test_regress: all_nomsg
 info: $(INFOS)
 
 # Use --no-split to avoid creating filenames > 14 chars.
-verilator.1: ${srcdir}/bin/verilator
-	pod2man $< $@
-
-verilator_coverage.1: ${srcdir}/bin/verilator_coverage
+%.1: ${srcdir}/bin/%
 	pod2man $< $@
 
 verilator.txt: ${srcdir}/bin/verilator
@@ -230,16 +230,16 @@ verilator.pdf: ${srcdir}/bin/verilator Makefile
 	pdflatex verilator.tex
 	-rm -f verilator.toc verilator.aux verilator.idx verilator.out
 
-README: readme.pod
+README: README.pod
 	-rm -f $@
 	$(POD2TEXT) --loose $< > $@
 
-README.html: readme.pod
+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
+	pod2latex --full --out README.tex README.pod
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) README File" "${DISTDATE}" < README.tex > README2.tex
 	mv README2.tex README.tex
 	pdflatex README.tex
@@ -269,9 +269,10 @@ VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg verilator_coverage
 # 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
+VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_profcfunc.1
 
 VL_INST_INC_BLDDIR_FILES = \
+	include/verilated_config.h \
 	include/verilated.mk \
 
 # Files under srcdir, instead of build time
@@ -299,7 +300,8 @@ installbin:
 # So important we use $< so VPATH is searched
 installman: $(VL_INST_MAN_FILES)
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
-	for p in $< ; do \
+	cd $(srcdir) \
+	; for p in $(VL_INST_MAN_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
@@ -319,6 +321,8 @@ installdata:
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/examples/$$p; \
 	done
+	$(SHELL) ${srcdir}/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
 uninstall:
@@ -328,6 +332,7 @@ uninstall:
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir)/examples && rm -f $(VL_INST_DATA_SRCDIR_FILES)
+	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
 	-rmdir $(DESTDIR)$(pkgdatadir)/bin
 	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
 	-rmdir $(DESTDIR)$(pkgdatadir)/include
@@ -337,6 +342,7 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_v
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
 	-rmdir $(DESTDIR)$(pkgdatadir)
+	-rmdir $(DESTDIR)$(pkgconfigdir)
 
 install: all_nomsg install-all
 install-all: installbin installman installdata install-msg
@@ -406,7 +412,8 @@ endif
 
 # Use --xml flag to see the cppcheck code to use for suppression
 CPPCHECK = src/cppcheck_filtered
-CPPCHECK_FLAGS = --enable=all --inline-suppr --suppress=unusedScopedObject --suppress=cstyleCast
+CPPCHECK_FLAGS = --enable=all --inline-suppr \
+	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList
 CPPCHECK_FLAGS += --xml
 CPPCHECK_CPP = $(wildcard $(srcdir)/include/*.cpp $(srcdir)/src/*.cpp)
 CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
@@ -421,7 +428,7 @@ ftp: info
 install-msg:
 	@echo "Installed!"
 	@echo
-	@echo "Fod documentation see 'man verilator' or 'verilator --help'"
+	@echo "For documentation see 'man verilator' or 'verilator --help'"
 	@echo "For forums and to report bugs see http://www.veripool.org/verilator"
 	@echo
 

README.pod

@@ -5,11 +5,13 @@
 
 =head1 NAME
 
-This is the Verilator Package README file.
+This is the Verilator package README file.
 
 =head1 DISTRIBUTION
 
-This package is Copyright 2003-2014 by Wilson Snyder.  (Report bugs to
+http://www.veripool.org/verilator
+
+This package is Copyright 2003-2017 by Wilson Snyder.  (Report bugs to
 L<http://www.veripool.org/>.)
 
 Verilator is free software; you can redistribute it and/or modify it under
@@ -115,9 +117,10 @@ and add it to path using Modules/modulecmd:
     After installing you'll want a module file like the following:
 
     set install_root /CAD_DISK/verilator/{version-number-used-above}
-    setenv VERILATOR_ROOT $install_root
+    unsetenv VERILATOR_ROOT
     prepend-path PATH $install_root/bin
     prepend-path MANPATH $install_root/man
+    prepend-path PKG_CONFIG_PATH $install_root/share/pkgconfig
 
 =item 3.
 

TODO

@@ -1,6 +1,6 @@
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2004-2017 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.

bin/verilator_coverage

@@ -3,7 +3,7 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 ######################################################################
 #
-# Copyright 2003-2014 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2017 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.
@@ -271,7 +271,7 @@ Specifies a module search directory.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2003-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2003-2017 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify the Verilator internals under the terms of
 either the GNU Lesser General Public License Version 3 or the Perl Artistic
 License Version 2.0.

bin/verilator_difftree

@@ -235,7 +235,7 @@ Do not show differences in line numbering.
 
 The latest version is available from L<http://www.veripool.org/verilator>.
 
-Copyright 2005-2014 by Wilson Snyder.  This package is free software; you can
+Copyright 2005-2017 by Wilson Snyder.  This package 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.
 

bin/verilator_includer

@@ -3,7 +3,7 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2014 by Wilson Snyder. This package is free software; you can
+# Copyright 2003-2017 by Wilson Snyder. This package 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.
 ######################################################################

bin/verilator_profcfunc

@@ -222,7 +222,7 @@ Displays this message and program version and exits.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2007-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2007-2017 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.
 

configure.ac

@@ -1,19 +1,21 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2014 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2017 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.
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[3.867 devel])
+AC_INIT([Verilator],[3.910 2017-09-07])
+# When releasing, also update header of Changes file
+
 AC_CONFIG_HEADER(src/config_build.h)
-AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h)
+AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
 
 AC_MSG_RESULT([configuring for $PACKAGE_STRING])
 
 # Special Substitutions - CFG_WITH_DEFENV
-AC_MSG_CHECKING(whether to disable hardcoded paths)
+AC_MSG_CHECKING(whether to use hardcoded paths)
 AC_ARG_ENABLE([defenv],
               [AS_HELP_STRING([--disable-defenv],
                               [disable using some hardcoded data paths extracted from some default environment variables (the default is to use hardcoded paths)])],
@@ -107,32 +109,66 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
    [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
     ACO_SAVE_CXXFLAGS="$CXXFLAGS"
     # -Werror needed otherwise unknown -Wno-div-by-zero won't report problems
-    CXXFLAGS="$CXXFLAGS $1 -Werror"
-    AC_MSG_CHECKING([whether $CXX accepts $1])
+    CXXFLAGS="$CXXFLAGS $2 -Werror"
+    AC_MSG_CHECKING([whether $CXX accepts $2])
     AC_COMPILE_IFELSE(
          [AC_LANG_PROGRAM([],[])],
-	 [_my_result=yes],
+	 [_my_result=yes
+	  if test -s conftest.err; then
+	    if grep -e "$2" conftest.err >/dev/null; then
+	      _my_result=no
+	    fi
+	  fi],
 	 [_my_result=no])
+    # GCC is annoying, trying to be helpful, it postpones unknown -Wno-
+    # options if there's no error We want to see them regardless, so try
+    # forcing an error and see if we get a gcc warning
+    AC_COMPILE_IFELSE(
+         [AC_LANG_PROGRAM([[an_error "intentional-error-for-test.h"
+	                  ]],[])],
+         [], # Ignore ok exit
+         [if test -s conftest.err; then
+            if grep -e "$2" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi])
     AC_MSG_RESULT($_my_result)
     if test "$_my_result" = "yes" ; then
-       CFG_CXXFLAGS_NO_UNUSED="$CFG_CXXFLAGS_NO_UNUSED $1"
+       $1="$$1 $2"
     fi
     CXXFLAGS="$ACO_SAVE_CXXFLAGS"
    ])# _MY_CXX_CHECK_OPT
 
+# Flags for compiling Verilator internals including parser
+_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)
+AC_SUBST(CFG_CXXFLAGS_SRC)
+
+# Flags for compiling Verilator parser (in addition to above CFG_CXXFLAGS_SRC)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-null-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
+AC_SUBST(CFG_CXXFLAGS_PARSER)
+
+# Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
-_MY_CXX_CHECK_OPT(-Wno-char-subscripts)
-_MY_CXX_CHECK_OPT(-Wno-parentheses-equality)
 # Random code often does / 0.  Unfortunately VL_DIV_I(0,0) will warn
 # without this flag, even though there's a conditional to prevent the divide.
 # We still don't add no-div-by-zero as it throws message to stdout, though doesn't die.
 #_MY_CXX_CHECK_OPT(-Wno-div-by-zero)
-_MY_CXX_CHECK_OPT(-Wno-sign-compare)
-_MY_CXX_CHECK_OPT(-Wno-uninitialized)
-_MY_CXX_CHECK_OPT(-Wno-unused-but-set-variable)
-_MY_CXX_CHECK_OPT(-Wno-unused-parameter)
-_MY_CXX_CHECK_OPT(-Wno-unused-variable)
-_MY_CXX_CHECK_OPT(-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-faligned-new)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-sign-compare)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-uninitialized)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-but-set-variable)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 
 # Checks for library functions.
@@ -142,6 +178,8 @@ AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 # Other install directories
 pkgdatadir=${datadir}/verilator
 AC_SUBST(pkgdatadir)
+pkgconfigdir=${datadir}/pkgconfig
+AC_SUBST(pkgconfigdir)
 
 AC_OUTPUT
 

include/verilated.cpp

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.
@@ -115,7 +115,7 @@ QData VL_RANDOM_Q(int obits) {
 }
 
 WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp) {
-    for (int i=0; i<VL_WORDS_I(obits); i++) {
+    for (int i=0; i<VL_WORDS_I(obits); ++i) {
 	if (i<(VL_WORDS_I(obits)-1)) {
 	    outwp[i] = VL_RAND32();
 	} else {
@@ -146,7 +146,7 @@ QData VL_RAND_RESET_Q(int obits) {
 }
 
 WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) {
-    for (int i=0; i<VL_WORDS_I(obits); i++) {
+    for (int i=0; i<VL_WORDS_I(obits); ++i) {
 	if (i<(VL_WORDS_I(obits)-1)) {
 	    outwp[i] = VL_RAND_RESET_I(32);
 	} else {
@@ -157,7 +157,7 @@ WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) {
 }
 
 WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) {
-    for (int i=0; i<VL_WORDS_I(obits); i++) outwp[i] = 0;
+    for (int i=0; i<VL_WORDS_I(obits); ++i) outwp[i] = 0;
     return outwp;
 }
 
@@ -166,7 +166,7 @@ WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) {
 
 void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) {
     VL_PRINTF("  Data: w%d: ", lbits);
-    for (int i=VL_WORDS_I(lbits)-1; i>=0; i--) { VL_PRINTF("%08x ",iwp[i]); }
+    for (int i=VL_WORDS_I(lbits)-1; i>=0; --i) { VL_PRINTF("%08x ",iwp[i]); }
     VL_PRINTF("\n");
 }
 
@@ -179,7 +179,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
     // for debug see V3Number version
     // Requires clean input
     int words = VL_WORDS_I(lbits);
-    for (int i=0; i<words; i++) owp[i]=0;
+    for (int i=0; i<words; ++i) owp[i]=0;
     // Find MSB and check for zero.
     int umsbp1 = VL_MOSTSETBITP1_W(words,lwp); // dividend
     int vmsbp1 = VL_MOSTSETBITP1_W(words,rwp); // divisor
@@ -193,14 +193,14 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 
     if (vw == 1) {  // Single divisor word breaks rest of algorithm
 	vluint64_t k = 0;
-	for (int j = uw-1; j >= 0; j--) {
+	for (int j = uw-1; j >= 0; --j) {
 	    vluint64_t unw64 = ((k<<VL_ULL(32)) + (vluint64_t)(lwp[j]));
 	    owp[j] = unw64 / (vluint64_t)(rwp[0]);
 	    k      = unw64 - (vluint64_t)(owp[j])*(vluint64_t)(rwp[0]);
 	}
 	if (is_modulus) {
 	    owp[0] = k;
-	    for (int i=1; i<words; i++) owp[i]=0;
+	    for (int i=1; i<words; ++i) owp[i]=0;
 	}
 	return owp;
     }
@@ -211,13 +211,13 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 
     // Zero for ease of debugging and to save having to zero for shifts
     // Note +1 as loop will use extra word
-    for (int i=0; i<words+1; i++) { un[i]=vn[i]=0; }
+    for (int i=0; i<words+1; ++i) { un[i]=vn[i]=0; }
 
     // Algorithm requires divisor MSB to be set
     // Copy and shift to normalize divisor so MSB of vn[vw-1] is set
     int s = 31-VL_BITBIT_I(vmsbp1-1);  // shift amount (0...31)
     vluint32_t shift_mask = s ? 0xffffffff : 0;  // otherwise >> 32 won't mask the value
-    for (int i = vw-1; i>0; i--) {
+    for (int i = vw-1; i>0; --i) {
 	vn[i] = (rwp[i] << s) | (shift_mask & (rwp[i-1] >> (32-s)));
     }
     vn[0] = rwp[0] << s;
@@ -225,13 +225,13 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
     // Copy and shift dividend by same amount; may set new upper word
     if (s) un[uw] = lwp[uw-1] >> (32-s);
     else un[uw] = 0;
-    for (int i=uw-1; i>0; i--) {
+    for (int i=uw-1; i>0; --i) {
 	un[i] = (lwp[i] << s) | (shift_mask & (lwp[i-1] >> (32-s)));
     }
     un[0] = lwp[0] << s;
 
     // Main loop
-    for (int j = uw - vw; j >= 0; j--) {
+    for (int j = uw - vw; j >= 0; --j) {
 	// Estimate
 	vluint64_t unw64 = ((vluint64_t)(un[j+vw])<<VL_ULL(32) | (vluint64_t)(un[j+vw-1]));
 	vluint64_t qhat = unw64 / (vluint64_t)(vn[vw-1]);
@@ -247,7 +247,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 
 	vlsint64_t t = 0;  // Must be signed
 	vluint64_t k = 0;
-	for (int i=0; i<vw; i++) {
+	for (int i=0; i<vw; ++i) {
 	    vluint64_t p = qhat*vn[i];  // Multiply by estimate
 	    t = un[i+j] - k - (p & VL_ULL(0xFFFFFFFF));  // Subtract
 	    un[i+j] = t;
@@ -261,7 +261,7 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 	    // Over subtracted; correct by adding back
 	    owp[j]--;
 	    k = 0;
-	    for (int i=0; i<vw; i++) {
+	    for (int i=0; i<vw; ++i) {
 		t = (vluint64_t)(un[i+j]) + (vluint64_t)(vn[i]) + k;
 		un[i+j] = t;
 		k = t >> VL_ULL(32);
@@ -272,16 +272,92 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
 
     if (is_modulus) { // modulus
 	// Need to reverse normalization on copy to output
-	for (int i=0; i<vw; i++) {
+	for (int i=0; i<vw; ++i) {
 	    owp[i] = (un[i] >> s) | (shift_mask & (un[i+1] << (32-s)));
 	}
-	for (int i=vw; i<words; i++) owp[i] = 0;
+	for (int i=vw; i<words; ++i) owp[i] = 0;
 	return owp;
     } else { // division
 	return owp;
     }
 }
 
+WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDataInP rwp) {
+    // obits==lbits, rbits can be different
+    owp[0] = 1;
+    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    // cppcheck-suppress variableScope
+    WData powstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lastpowstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    WData lastoutstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
+    VL_ASSIGN_W(obits, powstore, lwp);
+    for (int bit=0; bit<rbits; bit++) {
+	if (bit>0) {  // power = power*power
+	    VL_ASSIGN_W(obits, lastpowstore, powstore);
+	    VL_MUL_W(VL_WORDS_I(obits), powstore, lastpowstore, lastpowstore);
+	}
+	if (VL_BITISSET_W(rwp,bit)) {  // out *= power
+	    VL_ASSIGN_W(obits, lastoutstore, owp);
+	    VL_MUL_W(VL_WORDS_I(obits), owp, lastoutstore, powstore);
+	}
+    }
+    return owp;
+}
+WDataOutP VL_POW_WWQ(int obits, int lbits, int rbits, WDataOutP owp, WDataInP lwp, QData rhs) {
+    WData rhsw[2];  VL_SET_WQ(rhsw, rhs);
+    return VL_POW_WWW(obits,lbits,rbits,owp,lwp,rhsw);
+}
+QData VL_POW_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp) {
+    // Skip check for rhs == 0, as short-circuit doesn't save time
+    if (VL_UNLIKELY(lhs==0)) return 0;
+    QData power = lhs;
+    QData out = VL_ULL(1);
+    for (int bit=0; bit<rbits; ++bit) {
+	if (bit>0) power = power*power;
+	if (VL_BITISSET_W(rwp,bit)) out *= power;
+    }
+    return out;
+}
+
+WDataOutP VL_POWSS_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool lsign, bool rsign) {
+    // obits==lbits, rbits can be different
+    if (rsign && VL_SIGN_W(rbits, rwp)) {
+	int words = VL_WORDS_I(obits);
+	VL_ZERO_W(obits, owp);
+	IData lor = 0; // 0=all zeros, ~0=all ones, else mix
+	for (int i=1; i < (words-1); ++i) {
+	    lor |= lwp[i];
+	}
+	lor |= ( (lwp[words-1] == VL_MASK_I(rbits)) ? ~VL_UL(0) : 0);
+	if (lor==0 && lwp[0]==0) { return owp; } // "X" so return 0
+	else if (lor==0 && lwp[0]==1) { owp[0] = 1; return owp; } // 1
+	else if (lsign && lor == ~VL_UL(0) && lwp[0]==~VL_UL(0)) {  // -1
+	    if (rwp[0] & 1) { return VL_ALLONES_W(obits, owp); } // -1^odd=-1
+	    else { owp[0] = 1; return owp; } // -1^even=1
+	}
+	return 0;
+    }
+    return VL_POW_WWW(obits, rbits, rbits, owp, lwp, rwp);
+}
+WDataOutP VL_POWSS_WWQ(int obits, int lbits, int rbits, WDataOutP owp, WDataInP lwp, QData rhs, bool lsign, bool rsign) {
+    WData rhsw[2];  VL_SET_WQ(rhsw, rhs);
+    return VL_POWSS_WWW(obits,lbits,rbits,owp,lwp,rhsw,lsign,rsign);
+}
+QData VL_POWSS_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp, bool lsign, bool rsign) {
+    // Skip check for rhs == 0, as short-circuit doesn't save time
+    if (rsign && VL_SIGN_W(rbits, rwp)) {
+	if (lhs==0) return 0;	// "X"
+	else if (lhs==1) return 1;
+	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
+	    if (rwp[0] & 1) return VL_MASK_I(obits);  // -1^odd=-1
+	    else return 1; // -1^even=1
+	}
+	return 0;
+    }
+    return VL_POW_QQW(obits, rbits, rbits, lhs, rwp);
+}
+
 //===========================================================================
 // Formatting
 
@@ -302,8 +378,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
     bool inPct = false;
     bool widthSet = false;
     int width = 0;
-    const char* pos = formatp;
-    for (; *pos; ++pos) {
+    for (const char* pos = formatp; *pos; ++pos) {
 	if (!inPct && pos[0]=='%') {
 	    pctp = pos;
 	    inPct = true;
@@ -374,10 +449,10 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 		} else {
 		    lwp = va_arg(ap,WDataInP);
 		    ld = lwp[0];
-		    if (fmt == 'u' || fmt == 'd') fmt = 'x';  // Not supported, but show something
+		    if (fmt == 'd' || fmt == '#') fmt = 'x';  // Not supported, but show something
 		}
 		int lsb=lbits-1;
-		if (widthSet && width==0) while (lsb && !VL_BITISSET_W(lwp,lsb)) lsb--;
+		if (widthSet && width==0) while (lsb && !VL_BITISSET_W(lwp,lsb)) --lsb;
 		switch (fmt) {
 		case 'c': {
 		    IData charval = ld & 0xff;
@@ -385,7 +460,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 		    break;
 		}
 		case 's':
-		    for (; lsb>=0; lsb--) {
+		    for (; lsb>=0; --lsb) {
 			lsb = (lsb / 8) * 8; // Next digit
 			IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
 			output += (charval==0)?' ':charval;
@@ -404,7 +479,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 		    output += tmp;
 		    break;
 		}
-		case 'u': { // Unsigned decimal
+		case '#': { // Unsigned decimal
 		    int digits=sprintf(tmp,"%" VL_PRI64 "u",ld);
 		    int needmore = width-digits;
 		    if (needmore>0) {
@@ -434,12 +509,13 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 		    break;
 		}
 		case 'b':
-		    for (; lsb>=0; lsb--) {
+		    for (; lsb>=0; --lsb) {
 			output += ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0';
 		    }
 		    break;
+		    break;
 		case 'o':
-		    for (; lsb>=0; lsb--) {
+		    for (; lsb>=0; --lsb) {
 			lsb = (lsb / 3) * 3; // Next digit
 			// Octal numbers may span more than one wide word,
 			// so we need to grab each bit separately and check for overrun
@@ -450,8 +526,33 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 				   + ((VL_BITISSETLIMIT_W(lwp, lbits, lsb+2)) ? 4 : 0));
 		    }
 		    break;
+		case 'u':  // Packed 2-state
+		    output.reserve(output.size() + 4*VL_WORDS_I(lbits));
+		    for (int i=0; i<VL_WORDS_I(lbits); ++i) {
+			output += (char)((lwp[i]     ) & 0xff);
+			output += (char)((lwp[i] >> 8) & 0xff);
+			output += (char)((lwp[i] >> 16) & 0xff);
+			output += (char)((lwp[i] >> 24) & 0xff);
+		    }
+		    break;
+		case 'z':  // Packed 4-state
+		    output.reserve(output.size() + 8*VL_WORDS_I(lbits));
+		    for (int i=0; i<VL_WORDS_I(lbits); ++i) {
+			output += (char)((lwp[i]     ) & 0xff);
+			output += (char)((lwp[i] >> 8) & 0xff);
+			output += (char)((lwp[i] >> 16) & 0xff);
+			output += (char)((lwp[i] >> 24) & 0xff);
+			output += "\0\0\0\0"; // No tristate
+		    }
+		    break;
+		case 'v': // Strength; assume always strong
+		    for (lsb=lbits-1; lsb>=0; --lsb) {
+			if ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) output += "St1 ";
+			else output += "St0 ";
+		    }
+		    break;
 		case 'x':
-		    for (; lsb>=0; lsb--) {
+		    for (; lsb>=0; --lsb) {
 			lsb = (lsb / 4) * 4; // Next digit
 			IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xf;
 			output += "0123456789abcdef"[charval];
@@ -476,7 +577,7 @@ static inline void _vl_vsss_advance(FILE* fp, int& floc) {
     if (fp) fgetc(fp);
     else floc -= 8;
 }
-static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp) {
+static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, const string& fstr) {
     // Get a character without advancing
     if (fp) {
 	int data = fgetc(fp);
@@ -486,23 +587,26 @@ static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp) {
     } else {
 	if (floc < 0) return EOF;
 	floc = floc & ~7;	// Align to closest character
-	int data = (fromp[VL_BITWORD_I(floc)] >> VL_BITBIT_I(floc)) & 0xff;
-	return data;
+	if (fromp == NULL) {
+	    return fstr[fstr.length()-1 - (floc>>3)];
+	} else {
+	    return (fromp[VL_BITWORD_I(floc)] >> VL_BITBIT_I(floc)) & 0xff;
+	}
     }
 }
-static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp) {
+static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp, const string& fstr) {
     while (1) {
-	int c = _vl_vsss_peek(fp, floc, fromp);
+	int c = _vl_vsss_peek(fp, floc, fromp, fstr);
 	if (c==EOF || !isspace(c)) return;
 	_vl_vsss_advance(fp, floc);
     }
 }
-static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp,
+static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp, const string& fstr,
 				 char* tmpp, const char* acceptp) {
     // Read into tmp, consisting of characters from acceptp list
     char* cp = tmpp;
     while (1) {
-	int c = _vl_vsss_peek(fp, floc, fromp);
+	int c = _vl_vsss_peek(fp, floc, fromp, fstr);
 	if (c==EOF || isspace(c)) break;
 	if (acceptp!=NULL // String - allow anything
 	    && NULL==strchr(acceptp, c)) break;
@@ -521,7 +625,7 @@ static inline void _vl_vsss_setbit(WDataOutP owp, int obits, int lsb, int nbits,
 static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp, int posstart, int posend) {
     // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits.
     int lsb = 0;
-    for (int i=0, pos=posend-1; i<obits && pos>=posstart; pos--) {
+    for (int i=0, pos=posend-1; i<obits && pos>=posstart; --pos) {
 	switch (tolower (strp[pos])) {
 	case 'x': case 'z': case '?': //FALLTHRU
 	case '0': lsb += baseLog2; break;
@@ -547,6 +651,7 @@ static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const
 
 IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		  int fbits, WDataInP fromp,  // Else if a sscanf
+		  const string& fstr,  // if a sscanf to string
 		  const char* formatp, va_list ap) {
     // Read a Verilog $sscanf/$fscanf style format into the output list
     // The format must be pre-processed (and lower cased) by Verilator
@@ -557,15 +662,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
     bool inPct = false;
     const char* pos = formatp;
     for (; *pos && !_vl_vsss_eof(fp,floc); ++pos) {
-	//VL_PRINTF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc, _vl_vsss_peek(fp,floc,fromp));
+	//VL_PRINTF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc, _vl_vsss_peek(fp,floc,fromp,fstr));
 	if (!inPct && pos[0]=='%') {
 	    inPct = true;
 	} else if (!inPct && isspace(pos[0])) {   // Format spaces
 	    while (isspace(pos[1])) pos++;
-	    _vl_vsss_skipspace(fp,floc,fromp);
+	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
 	} else if (!inPct) {   // Expected Format
-	    _vl_vsss_skipspace(fp,floc,fromp);
-	    int c = _vl_vsss_peek(fp,floc,fromp);
+	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+	    int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 	    if (c != pos[0]) goto done;
 	    else _vl_vsss_advance(fp,floc);
 	} else { // Format character
@@ -574,7 +679,7 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 	    char fmt = pos[0];
 	    switch (fmt) {
 	    case '%': {
-		int c = _vl_vsss_peek(fp,floc,fromp);
+		int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 		if (c != '%') goto done;
 		else _vl_vsss_advance(fp,floc);
 		break;
@@ -583,34 +688,34 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		// Deal with all read-and-scan somethings
 		// Note LSBs are preserved if there's an overflow
 		const int obits = va_arg(ap, int);
-		WData qowp[2];
+		WData qowp[2] = {0, 0};
 		WDataOutP owp = qowp;
 		if (obits > VL_QUADSIZE) {
 		    owp = va_arg(ap,WDataOutP);
 		}
-		for (int i=0; i<VL_WORDS_I(obits); i++) owp[i] = 0;
+		for (int i=0; i<VL_WORDS_I(obits); ++i) owp[i] = 0;
 		switch (fmt) {
 		case 'c': {
-		    int c = _vl_vsss_peek(fp,floc,fromp);
+		    int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 		    if (c==EOF) goto done;
 		    else _vl_vsss_advance(fp,floc);
 		    owp[0] = c;
 		    break;
 		}
 		case 's': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, NULL);
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, NULL);
 		    if (!tmp[0]) goto done;
 		    int pos = ((int)strlen(tmp))-1;
 		    int lsb = 0;
-		    for (int i=0; i<obits && pos>=0; pos--) {
+		    for (int i=0; i<obits && pos>=0; --pos) {
 			_vl_vsss_setbit(owp,obits,lsb, 8, tmp[pos]); lsb+=8;
 		    }
 		    break;
 		}
 		case 'd': { // Signed decimal
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    vlsint64_t ld;
 		    sscanf(tmp,"%30" VL_PRI64 "d",&ld);
@@ -620,18 +725,19 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		case 'f':
 		case 'e':
 		case 'g': { // Real number
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "+-.0123456789eE");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "+-.0123456789eE");
 		    if (!tmp[0]) goto done;
+		    // cppcheck-suppress unusedStructMember  // It's used
 		    union { double r; vlsint64_t ld; } u;
 		    u.r = strtod(tmp, NULL);
 		    VL_SET_WQ(owp,u.ld);
 		    break;
 		}
 		case 't': // FALLTHRU  // Time
-		case 'u': { // Unsigned decimal
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xXzZ?_");
+		case '#': { // Unsigned decimal
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    QData ld;
 		    sscanf(tmp,"%30" VL_PRI64 "u",&ld);
@@ -639,22 +745,22 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    break;
 		}
 		case 'b': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "01xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "01xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 1, tmp, 0, (int)strlen(tmp));
 		    break;
 		}
 		case 'o': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "01234567xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "01234567xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 3, tmp, 0, (int)strlen(tmp));
 		    break;
 		}
 		case 'x': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789abcdefABCDEFxXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789abcdefABCDEFxXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 4, tmp, 0, (int)strlen(tmp));
 		    break;
@@ -696,7 +802,7 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) {
     int lsb=obits-1;
     bool start=true;
     char* destp = destoutp;
-    for (; lsb>=0; lsb--) {
+    for (; lsb>=0; --lsb) {
 	lsb = (lsb / 8) * 8; // Next digit
 	IData charval = (sourcep[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
 	if (!start || charval) {
@@ -704,8 +810,8 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) {
 	    start = false;	// Drop leading 0s
 	}
     }
-    *destp++ = '\0'; // Terminate
-    while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';  // Drop trailing spaces
+    *destp = '\0'; // Terminate
+    if (!start) while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';  // Drop trailing spaces
 }
 
 void _VL_STRING_TO_VINT(int obits, void* destp, int srclen, const char* srcp) {
@@ -714,8 +820,8 @@ void _VL_STRING_TO_VINT(int obits, void* destp, int srclen, const char* srcp) {
     char* op = ((char*)(destp));
     if (srclen > bytes) srclen = bytes;  // Don't overflow destination
     int i;
-    for (i=0; i<srclen; i++) { *op++ = srcp[srclen-1-i]; }
-    for (; i<bytes; i++) { *op++ = 0; }
+    for (i=0; i<srclen; ++i) { *op++ = srcp[srclen-1-i]; }
+    for (; i<bytes; ++i) { *op++ = 0; }
 }
 
 IData VL_FGETS_IXI(int obits, void* destp, IData fpi) {
@@ -746,8 +852,13 @@ IData VL_FGETS_IXI(int obits, void* destp, IData fpi) {
     return got;
 }
 
+IData VL_FOPEN_NI(const string& filename, IData mode) {
+    char modez[5];
+    _VL_VINT_TO_STRING(VL_WORDSIZE, modez, &mode);
+    return VL_FOPEN_S(filename.c_str(), modez);
+}
 IData VL_FOPEN_QI(QData filename, IData mode) {
-    IData fnw[2];  VL_SET_WQ(fnw, filename);
+    WData fnw[2];  VL_SET_WQ(fnw, filename);
     return VL_FOPEN_WI(2, fnw, mode);
 }
 IData VL_FOPEN_WI(int fnwords, WDataInP filenamep, IData mode) {
@@ -875,40 +986,47 @@ IData VL_FSCANF_IX(IData fpi, const char* formatp, ...) {
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(fp, 0, NULL, formatp, ap);
+    IData got = _vl_vsscanf(fp, 0, NULL, "", formatp, ap);
     va_end(ap);
     return got;
 }
 
 IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...) {
-    IData fnw[2];  VL_SET_WI(fnw, ld);
+    WData fnw[2];  VL_SET_WI(fnw, ld);
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, "", formatp, ap);
     va_end(ap);
     return got;
 }
 IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...) {
-    IData fnw[2];  VL_SET_WQ(fnw, ld);
+    WData fnw[2];  VL_SET_WQ(fnw, ld);
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, "", formatp, ap);
     va_end(ap);
     return got;
 }
 IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...) {
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, lwp, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, lwp, "", formatp, ap);
+    va_end(ap);
+    return got;
+}
+IData VL_SSCANF_INX(int, const string& ld, const char* formatp, ...) {
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(NULL, ld.length()*8, NULL, ld, formatp, ap);
     va_end(ap);
     return got;
 }
 
 void VL_READMEM_Q(bool hex, int width, int depth, int array_lsb, int,
 		  QData ofilename, void* memp, IData start, IData end) {
-    IData fnw[2];  VL_SET_WQ(fnw, ofilename);
+    WData fnw[2];  VL_SET_WQ(fnw, ofilename);
     return VL_READMEM_W(hex,width,depth,array_lsb,2, fnw,memp,start,end);
 }
 
@@ -916,11 +1034,18 @@ void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
 		  WDataInP ofilenamep, void* memp, IData start, IData end) {
     char ofilenamez[VL_TO_STRING_MAX_WORDS*VL_WORDSIZE+1];
     _VL_VINT_TO_STRING(fnwords*VL_WORDSIZE, ofilenamez, ofilenamep);
-    FILE* fp = fopen(ofilenamez, "r");
+    string ofilenames(ofilenamez);
+    return VL_READMEM_N(hex,width,depth,array_lsb,fnwords,ofilenames,memp,start,end);
+}
+
+void VL_READMEM_N(bool hex, int width, int depth, int array_lsb, int fnwords,
+		  const string& ofilenamep, void* memp, IData start, IData end) {
+    if (fnwords) {}
+    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 (ofilenamez, 0, "", "$readmem file not found");
-	return;
+        // We don't report the Verilog source filename as it slow to have to pass it down
+        vl_fatal (ofilenamep.c_str(), 0, "", "$readmem file not found");
+        return;
     }
     // Prep for reading
     IData addr = start;
@@ -935,86 +1060,86 @@ void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
     // We process a character at a time, as then we don't need to deal
     // with changing buffer sizes dynamically, etc.
     while (1) {
-	int c = fgetc(fp);
-	if (VL_UNLIKELY(c==EOF)) break;
-	//printf("%d: Got '%c' Addr%x IN%d IgE%d IgC%d ninc%d\n", linenum, c, addr, innum, ignore_to_eol, ignore_to_cmt, needinc);
-	if (c=='\n') { linenum++; ignore_to_eol=false; if (innum) reading_addr=false; innum=false; }
-	else if (c=='\t' || c==' ' || c=='\r' || c=='\f') { if (innum) reading_addr=false; innum=false; }
-	// Skip // comments and detect /* comments
-	else if (ignore_to_cmt && lastc=='*' && c=='/') {
-	    ignore_to_cmt = false; if (innum) reading_addr=false; innum=false;
-	} else if (!ignore_to_eol && !ignore_to_cmt) {
-	    if (lastc=='/' && c=='*') { ignore_to_cmt = true; }
-	    else if (lastc=='/' && c=='/') { ignore_to_eol = true; }
-	    else if (c=='/') {}  // Part of /* or //
-	    else if (c=='_') {}
-	    else if (c=='@') { reading_addr = true; innum=false; needinc=false; }
-	    // Check for hex or binary digits as file format requests
-	    else if (isxdigit(c)) {
-		c = tolower(c);
-		int value = (c >= 'a' ? (c-'a'+10) : (c-'0'));
-		if (!innum) {  // Prep for next number
-		    if (needinc) { addr++; needinc=false; }
-		}
-		if (reading_addr) {
-		    // Decode @ addresses
-		    if (!innum) addr=0;
-		    addr = (addr<<4) + value;
-		} else {
-		    needinc = true;
-		    //printf(" Value width=%d  @%x = %c\n", width, addr, c);
-		    if (VL_UNLIKELY(addr >= (IData)(depth+array_lsb) || addr < (IData)(array_lsb))) {
-			vl_fatal (ofilenamez, linenum, "", "$readmem file address beyond bounds of array");
-		    } else {
-			int entry = addr - array_lsb;
-			QData shift = hex ? VL_ULL(4) : VL_ULL(1);
-			// Shift value in
-			if (width<=8) {
-			    CData* datap = &((CData*)(memp))[entry];
-			    if (!innum) { *datap = 0; }
-			    *datap = ((*datap << shift) + value) & VL_MASK_I(width);
-			} else if (width<=16) {
-			    SData* datap = &((SData*)(memp))[entry];
-			    if (!innum) { *datap = 0; }
-			    *datap = ((*datap << shift) + value) & VL_MASK_I(width);
-			} else if (width<=VL_WORDSIZE) {
-			    IData* datap = &((IData*)(memp))[entry];
-			    if (!innum) { *datap = 0; }
-			    *datap = ((*datap << shift) + value) & VL_MASK_I(width);
-			} else if (width<=VL_QUADSIZE) {
-			    QData* datap = &((QData*)(memp))[entry];
-			    if (!innum) { *datap = 0; }
-			    *datap = ((*datap << (QData)(shift)) + (QData)(value)) & VL_MASK_Q(width);
-			} else {
-			    WDataOutP datap = &((WDataOutP)(memp))[ entry*VL_WORDS_I(width) ];
-			    if (!innum) { VL_ZERO_RESET_W(width, datap); }
-			    _VL_SHIFTL_INPLACE_W(width, datap, (IData)shift);
-			    datap[0] |= value;
-			}
-			if (VL_UNLIKELY(value>=(1<<shift))) {
-			    vl_fatal (ofilenamez, linenum, "", "$readmemb (binary) file contains hex characters");
-			}
-		    }
-		}
-		innum = true;
-	    }
-	    else {
-		vl_fatal (ofilenamez, linenum, "", "$readmem file syntax error");
-	    }
-	}
-	lastc = c;
+        int c = fgetc(fp);
+        if (VL_UNLIKELY(c==EOF)) break;
+        //printf("%d: Got '%c' Addr%x IN%d IgE%d IgC%d ninc%d\n", linenum, c, addr, innum, ignore_to_eol, ignore_to_cmt, needinc);
+        if (c=='\n') { linenum++; ignore_to_eol=false; if (innum) reading_addr=false; innum=false; }
+        else if (c=='\t' || c==' ' || c=='\r' || c=='\f') { if (innum) reading_addr=false; innum=false; }
+        // Skip // comments and detect /* comments
+        else if (ignore_to_cmt && lastc=='*' && c=='/') {
+            ignore_to_cmt = false; if (innum) reading_addr=false; innum=false;
+        } else if (!ignore_to_eol && !ignore_to_cmt) {
+            if (lastc=='/' && c=='*') { ignore_to_cmt = true; }
+            else if (lastc=='/' && c=='/') { ignore_to_eol = true; }
+            else if (c=='/') {}  // Part of /* or //
+            else if (c=='_') {}
+            else if (c=='@') { reading_addr = true; innum=false; needinc=false; }
+            // Check for hex or binary digits as file format requests
+            else if (isxdigit(c) || (!reading_addr && (c=='x' || c=='X'))) {
+                c = tolower(c);
+                int value = (c >= 'a' ? (c=='x' ? VL_RAND_RESET_I(4) : (c-'a'+10)) : (c-'0'));
+                if (!innum) {  // Prep for next number
+                    if (needinc) { addr++; needinc=false; }
+                }
+                if (reading_addr) {
+                    // Decode @ addresses
+                    if (!innum) addr=0;
+                    addr = (addr<<4) + value;
+                } else {
+                    needinc = true;
+                    //printf(" Value width=%d  @%x = %c\n", width, addr, c);
+                    if (VL_UNLIKELY(addr >= (IData)(depth+array_lsb) || addr < (IData)(array_lsb))) {
+                        vl_fatal (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);
+                        // Shift value in
+                        if (width<=8) {
+                            CData* datap = &((CData*)(memp))[entry];
+                            if (!innum) { *datap = 0; }
+                            *datap = ((*datap << shift) + value) & VL_MASK_I(width);
+                        } else if (width<=16) {
+                            SData* datap = &((SData*)(memp))[entry];
+                            if (!innum) { *datap = 0; }
+                            *datap = ((*datap << shift) + value) & VL_MASK_I(width);
+                        } else if (width<=VL_WORDSIZE) {
+                            IData* datap = &((IData*)(memp))[entry];
+                            if (!innum) { *datap = 0; }
+                            *datap = ((*datap << shift) + value) & VL_MASK_I(width);
+                        } else if (width<=VL_QUADSIZE) {
+                            QData* datap = &((QData*)(memp))[entry];
+                            if (!innum) { *datap = 0; }
+                            *datap = ((*datap << (QData)(shift)) + (QData)(value)) & VL_MASK_Q(width);
+                        } else {
+                            WDataOutP datap = &((WDataOutP)(memp))[ entry*VL_WORDS_I(width) ];
+                            if (!innum) { VL_ZERO_RESET_W(width, datap); }
+                            _VL_SHIFTL_INPLACE_W(width, datap, (IData)shift);
+                            datap[0] |= value;
+                        }
+                        if (VL_UNLIKELY(value>=(1<<shift))) {
+                            vl_fatal (ofilenamep.c_str(), linenum, "", "$readmemb (binary) file contains hex characters");
+                        }
+                    }
+                }
+                innum = true;
+            }
+            else {
+                vl_fatal (ofilenamep.c_str(), linenum, "", "$readmem file syntax error");
+            }
+        }
+        lastc = c;
     }
-    if (needinc) { addr++; needinc=false; }
+    if (needinc) { addr++; }
 
     // Final checks
     fclose(fp);
     if (VL_UNLIKELY(end != VL_UL(0xffffffff) && addr != (end+1))) {
-	vl_fatal (ofilenamez, linenum, "", "$readmem file ended before specified ending-address");
+        vl_fatal (ofilenamep.c_str(), linenum, "", "$readmem file ended before specified ending-address");
     }
 }
 
 IData VL_SYSTEM_IQ(QData lhs) {
-    IData lhsw[2];  VL_SET_WQ(lhsw, lhs);
+    WData lhsw[2];  VL_SET_WQ(lhsw, lhs);
     return VL_SYSTEM_IW(2, lhsw);
 }
 IData VL_SYSTEM_IW(int lhswords, WDataInP filenamep) {
@@ -1030,14 +1155,36 @@ IData VL_TESTPLUSARGS_I(const char* formatp) {
     else return 1;
 }
 
-IData VL_VALUEPLUSARGS_IW(int rbits, const char* prefixp, char fmt, WDataOutP rwp) {
-    const string& match = VerilatedImp::argPlusMatch(prefixp);
-    const char* dp = match.c_str() + 1 /*leading + */ + strlen(prefixp);
+IData VL_VALUEPLUSARGS_INW(int rbits, const string& ld, WDataOutP rwp) {
+    string prefix;
+    bool inPct = false;
+    bool done = false;
+    char fmt = ' ';
+    for (const char* posp = ld.c_str(); !done && *posp; ++posp) {
+	if (!inPct && posp[0]=='%') {
+	    inPct = true;
+	} else if (!inPct) {   // Normal text
+	    prefix += *posp;
+	} else { // Format character
+	    switch (tolower(*posp)) {
+	    case '%':
+		prefix += *posp;
+		inPct = false;
+		break;
+	    default:
+		fmt = *posp;
+		done = true;
+		break;
+	    }
+	}
+    }
+
+    const string& match = VerilatedImp::argPlusMatch(prefix.c_str());
+    const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
     if (match == "") return 0;
+
     VL_ZERO_RESET_W(rbits, rwp);
     switch (tolower(fmt)) {
-    case '%':
-	break;
     case 'd':
 	vlsint64_t ld;
 	sscanf(dp,"%30" VL_PRI64 "d",&ld);
@@ -1053,18 +1200,47 @@ IData VL_VALUEPLUSARGS_IW(int rbits, const char* prefixp, char fmt, WDataOutP rw
     case 'x':
 	_vl_vsss_based(rwp,rbits, 4, dp, 0, (int)strlen(dp));
 	break;
-    case 's':
-	for (int i=0, lsb=0, pos=((int)strlen(dp))-1; i<rbits && pos>=0; pos--) {
-	    _vl_vsss_setbit(rwp,rbits,lsb, 8, dp[pos]); lsb+=8;
+    case 's': // string/no conversion
+	for (int i=0, lsb=0, posp=((int)strlen(dp))-1; i<rbits && posp>=0; --posp) {
+	    _vl_vsss_setbit(rwp,rbits,lsb, 8, dp[posp]); lsb+=8;
 	}
 	break;
-    default:  // Compile time should have found all errors before this
-	vl_fatal (__FILE__, __LINE__, "", "$value$plusargs format error");
-	break;
+    case 'e': //FALLTHRU - Unsupported
+    case 'f': //FALLTHRU - Unsupported
+    case 'g': //FALLTHRU - Unsupported
+    default:  // Other simulators simply return 0 in these cases and don't error out
+	return 0;
     }
     _VL_CLEAN_INPLACE_W(rbits,rwp);
     return 1;
 }
+IData VL_VALUEPLUSARGS_INN(int, const string& ld, string& rdr) {
+    string prefix;
+    bool inPct = false;
+    bool done = false;
+    for (const char* posp = ld.c_str(); !done && *posp; ++posp) {
+	if (!inPct && posp[0]=='%') {
+	    inPct = true;
+	} else if (!inPct) {   // Normal text
+	    prefix += *posp;
+	} else { // Format character
+	    switch (tolower(*posp)) {
+	    case '%':
+		prefix += *posp;
+		inPct = false;
+		break;
+	    default:
+		done = true;
+		break;
+	    }
+	}
+    }
+    const string& match = VerilatedImp::argPlusMatch(prefix.c_str());
+    const char* dp = match.c_str() + 1 /*leading + */ + prefix.length();
+    if (match == "") return 0;
+    rdr = string(dp);
+    return 1;
+}
 
 const char* vl_mc_scan_plusargs(const char* prefixp) {
     const string& match = VerilatedImp::argPlusMatch(prefixp);
@@ -1087,7 +1263,7 @@ string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) {
     bool start=true;
     char* destp = destout;
     int len = 0;
-    for (; lsb>=0; lsb--) {
+    for (; lsb>=0; --lsb) {
 	lsb = (lsb / 8) * 8; // Next digit
 	IData charval = (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 0xff;
 	if (!start || charval) {
@@ -1108,7 +1284,7 @@ const char* Verilated::catName(const char* n1, const char* n2) {
     static char* strp = NULL;
     static size_t len  = 0;
     size_t newlen = strlen(n1)+strlen(n2)+2;
-    if (newlen > len) {
+    if (!strp || newlen > len) {
 	if (strp) delete [] strp;
 	strp = new char[newlen];
 	len = newlen;
@@ -1135,7 +1311,12 @@ void Verilated::commandArgs(int argc, const char** argv) {
 }
 
 const char* Verilated::commandArgsPlusMatch(const char* prefixp) {
-    return VerilatedImp::argPlusMatch(prefixp).c_str();
+    const string& match = VerilatedImp::argPlusMatch(prefixp);
+    static VL_THREAD char outstr[VL_VALUE_STRING_MAX_WIDTH];
+    if (match == "") return "";
+    strncpy(outstr, match.c_str(), VL_VALUE_STRING_MAX_WIDTH);
+    outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
+    return outstr;
 }
 
 void Verilated::internalsDump() {
@@ -1154,6 +1335,10 @@ int Verilated::exportFuncNum(const char* namep) {
     return VerilatedImp::exportFind(namep);
 }
 
+const VerilatedScopeNameMap* Verilated::scopeNameMap() {
+    return VerilatedImp::scopeNameMap();
+}
+
 //===========================================================================
 // VerilatedModule:: Methods
 
@@ -1162,7 +1347,7 @@ VerilatedModule::VerilatedModule(const char* namep)
 }
 
 VerilatedModule::~VerilatedModule() {
-    if (m_namep) free((void*)m_namep); m_namep=NULL;
+    if (m_namep) { free((void*)m_namep); m_namep=NULL; }
 }
 
 //======================================================================
@@ -1276,7 +1461,7 @@ VerilatedVar* VerilatedScope::varFind(const char* namep) const {
     return NULL;
 }
 
-void* VerilatedScope::exportFindNullError(int funcnum) const {
+void* VerilatedScope::exportFindNullError(int funcnum) {
     // Slowpath - Called only when find has failed
     string msg = (string("Testbench C called '")
 		  +VerilatedImp::exportName(funcnum)
@@ -1297,7 +1482,7 @@ void* VerilatedScope::exportFindError(int funcnum) const {
 
 void VerilatedScope::scopeDump() const {
     VL_PRINTF("    SCOPE %p: %s\n", this, name());
-    for (int i=0; i<m_funcnumMax; i++) {
+    for (int i=0; i<m_funcnumMax; ++i) {
 	if (m_callbacksp && m_callbacksp[i]) {
 	    VL_PRINTF("       DPI-EXPORT %p: %s\n",
 		      m_callbacksp[i], VerilatedImp::exportName(i));

include/verilated.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.
@@ -38,6 +38,7 @@
 #include <cstring>
 #include <cmath>
 // <iostream> avoided to reduce compile time
+// <map> avoided and instead in verilated_heavy.h to reduce compile time
 // <string> avoided and instead in verilated_heavy.h to reduce compile time
 using namespace std;
 
@@ -45,7 +46,7 @@ using namespace std;
 // Switches
 
 #if VM_TRACE		// Verilator tracing requested
-# define WAVES 1	// Set backward compatibility flag as in systemperl.h
+# define WAVES 1	// Set backward compatibility flag
 #endif
 
 //=========================================================================
@@ -68,6 +69,7 @@ typedef void (*VerilatedVoidCb)(void);
 
 class SpTraceVcd;
 class SpTraceVcdCFile;
+class VerilatedScopeNameMap;
 class VerilatedVar;
 class VerilatedVarNameMap;
 class VerilatedVcd;
@@ -102,9 +104,9 @@ class VerilatedModule {
 private:
     const char*		m_namep;	///< Module name
     VerilatedModule();				///< N/A, always use named constructor below
-    VerilatedModule(const VerilatedModule& );	///< N/A, no copying modules
+    VerilatedModule(const VerilatedModule& );	///< N/A, no copy constructor
 public:
-    VerilatedModule(const char* namep);	///< Create module with given hierarchy name
+    explicit VerilatedModule(const char* namep);	///< Create module with given hierarchy name
     ~VerilatedModule();
     const char* name() const { return m_namep; }	///< Return name of module
 };
@@ -199,16 +201,16 @@ public:  // But internals only - called from VerilatedModule's
     inline VerilatedSyms* symsp() const { return m_symsp; }
     VerilatedVar* varFind(const char* namep) const;
     VerilatedVarNameMap* varsp() const { return m_varsp; }
-    void* exportFindError(int funcnum) const;
-    void* exportFindNullError(int funcnum) const;
     void scopeDump() const;
-    inline void* exportFind(int funcnum) const {
-	if (VL_UNLIKELY(!this)) return exportFindNullError(funcnum);
-	if (VL_LIKELY(funcnum < m_funcnumMax)) {
+    void* exportFindError(int funcnum) const;
+    static void* exportFindNullError(int funcnum);
+    static inline void* exportFind(const VerilatedScope* scopep, int funcnum) {
+	if (VL_UNLIKELY(!scopep)) return exportFindNullError(funcnum);
+	if (VL_LIKELY(funcnum < scopep->m_funcnumMax)) {
 	    // m_callbacksp must be declared, as Max'es are > 0
-	    return m_callbacksp[funcnum];
+	    return scopep->m_callbacksp[funcnum];
 	} else {
-	    return exportFindError(funcnum);
+	    return scopep->exportFindError(funcnum);
 	}
     }
 };
@@ -286,7 +288,9 @@ public:
     /// Record command line arguments, for retrieval by $test$plusargs/$value$plusargs
     static void commandArgs(int argc, const char** argv);
     static void commandArgs(int argc, char** argv) { commandArgs(argc,(const char**)argv); }
+    static void commandArgsAdd(int argc, const char** argv);
     static CommandArgValues* getCommandArgs() {return &s_args;}
+    /// Match plusargs with a given prefix. Returns static char* valid only for a single call
     static const char* commandArgsPlusMatch(const char* prefixp);
 
     /// Produce name & version for (at least) VPI
@@ -308,6 +312,7 @@ public:
     static const char* catName(const char* n1, const char* n2); // Returns new'ed data
     // Internal: Find scope
     static const VerilatedScope* scopeFind(const char* namep);
+    static const VerilatedScopeNameMap* scopeNameMap();
     // Internal: Get and set DPI context
     static const VerilatedScope* dpiScope() { return t_dpiScopep; }
     static void dpiScope(const VerilatedScope* scopep) { t_dpiScopep=scopep; }
@@ -344,7 +349,7 @@ extern WDataOutP VL_RANDOM_W(int obits, WDataOutP outwp);	///< Randomize a signa
 extern IData  VL_RAND_RESET_I(int obits);	///< Random reset a signal
 extern QData  VL_RAND_RESET_Q(int obits);	///< Random reset a signal
 extern WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp);	///< Random reset a signal
-extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);	///< Zero reset a signal
+extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);	///< Zero reset a signal (slow - else use VL_ZERO_W)
 
 /// Math
 extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool is_modulus);
@@ -357,6 +362,7 @@ extern IData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
 extern IData VL_FOPEN_QI(QData ofilename, IData mode);
 inline IData VL_FOPEN_II(IData ofilename, IData mode) { return VL_FOPEN_QI(ofilename,mode); }
 
+
 extern void VL_FCLOSE_I(IData fdi);
 
 extern void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
@@ -386,19 +392,19 @@ extern IData VL_SYSTEM_IQ(QData lhs);
 inline IData VL_SYSTEM_II(IData lhs) { return VL_SYSTEM_IQ(lhs); }
 
 extern IData VL_TESTPLUSARGS_I(const char* formatp);
-extern IData VL_VALUEPLUSARGS_IW(int rbits, const char* prefixp, char fmt, WDataOutP rwp);
 extern const char* vl_mc_scan_plusargs(const char* prefixp);  // PLIish
 
 //=========================================================================
 // Base macros
 
-/// Return true if data[bit] set
+/// Return true if data[bit] set; not 0/1 return, but 0/non-zero return.
 #define VL_BITISSET_I(data,bit) (data & (VL_UL(1)<<VL_BITBIT_I(bit)))
 #define VL_BITISSET_Q(data,bit) (data & (VL_ULL(1)<<VL_BITBIT_Q(bit)))
 #define VL_BITISSET_W(data,bit) (data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
 #define VL_BITISSETLIMIT_W(data,width,bit) (((bit)<(width)) && data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
 
 /// Create two 32-bit words from quadword
+/// WData is always at least 2 words; does not clean upper bits
 #define VL_SET_WQ(owp,data)	{ owp[0]=(IData)(data); owp[1]=(IData)((data)>>VL_WORDSIZE); }
 #define VL_SET_WI(owp,data)	{ owp[0]=(IData)(data); owp[1]=0; }
 #define VL_SET_QW(lwp)		( ((QData)(lwp[0])) | ((QData)(lwp[1])<<((QData)(VL_WORDSIZE)) ))
@@ -427,6 +433,7 @@ static inline IData  VL_RTOIROUND_I_D(double lhs) { return ((vlsint32_t)(VL_ROUN
 // (Requires clean input)
 #define VL_SIGN_I(nbits,lhs)      ((lhs) >> VL_BITBIT_I((nbits) - VL_UL(1)))
 #define VL_SIGN_Q(nbits,lhs)      ((lhs) >> VL_BITBIT_Q((nbits) - VL_ULL(1)))
+#define VL_SIGN_W(nbits,rwp)      ((rwp)[VL_BITWORD_I((nbits)-VL_UL(1))] >> VL_BITBIT_I((nbits)-VL_UL(1)))
 #define VL_SIGNONES_I(nbits,lhs)  (-(VL_SIGN_I(nbits,lhs)))
 
 // Sign bit extended up to MSB, doesn't include unsigned portion
@@ -498,17 +505,28 @@ static inline WDataOutP _VL_CLEAN_INPLACE_W(int obits, WDataOutP owp) {
 }
 static inline WDataOutP VL_CLEAN_WW(int obits, int, WDataOutP owp, WDataInP lwp){
     int words = VL_WORDS_I(obits);
-    for (int i=0; (i < (words-1)); i++) owp[i] = lwp[i];
+    for (int i=0; (i < (words-1)); ++i) owp[i] = lwp[i];
     owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
     return(owp);
 }
+static inline WDataOutP VL_ZERO_W(int obits, WDataOutP owp) {
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i < words; ++i) owp[i] = 0;
+    return owp;
+}
+static inline WDataOutP VL_ALLONES_W(int obits, WDataOutP owp) {
+    int words = VL_WORDS_I(obits);
+    for (int i=0; (i < (words-1)); ++i) owp[i] = ~VL_UL(0);
+    owp[words-1] = VL_MASK_I(obits);
+    return owp;
+}
 
 // EMIT_RULE: VL_ASSIGN:  oclean=rclean; obits==lbits;
 // For now, we always have a clean rhs.
 // Note: If a ASSIGN isn't clean, use VL_ASSIGNCLEAN instead to do the same thing.
-static inline WDataOutP VL_ASSIGN_W(int obits, WDataOutP owp,WDataInP lwp){
+static inline WDataOutP VL_ASSIGN_W(int obits, WDataOutP owp, WDataInP lwp) {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i < words; i++) owp[i] = lwp[i];
+    for (int i=0; i < words; ++i) owp[i] = lwp[i];
     return(owp);
 }
 
@@ -569,7 +587,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 }
 #define VL_ASSIGN_WSW(obits,owp,svar) { \
     int words = VL_WORDS_I(obits); \
-    for (int i=0; i < words; i++) owp[i] = svar.read().get_word(i); \
+    for (int i=0; i < words; ++i) owp[i] = svar.read().get_word(i); \
     owp[words-1] &= VL_MASK_I(obits); \
 }
 
@@ -578,7 +596,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 #define VL_ASSIGN_WSB(obits,owp,svar) {                       \
     int words = VL_WORDS_I(obits);                            \
     sc_biguint<obits> _butemp = (svar).read();                \
-    for (int i=0; i < words; i++) {                           \
+    for (int i=0; i < words; ++i) {                           \
         int msb = ((i+1)*VL_WORDSIZE) - 1;                    \
         msb = (msb >= obits) ? (obits-1) : msb;               \
         owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint();  \
@@ -594,18 +612,18 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 
 #define VL_ASSIGN_SWI(obits,svar,rd) { \
     sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0,rd); \
+    _bvtemp.set_word(0,(rd));			\
     svar.write(_bvtemp); \
 }
 #define VL_ASSIGN_SWQ(obits,svar,rd) { \
     sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0,rd); \
-    _bvtemp.set_word(1,rd>>VL_WORDSIZE); \
+    _bvtemp.set_word(0,(IData)(rd));	 \
+    _bvtemp.set_word(1,(IData)((rd)>>VL_WORDSIZE));	\
     svar.write(_bvtemp); \
 }
 #define VL_ASSIGN_SWW(obits,svar,rwp) { \
     sc_bv<obits> _bvtemp; \
-    for (int i=0; i < VL_WORDS_I(obits); i++) _bvtemp.set_word(i,rwp[i]); \
+    for (int i=0; i < VL_WORDS_I(obits); ++i) _bvtemp.set_word(i,rwp[i]); \
     svar.write(_bvtemp); \
 }
 
@@ -615,7 +633,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 #define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); }
 #define VL_ASSIGN_SBW(obits,svar,rwp) {             \
     sc_biguint<obits> _butemp;                      \
-    for (int i=0; i < VL_WORDS_I(obits); i++) {     \
+    for (int i=0; i < VL_WORDS_I(obits); ++i) {     \
         int msb = ((i+1)*VL_WORDSIZE) - 1;          \
         msb = (msb >= obits) ? (obits-1) : msb;     \
         _butemp.range(msb,i*VL_WORDSIZE) = rwp[i];  \
@@ -637,17 +655,17 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 static inline WDataOutP VL_EXTEND_WI(int obits, int, WDataOutP owp, IData ld) {
     // Note for extracts that obits != lbits
     owp[0] = ld;
-    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     return(owp);
 }
 static inline WDataOutP VL_EXTEND_WQ(int obits, int, WDataOutP owp, QData ld) {
     VL_SET_WQ(owp,ld);
-    for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     return(owp);
 }
 static inline WDataOutP VL_EXTEND_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) {
-    for (int i=0; i < VL_WORDS_I(lbits); i++) owp[i] = lwp[i];
-    for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=0; i < VL_WORDS_I(lbits); ++i) owp[i] = lwp[i];
+    for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     return(owp);
 }
 
@@ -666,22 +684,22 @@ static inline QData VL_EXTENDS_QQ(int, int lbits, QData lhs) {
 static inline WDataOutP VL_EXTENDS_WI(int obits, int lbits, WDataOutP owp, IData ld) {
     IData sign = VL_SIGNONES_I(lbits,ld);
     owp[0] = ld | (sign & ~VL_MASK_I(lbits));
-    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = sign;
+    for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
     return(owp);
 }
 static inline WDataOutP VL_EXTENDS_WQ(int obits, int lbits, WDataOutP owp, QData ld) {
     VL_SET_WQ(owp,ld);
     IData sign = VL_SIGNONES_I(lbits,owp[1]);
     owp[1] |= sign & ~VL_MASK_I(lbits);
-    for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = sign;
+    for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
     return(owp);
 }
 static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WDataInP lwp) {
-    for (int i=0; i < VL_WORDS_I(lbits)-1; i++) owp[i] = lwp[i];
+    for (int i=0; i < VL_WORDS_I(lbits)-1; ++i) owp[i] = lwp[i];
     int lmsw=VL_WORDS_I(lbits)-1;
     IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
     owp[lmsw] = lwp[lmsw] | (sign & ~VL_MASK_I(lbits));
-    for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); i++) owp[i] = sign;
+    for (int i=VL_WORDS_I(lbits); i < VL_WORDS_I(obits); ++i) owp[i] = sign;
     return(owp);
 }
 
@@ -694,7 +712,7 @@ static inline WDataOutP VL_EXTENDS_WW(int obits, int lbits, WDataOutP owp, WData
 static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) {
     int words = VL_WORDS_I(lbits);
     IData combine=lwp[0];
-    for (int i=1; i < words-1; i++) combine &= lwp[i];
+    for (int i=1; i < words-1; ++i) combine &= lwp[i];
     combine &= ~VL_MASK_I(lbits) | lwp[words-1];
     return ((~combine)==0);
 }
@@ -704,7 +722,7 @@ static inline IData VL_REDAND_IW(int, int lbits, WDataInP lwp) {
 #define VL_REDOR_Q(lhs) (lhs!=0)
 static inline IData VL_REDOR_W(int words, WDataInP lwp) {
     IData equal=0;
-    for (int i=0; i < words; i++) equal |= lwp[i];
+    for (int i=0; i < words; ++i) equal |= lwp[i];
     return(equal!=0);
 }
 
@@ -756,7 +774,7 @@ static inline IData VL_REDXOR_64(QData r) {
 }
 static inline IData VL_REDXOR_W(int words, WDataInP lwp) {
     IData r = lwp[0];
-    for (int i=1; i < words; i++) r ^= lwp[i];
+    for (int i=1; i < words; ++i) r ^= lwp[i];
     return VL_REDXOR_32(r);
 }
 
@@ -774,7 +792,7 @@ static inline IData VL_COUNTONES_Q(QData lhs) {
 }
 static inline IData VL_COUNTONES_W(int words, WDataInP lwp) {
     IData r = 0;
-    for (int i=0; (i < words); i++) r+=VL_COUNTONES_I(lwp[i]);
+    for (int i=0; (i < words); ++i) r+=VL_COUNTONES_I(lwp[i]);
     return r;
 }
 
@@ -786,7 +804,7 @@ static inline IData VL_ONEHOT_Q(QData lhs) {
 }
 static inline IData VL_ONEHOT_W(int words, WDataInP lwp) {
     IData one=0;
-    for (int i=0; (i < words); i++) {
+    for (int i=0; (i < words); ++i) {
 	if (lwp[i]) {
 	    if (one) return 0;
 	    one = 1;
@@ -804,7 +822,7 @@ static inline IData VL_ONEHOT0_Q(QData lhs) {
 }
 static inline IData VL_ONEHOT0_W(int words, WDataInP lwp) {
     bool one=false;
-    for (int i=0; (i < words); i++) {
+    for (int i=0; (i < words); ++i) {
 	if (lwp[i]) {
 	    if (one) return 0;
 	    one = true;
@@ -819,21 +837,21 @@ static inline IData VL_CLOG2_I(IData lhs) {
     if (VL_UNLIKELY(!lhs)) return 0;
     lhs--;
     int shifts=0;
-    for (; lhs!=0; shifts++) lhs = lhs >> 1;
+    for (; lhs!=0; ++shifts) lhs = lhs >> 1;
     return shifts;
 }
 static inline IData VL_CLOG2_Q(QData lhs) {
     if (VL_UNLIKELY(!lhs)) return 0;
     lhs--;
     int shifts=0;
-    for (; lhs!=0; shifts++) lhs = lhs >> VL_ULL(1);
+    for (; lhs!=0; ++shifts) lhs = lhs >> VL_ULL(1);
     return shifts;
 }
 static inline IData VL_CLOG2_W(int words, WDataInP lwp) {
     IData adjust = (VL_COUNTONES_W(words,lwp)==1) ? 0 : 1;
-    for (int i=words-1; i>=0; i--) {
+    for (int i=words-1; i>=0; --i) {
 	if (VL_UNLIKELY(lwp[i])) {  // Shorter worst case if predict not taken
-	    for (int bit=31; bit>=0; bit--) {
+	    for (int bit=31; bit>=0; --bit) {
 		if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) {
 		    return i*VL_WORDSIZE + bit + adjust;
 		}
@@ -846,9 +864,9 @@ static inline IData VL_CLOG2_W(int words, WDataInP lwp) {
 
 static inline IData VL_MOSTSETBITP1_W(int words, WDataInP lwp) {
     // MSB set bit plus one; similar to FLS.  0=value is zero
-    for (int i=words-1; i>=0; i--) {
+    for (int i=words-1; i>=0; --i) {
 	if (VL_UNLIKELY(lwp[i])) {  // Shorter worst case if predict not taken
-	    for (int bit=31; bit>=0; bit--) {
+	    for (int bit=31; bit>=0; --bit) {
 		if (VL_UNLIKELY(VL_BITISSET_I(lwp[i],bit))) {
 		    return i*VL_WORDSIZE + bit + 1;
 		}
@@ -864,33 +882,33 @@ static inline IData VL_MOSTSETBITP1_W(int words, WDataInP lwp) {
 
 // EMIT_RULE: VL_AND:  oclean=lclean||rclean; obits=lbits; lbits==rbits;
 static inline WDataOutP VL_AND_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
-    for (int i=0; (i < words); i++) owp[i] = (lwp[i] & rwp[i]);
+    for (int i=0; (i < words); ++i) owp[i] = (lwp[i] & rwp[i]);
     return(owp);
 }
 // EMIT_RULE: VL_OR:   oclean=lclean&&rclean; obits=lbits; lbits==rbits;
 static inline WDataOutP VL_OR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
-    for (int i=0; (i < words); i++) owp[i] = (lwp[i] | rwp[i]);
+    for (int i=0; (i < words); ++i) owp[i] = (lwp[i] | rwp[i]);
     return(owp);
 }
 // EMIT_RULE: VL_CHANGEXOR:  oclean=1; obits=32; lbits==rbits;
 static inline IData VL_CHANGEXOR_W(int words, WDataInP lwp,WDataInP rwp){
     IData od = 0;
-    for (int i=0; (i < words); i++) od |= (lwp[i] ^ rwp[i]);
+    for (int i=0; (i < words); ++i) od |= (lwp[i] ^ rwp[i]);
     return(od);
 }
 // EMIT_RULE: VL_XOR:  oclean=lclean&&rclean; obits=lbits; lbits==rbits;
 static inline WDataOutP VL_XOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
-    for (int i=0; (i < words); i++) owp[i] = (lwp[i] ^ rwp[i]);
+    for (int i=0; (i < words); ++i) owp[i] = (lwp[i] ^ rwp[i]);
     return(owp);
 }
 // EMIT_RULE: VL_XNOR:  oclean=dirty; obits=lbits; lbits==rbits;
 static inline WDataOutP VL_XNOR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
-    for (int i=0; (i < words); i++) owp[i] = (lwp[i] ^ ~rwp[i]);
+    for (int i=0; (i < words); ++i) owp[i] = (lwp[i] ^ ~rwp[i]);
     return(owp);
 }
 // EMIT_RULE: VL_NOT:  oclean=dirty; obits=lbits;
 static inline WDataOutP VL_NOT_W(int words, WDataOutP owp,WDataInP lwp) {
-    for (int i=0; i < words; i++) owp[i] = ~(lwp[i]);
+    for (int i=0; i < words; ++i) owp[i] = ~(lwp[i]);
     return(owp);
 }
 
@@ -912,7 +930,7 @@ static inline WDataOutP VL_NOT_W(int words, WDataOutP owp,WDataInP lwp) {
 // Output clean, <lhs> AND <rhs> MUST BE CLEAN
 static inline IData VL_EQ_W(int words, WDataInP lwp, WDataInP rwp) {
     int nequal=0;
-    for (int i=0; (i < words); i++) nequal |= (lwp[i] ^ rwp[i]);
+    for (int i=0; (i < words); ++i) nequal |= (lwp[i] ^ rwp[i]);
     return(nequal==0);
 }
 
@@ -1006,7 +1024,7 @@ static inline int _VL_CMPS_W(int lbits, WDataInP lwp, WDataInP rwp) {
 
 static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
     QData carry = 0;
-    for (int i=0; i<words; i++) {
+    for (int i=0; i<words; ++i) {
 	carry = carry + (QData)(lwp[i]) + (QData)(rwp[i]);
 	owp[i] = (carry & VL_ULL(0xffffffff));
 	carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff);
@@ -1016,7 +1034,7 @@ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP
 
 static inline WDataOutP VL_SUB_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
     QData carry = 0;
-    for (int i=0; i<words; i++) {
+    for (int i=0; i<words; ++i) {
 	carry = carry + (QData)(lwp[i]) + (QData)(IData)(~rwp[i]);
 	if (i==0) carry++;  // Negation of temp2
 	owp[i] = (carry & VL_ULL(0xffffffff));
@@ -1033,7 +1051,7 @@ static inline QData  VL_NEGATE_Q(QData data) { return -data; }
 
 static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){
     QData carry = 0;
-    for (int i=0; i<words; i++) {
+    for (int i=0; i<words; ++i) {
 	carry = carry + (QData)(IData)(~lwp[i]);
 	if (i==0) carry++;  // Negation of temp2
 	owp[i] = (carry & VL_ULL(0xffffffff));
@@ -1043,11 +1061,11 @@ static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){
 }
 
 static inline WDataOutP VL_MUL_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
-    for (int i=0; i<words; i++) owp[i] = 0;
-    for (int lword=0; lword<words; lword++) {
-	for (int rword=0; rword<words; rword++) {
+    for (int i=0; i<words; ++i) owp[i] = 0;
+    for (int lword=0; lword<words; ++lword) {
+	for (int rword=0; rword<words; ++rword) {
 	    QData mul = (QData)(lwp[lword]) * (QData)(rwp[rword]);
-	    for (int qword=lword+rword; qword<words; qword++) {
+	    for (int qword=lword+rword; qword<words; ++qword) {
 		mul += (QData)(owp[qword]);
 		owp[qword] = (mul & VL_ULL(0xffffffff));
 		mul = (mul >> VL_ULL(32)) & VL_ULL(0xffffffff);
@@ -1071,8 +1089,10 @@ static inline QData VL_MULS_QQQ(int,int lbits,int, QData lhs,QData rhs) {
 
 static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lwp,WDataInP rwp){
     int words = VL_WORDS_I(lbits);
-    IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
-    IData rwstore[VL_MULS_MAX_WORDS];
+    // cppcheck-suppress variableScope
+    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
+    WData rwstore[VL_MULS_MAX_WORDS];
     WDataInP lwusp = lwp;
     WDataInP rwusp = rwp;
     IData lneg = VL_SIGN_I(lbits,lwp[words-1]);
@@ -1091,7 +1111,7 @@ static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lw
     owp[words-1] &= VL_MASK_I(lbits);  // Clean.  Note it's ok for the multiply to overflow into the sign bit
     if ((lneg ^ rneg) & 1) {      // Negate output  (not using NEGATE, as owp==lwp)
 	QData carry = 0;
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    carry = carry + (QData)(IData)(~owp[i]);
 	    if (i==0) carry++;  // Negation of temp2
 	    owp[i] = (carry & VL_ULL(0xffffffff));
@@ -1132,8 +1152,10 @@ static inline WDataOutP VL_DIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDataI
     int words = VL_WORDS_I(lbits);
     IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
     IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
-    IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
-    IData rwstore[VL_MULS_MAX_WORDS];
+    // cppcheck-suppress variableScope
+    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
+    WData rwstore[VL_MULS_MAX_WORDS];
     WDataInP ltup = lwp;
     WDataInP rtup = rwp;
     if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), lwstore, lwp)); }
@@ -1151,14 +1173,16 @@ static inline WDataOutP VL_MODDIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDa
     int words = VL_WORDS_I(lbits);
     IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
     IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
-    IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
-    IData rwstore[VL_MULS_MAX_WORDS];
+    // cppcheck-suppress variableScope
+    WData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
+    WData rwstore[VL_MULS_MAX_WORDS];
     WDataInP ltup = lwp;
     WDataInP rtup = rwp;
     if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), lwstore, lwp)); }
     if (rsign) { rtup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), rwstore, rwp)); }
     if (lsign) {  // Only dividend sign matters for modulus
-	IData qNoSign[VL_MULS_MAX_WORDS];
+	WData qNoSign[VL_MULS_MAX_WORDS];
 	VL_MODDIV_WWW(lbits,qNoSign,ltup,rtup);
 	_VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), owp, qNoSign));
 	return owp;
@@ -1167,14 +1191,17 @@ static inline WDataOutP VL_MODDIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDa
     }
 }
 
+#define VL_POW_IIQ(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs)
+#define VL_POW_IIW(obits,lbits,rbits,lhs,rwp) VL_POW_QQW(obits,lbits,rbits,lhs,rwp)
 #define VL_POW_QQI(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs)
+#define VL_POW_WWI(obits,lbits,rbits,owp,lwp,rhs) VL_POW_WWQ(obits,lbits,rbits,owp,lwp,rhs)
 
 static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) {
     if (VL_UNLIKELY(rhs==0)) return 1;
     if (VL_UNLIKELY(lhs==0)) return 0;
     IData power = lhs;
     IData out = 1;
-    for (int i=0; i<rbits; i++) {
+    for (int i=0; i<rbits; ++i) {
 	if (i>0) power = power*power;
 	if (rhs & (VL_ULL(1)<<i)) out *= power;
     }
@@ -1185,42 +1212,51 @@ static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
     if (VL_UNLIKELY(lhs==0)) return 0;
     QData power = lhs;
     QData out = VL_ULL(1);
-    for (int i=0; i<rbits; i++) {
+    for (int i=0; i<rbits; ++i) {
 	if (i>0) power = power*power;
 	if (rhs & (VL_ULL(1)<<i)) out *= power;
     }
     return out;
 }
+WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDataInP rwp);
+WDataOutP VL_POW_WWQ(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, QData rhs);
+QData VL_POW_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp);
 
+#define VL_POWSS_IIQ(obits,lbits,rbits,lhs,rhs,lsign,rsign) VL_POWSS_QQQ(obits,lbits,rbits,lhs,rhs,lsign,rsign)
+#define VL_POWSS_IIQ(obits,lbits,rbits,lhs,rhs,lsign,rsign) VL_POWSS_QQQ(obits,lbits,rbits,lhs,rhs,lsign,rsign)
+#define VL_POWSS_IIW(obits,lbits,rbits,lhs,rwp,lsign,rsign) VL_POWSS_QQW(obits,lbits,rbits,lhs,rwp,lsign,rsign)
 #define VL_POWSS_QQI(obits,lbits,rbits,lhs,rhs,lsign,rsign) VL_POWSS_QQQ(obits,lbits,rbits,lhs,rhs,lsign,rsign)
+#define VL_POWSS_WWI(obits,lbits,rbits,owp,lwp,rhs,lsign,rsign) VL_POWSS_WWQ(obits,lbits,rbits,owp,lwp,rhs,lsign,rsign)
 
 static inline IData VL_POWSS_III(int obits, int, int rbits, IData lhs, IData rhs, bool lsign, bool rsign) {
     if (VL_UNLIKELY(rhs==0)) return 1;
     if (rsign && VL_SIGN_I(rbits, rhs)) {
 	if (lhs==0) return 0;	// "X"
 	else if (lhs==1) return 1;
-	else if (lsign && lhs==VL_MASK_I(obits)) {  //-1
+	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
 	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
 	    else return 1; // -1^even=1
 	}
 	return 0;
     }
-    return VL_POW_III(obits, obits, rbits, lhs, rhs);
+    return VL_POW_III(obits, rbits, rbits, lhs, rhs);
 }
-
 static inline QData VL_POWSS_QQQ(int obits, int, int rbits, QData lhs, QData rhs, bool lsign, bool rsign) {
     if (VL_UNLIKELY(rhs==0)) return 1;
     if (rsign && VL_SIGN_I(rbits, rhs)) {
 	if (lhs==0) return 0;	// "X"
 	else if (lhs==1) return 1;
-	else if (lsign && lhs==VL_MASK_I(obits)) {  //-1
+	else if (lsign && lhs==VL_MASK_I(obits)) {  // -1
 	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
 	    else return 1; // -1^even=1
 	}
 	return 0;
     }
-    return VL_POW_QQQ(obits, obits, rbits, lhs, rhs);
+    return VL_POW_QQQ(obits, rbits, rbits, lhs, rhs);
 }
+WDataOutP VL_POWSS_WWW(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool lsign, bool rsign);
+WDataOutP VL_POWSS_WWQ(int obits, int, int rbits, WDataOutP owp, WDataInP lwp, QData rhs, bool lsign, bool rsign);
+QData VL_POWSS_QQW(int obits, int, int rbits, QData lhs, WDataInP rwp, bool lsign, bool rsign);
 
 //===================================================================
 // Concat/replication
@@ -1275,13 +1311,13 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
     int words = VL_WORDS_I(hbit-lbit+1);
     if (hoffset==VL_SIZEBITS_I && loffset==0) {
 	// Fast and common case, word based insertion
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    owp[lword+i] = lwp[i];
 	}
     }
     else if (loffset==0) {
 	// Non-32bit, but nicely aligned, so stuff all but the last word
-	for (int i=0; i<(words-1); i++) {
+	for (int i=0; i<(words-1); ++i) {
 	    owp[lword+i] = lwp[i];
 	}
 	IData hinsmask = (VL_MASK_I(hoffset-0+1)); // Know it's not a full word as above fast case handled it
@@ -1293,7 +1329,7 @@ static inline void _VL_INSERT_WW(int, WDataOutP owp, WDataInP lwp, int hbit, int
 	int nbitsonright = 32-loffset;  // bits that end up in lword (know loffset!=0)
 	// Middle words
 	int hword = VL_BITWORD_I(hbit);
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    {	// Lower word
 		int oword = lword+i;
 		IData d = lwp[i]<<loffset;
@@ -1326,7 +1362,7 @@ static inline void _VL_INSERT_WQ(int obits, WDataOutP owp, QData ld, int hbit, i
 
 static inline IData VL_REPLICATE_III(int, int lbits, int, IData ld, IData rep) {
     IData returndata = ld;
-    for (unsigned i=1; i < rep; i++){
+    for (unsigned i=1; i < rep; ++i){
 	returndata = returndata << lbits;
 	returndata |= ld;
     }
@@ -1334,7 +1370,7 @@ static inline IData VL_REPLICATE_III(int, int lbits, int, IData ld, IData rep) {
 }
 static inline QData VL_REPLICATE_QII(int, int lbits, int, IData ld, IData rep) {
     QData returndata = ld;
-    for (unsigned i=1; i < rep; i++){
+    for (unsigned i=1; i < rep; ++i){
 	returndata = returndata << lbits;
 	returndata |= (QData)ld;
     }
@@ -1342,21 +1378,21 @@ static inline QData VL_REPLICATE_QII(int, int lbits, int, IData ld, IData rep) {
 }
 static inline WDataOutP VL_REPLICATE_WII(int obits, int lbits, int, WDataOutP owp, IData ld, IData rep) {
     owp[0] = ld;
-    for (unsigned i=1; i < rep; i++){
+    for (unsigned i=1; i < rep; ++i){
 	_VL_INSERT_WI(obits,owp,ld,i*lbits+lbits-1,i*lbits);
     }
     return(owp);
 }
 static inline WDataOutP VL_REPLICATE_WQI(int obits, int lbits, int, WDataOutP owp, QData ld, IData rep) {
     VL_SET_WQ(owp,ld);
-    for (unsigned i=1; i < rep; i++){
+    for (unsigned i=1; i < rep; ++i){
 	_VL_INSERT_WQ(obits,owp,ld,i*lbits+lbits-1,i*lbits);
     }
     return(owp);
 }
 static inline WDataOutP VL_REPLICATE_WWI(int obits, int lbits, int, WDataOutP owp, WDataInP lwp, IData rep) {
-    for (int i=0; i < VL_WORDS_I(lbits); i++) owp[i] = lwp[i];
-    for (unsigned i=1; i < rep; i++){
+    for (int i=0; i < VL_WORDS_I(lbits); ++i) owp[i] = lwp[i];
+    for (unsigned i=1; i < rep; ++i){
 	_VL_INSERT_WW(obits,owp,lwp,i*lbits+lbits-1,i*lbits);
     }
     return(owp);
@@ -1460,13 +1496,13 @@ static inline QData VL_STREAML_QQI(int, int lbits, int, QData ld, IData rd) {
 }
 
 static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WDataInP lwp, IData rd) {
-    VL_ZERO_RESET_W(lbits, owp);
+    VL_ZERO_W(lbits, owp);
     // Slice size should never exceed the lhs width
     int ssize = (rd < (IData)lbits) ? rd : ((IData)lbits);
     for (int istart=0; istart<lbits; istart+=rd) {
 	int ostart=lbits-rd-istart;
         ostart = ostart > 0 ? ostart : 0;
-	for (int sbit=0; sbit<ssize && sbit<lbits-istart; sbit++) {
+	for (int sbit=0; sbit<ssize && sbit<lbits-istart; ++sbit) {
             // Extract a single bit from lwp and shift it to the correct
             // location for owp.
             WData bit= ((lwp[VL_BITWORD_I(istart+sbit)] >> VL_BITBIT_I(istart+sbit)) & 1) << VL_BITBIT_I(ostart+sbit);
@@ -1488,55 +1524,55 @@ static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WData
 
 static inline WDataOutP VL_CONCAT_WII(int obits,int lbits,int rbits,WDataOutP owp,IData ld,IData rd) {
     owp[0] = rd;
-    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WWI(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, IData rd) {
     owp[0] = rd;
-    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WIW(int obits,int lbits,int rbits,WDataOutP owp,IData ld, WDataInP rwp) {
-    for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i];
-    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
+    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WIQ(int obits,int lbits,int rbits,WDataOutP owp,IData ld,QData rd) {
     VL_SET_WQ(owp,rd);
-    for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WI(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WQI(int obits,int lbits,int rbits,WDataOutP owp,QData ld,IData rd) {
     owp[0] = rd;
-    for (int i=1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WQQ(int obits,int lbits,int rbits,WDataOutP owp,QData ld,QData rd) {
     VL_SET_WQ(owp,rd);
-    for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WWQ(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, QData rd) {
     VL_SET_WQ(owp,rd);
-    for (int i=2; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=2; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WQW(int obits,int lbits,int rbits,WDataOutP owp,QData ld, WDataInP rwp) {
-    for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i];
-    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
+    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WQ(obits,owp,ld,rbits+lbits-1,rbits);
     return(owp);
 }
 static inline WDataOutP VL_CONCAT_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
-    for (int i=0; i < VL_WORDS_I(rbits); i++) owp[i] = rwp[i];
-    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); i++) owp[i] = 0;
+    for (int i=0; i < VL_WORDS_I(rbits); ++i) owp[i] = rwp[i];
+    for (int i=VL_WORDS_I(rbits); i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     _VL_INSERT_WW(obits,owp,lwp,rbits+lbits-1,rbits);
     return(owp);
 }
@@ -1549,7 +1585,7 @@ static inline WDataOutP VL_CONCAT_WWW(int obits,int lbits,int rbits,WDataOutP ow
 static inline void _VL_SHIFTL_INPLACE_W(int obits,WDataOutP iowp,IData rd/*1 or 4*/) {
     int words = VL_WORDS_I(obits);
     IData linsmask = VL_MASK_I(rd);
-    for (int i=words-1; i>=1; i--) {
+    for (int i=words-1; i>=1; --i) {
 	iowp[i] = ((iowp[i]<<rd) & ~linsmask) | ((iowp[i-1] >> (32-rd)) & linsmask);
     }
     iowp[0] = ((iowp[0]<<rd) & ~linsmask);
@@ -1563,16 +1599,32 @@ static inline WDataOutP VL_SHIFTL_WWI(int obits,int,int,WDataOutP owp,WDataInP l
     int word_shift = VL_BITWORD_I(rd);
     int bit_shift = VL_BITBIT_I(rd);
     if (rd >= (IData)obits) {  // rd may be huge with MSB set
-	for (int i=0; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+	for (int i=0; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     } else if (bit_shift==0) {  // Aligned word shift (<<0,<<32,<<64 etc)
-	for (int i=0; i < word_shift; i++) owp[i] = 0;
-	for (int i=word_shift; i < VL_WORDS_I(obits); i++) owp[i] = lwp[i-word_shift];
+	for (int i=0; i < word_shift; ++i) owp[i] = 0;
+	for (int i=word_shift; i < VL_WORDS_I(obits); ++i) owp[i] = lwp[i-word_shift];
     } else {
-	for (int i=0; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+	for (int i=0; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
 	_VL_INSERT_WW(obits,owp,lwp,obits-1,rd);
     }
     return(owp);
 }
+static inline WDataOutP VL_SHIFTL_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    return VL_ZERO_W(obits, owp);
+	}
+    }
+    return VL_SHIFTL_WWI(obits,lbits,32,owp,lwp,rwp[0]);
+}
+static inline IData VL_SHIFTL_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    return 0;
+	}
+    }
+    return VL_CLEAN_II(obits,obits,lhs<<rwp[0]);
+}
 
 // EMIT_RULE: VL_SHIFTR:  oclean=lclean; rclean==clean;
 // Important: Unlike most other funcs, the shift might well be a computed
@@ -1581,27 +1633,43 @@ static inline WDataOutP VL_SHIFTR_WWI(int obits,int,int,WDataOutP owp,WDataInP l
     int word_shift = VL_BITWORD_I(rd);  // Maybe 0
     int bit_shift = VL_BITBIT_I(rd);
     if (rd >= (IData)obits) {  // rd may be huge with MSB set
-	for (int i=0; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+	for (int i=0; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     } else if (bit_shift==0) {  // Aligned word shift (>>0,>>32,>>64 etc)
 	int copy_words = (VL_WORDS_I(obits)-word_shift);
-	for (int i=0; i < copy_words; i++) owp[i] = lwp[i+word_shift];
-	for (int i=copy_words; i < VL_WORDS_I(obits); i++) owp[i] = 0;
+	for (int i=0; i < copy_words; ++i) owp[i] = lwp[i+word_shift];
+	for (int i=copy_words; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     } else {
 	int loffset = rd & VL_SIZEBITS_I;
 	int nbitsonright = 32-loffset;  // bits that end up in lword (know loffset!=0)
 	// Middle words
 	int words = VL_WORDS_I(obits-rd);
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    owp[i] = lwp[i+word_shift]>>loffset;
 	    int upperword = i+word_shift+1;
 	    if (upperword < VL_WORDS_I(obits)) {
 		owp[i] |= lwp[upperword]<< nbitsonright;
 	    }
 	}
-	for (int i=words; i<VL_WORDS_I(obits); i++) owp[i]=0;
+	for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i]=0;
     }
     return(owp);
 }
+static inline WDataOutP VL_SHIFTR_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    return VL_ZERO_W(obits, owp);
+	}
+    }
+    return VL_SHIFTR_WWI(obits,lbits,32,owp,lwp,rwp[0]);
+}
+static inline IData VL_SHIFTR_IIW(int obits,int,int rbits,IData lhs, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    return 0;
+	}
+    }
+    return VL_CLEAN_II(obits,obits,lhs>>rwp[0]);
+}
 
 // EMIT_RULE: VL_SHIFTRS:  oclean=false; lclean=clean, rclean==clean;
 static inline IData VL_SHIFTRS_III(int obits, int lbits, int, IData lhs, IData rhs) {
@@ -1627,20 +1695,20 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int lbits,int,WDataOutP owp,WDa
     int lmsw = VL_WORDS_I(obits)-1;
     IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
     if (rd >= (IData)obits) {  // Shifting past end, sign in all of lbits
-	for (int i=0; i <= lmsw; i++) owp[i] = sign;
+	for (int i=0; i <= lmsw; ++i) owp[i] = sign;
 	owp[lmsw] &= VL_MASK_I(lbits);
     } else if (bit_shift==0) {  // Aligned word shift (>>0,>>32,>>64 etc)
 	int copy_words = (VL_WORDS_I(obits)-word_shift);
-	for (int i=0; i < copy_words; i++) owp[i] = lwp[i+word_shift];
+	for (int i=0; i < copy_words; ++i) owp[i] = lwp[i+word_shift];
 	if (copy_words>=0) owp[copy_words-1] |= ~VL_MASK_I(obits) & sign;
-	for (int i=copy_words; i < VL_WORDS_I(obits); i++) owp[i] = sign;
+	for (int i=copy_words; i < VL_WORDS_I(obits); ++i) owp[i] = sign;
 	owp[lmsw] &= VL_MASK_I(lbits);
     } else {
 	int loffset = rd & VL_SIZEBITS_I;
 	int nbitsonright = 32-loffset;  // bits that end up in lword (know loffset!=0)
 	// Middle words
 	int words = VL_WORDS_I(obits-rd);
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    owp[i] = lwp[i+word_shift]>>loffset;
 	    int upperword = i+word_shift+1;
 	    if (upperword < VL_WORDS_I(obits)) {
@@ -1648,11 +1716,49 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int lbits,int,WDataOutP owp,WDa
 	    }
 	}
 	if (words) owp[words-1] |= sign & ~VL_MASK_I(obits-loffset);
-	for (int i=words; i<VL_WORDS_I(obits); i++) owp[i] = sign;
+	for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i] = sign;
 	owp[lmsw] &= VL_MASK_I(lbits);
     }
     return(owp);
 }
+static inline WDataOutP VL_SHIFTRS_WWW(int obits,int lbits,int rbits,WDataOutP owp,WDataInP lwp, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    int lmsw = VL_WORDS_I(obits)-1;
+	    IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
+	    for (int i=0; i <= lmsw; ++i) owp[i] = sign;
+	    owp[lmsw] &= VL_MASK_I(lbits);
+	    return owp;
+	}
+    }
+    return VL_SHIFTRS_WWI(obits,lbits,32,owp,lwp,rwp[0]);
+}
+static inline IData VL_SHIFTRS_IIW(int obits,int lbits,int rbits,IData lhs, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    IData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
+	    return VL_CLEAN_II(obits,obits,sign);
+	}
+    }
+    return VL_SHIFTRS_III(obits,lbits,32,lhs,rwp[0]);
+}
+static inline QData VL_SHIFTRS_QQW(int obits,int lbits,int rbits,QData lhs, WDataInP rwp) {
+    for (int i=1; i < VL_WORDS_I(rbits); ++i) {
+	if (VL_UNLIKELY(rwp[i])) { // Huge shift 1>>32 or more
+	    QData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
+	    return VL_CLEAN_QQ(obits,obits,sign);
+	}
+    }
+    return VL_SHIFTRS_QQI(obits,lbits,32,lhs,rwp[0]);
+}
+static inline IData VL_SHIFTRS_IIQ(int obits,int lbits,int rbits,IData lhs, QData rhs) {
+    WData rwp[2]; VL_SET_WQ(rwp,rhs);
+    return VL_SHIFTRS_IIW(obits,lbits,rbits,lhs,rwp);
+}
+static inline QData VL_SHIFTRS_QQQ(int obits,int lbits,int rbits,QData lhs, QData rhs) {
+    WData rwp[2]; VL_SET_WQ(rwp,rhs);
+    return VL_SHIFTRS_QQW(obits,lbits,rbits,lhs,rwp);
+}
 
 //===================================================================
 // Bit selection
@@ -1718,25 +1824,25 @@ static inline WDataOutP VL_SEL_WWII(int obits,int lbits,int,int,WDataOutP owp,WD
     int msb = lsb+width-1;
     int word_shift = VL_BITWORD_I(lsb);
     if (VL_UNLIKELY(msb>lbits)) { // Outside bounds,
-	for (int i=0; i<VL_WORDS_I(obits)-1; i++) owp[i] = ~0;
+	for (int i=0; i<VL_WORDS_I(obits)-1; ++i) owp[i] = ~0;
 	owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
     } else if (VL_BITBIT_I(lsb)==0) {
 	// Just a word extract
-	for (int i=0; i<VL_WORDS_I(obits); i++) owp[i] = lwp[i+word_shift];
+	for (int i=0; i<VL_WORDS_I(obits); ++i) owp[i] = lwp[i+word_shift];
     } else {
 	// Not a _VL_INSERT because the bits come from any bit number and goto bit 0
 	int loffset = lsb & VL_SIZEBITS_I;
 	int nbitsfromlow = 32-loffset;  // bits that end up in lword (know loffset!=0)
 	// Middle words
 	int words = VL_WORDS_I(msb-lsb+1);
-	for (int i=0; i<words; i++) {
+	for (int i=0; i<words; ++i) {
 	    owp[i] = lwp[i+word_shift]>>loffset;
 	    int upperword = i+word_shift+1;
 	    if (upperword <= (int)VL_BITWORD_I(msb)) {
 		owp[i] |= lwp[upperword]<< nbitsfromlow;
 	    }
 	}
-	for (int i=words; i<VL_WORDS_I(obits); i++) owp[i]=0;
+	for (int i=words; i<VL_WORDS_I(obits); ++i) owp[i]=0;
     }
     return owp;
 }
@@ -1781,30 +1887,10 @@ static inline void VL_ASSIGNSEL_WIIW(int obits, int lsb, WDataOutP owp, WDataInP
 static inline WDataOutP VL_COND_WIWW(int obits, int, int, int,
 				     WDataOutP owp, int cond, WDataInP w1p, WDataInP w2p) {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i < words; i++) owp[i] = cond ? w1p[i] : w2p[i];
+    for (int i=0; i < words; ++i) owp[i] = cond ? w1p[i] : w2p[i];
     return(owp);
 }
 
-//======================================================================
-// System Functions
-
-inline IData VL_VALUEPLUSARGS_IQ(int rbits, const char* prefixp, char fmt, QData& ldr) {
-    WData wd[2]; IData v=VL_VALUEPLUSARGS_IW(rbits,prefixp,fmt,wd); if (v) ldr=VL_SET_QW(wd);
-    return v;
-}
-inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, CData& ldr) {
-    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(CData)qd;
-    return v;
-}
-inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, SData& ldr) {
-    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(SData)qd;
-    return v;
-}
-inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, IData& ldr) {
-    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(IData)qd;
-    return v;
-}
-
 //======================================================================
 // Constification
 
@@ -1814,7 +1900,7 @@ inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, IData
 // If changing the number of functions here, also change EMITCINLINES_NUM_CONSTW
 
 #define _END(obits,wordsSet) \
-    for(int i=(wordsSet);i<VL_WORDS_I(obits);i++) o[i] = (IData)0x0; \
+    for(int i=(wordsSet);i<VL_WORDS_I(obits);++i) o[i] = (IData)0x0; \
     return o
 
 #define VL_HAVE_CONST_W_1X

include/verilated.mk.in

@@ -2,7 +2,7 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2014 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2017 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.
 ######################################################################
@@ -22,7 +22,6 @@ CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
 ######################################################################
 # Programs
 
-SP_PREPROC	= sp_preproc
 SP_INCLUDER	= $(VERILATOR_INCLUDER)
 VERILATOR_COVERAGE = $(PERL) $(VERILATOR_ROOT)/bin/verilator_coverage
 VERILATOR_INCLUDER = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
@@ -43,8 +42,9 @@ VK_CPPFLAGS_ALWAYS += \
 		-I$(VERILATOR_ROOT)/include \
 		-I$(VERILATOR_ROOT)/include/vltstd \
 		-DVL_PRINTF=printf \
-		-DVM_TRACE=$(VM_TRACE) \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
+		-DVM_SC=$(VM_SC) \
+		-DVM_TRACE=$(VM_TRACE) \
 		$(CFG_CXXFLAGS_NO_UNUSED) \
 
 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
@@ -92,9 +92,9 @@ VM_CLASSES += $(VM_CLASSES_FAST) $(VM_CLASSES_SLOW)
 VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)
 
 #######################################################################
-##### SystemC or SystemPerl builds
+##### SystemC builds
 
-ifeq ($(VM_SP_OR_SC),1)
+ifeq ($(VM_SC),1)
   CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
   LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
   SC_LIBS   = -lsystemc
@@ -105,41 +105,14 @@ ifeq ($(VM_SP_OR_SC),1)
 endif
 
 #######################################################################
-##### SystemPerl builds
+##### Stub
 
-ifeq ($(VM_SP),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE) -DSYSTEMPERL
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
-  LIBS   += -lm -lstdc++
-
-  VK_CLASSES_SP = $(addsuffix .sp, $(VM_CLASSES))
-
-  # This rule is called manually by the upper level makefile
-  preproc:
-	 @echo "      SP Preprocess" $(basename $(VM_CLASSES)) ...
-	 $(SP_PREPROC) -M sp_preproc.d --tree $(VM_PREFIX).sp_tree \
-		--preproc $(VK_CLASSES_SP)
-else
- ifeq ($(VM_COVERAGE),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
- endif
-  preproc:
-endif
-
-#######################################################################
-##### SystemC w/o SystemPerl builds
-
-ifeq ($(VM_SC),1)
-  LIBS   += -lm -lstdc++
-endif
+preproc:
 
 #######################################################################
 ##### C/H builds
 
-ifeq ($(VM_PCLI),1)
-  LIBS   += -lm -lstdc++
-endif
+LIBS   += -lm -lstdc++
 
 #######################################################################
 # Overall Objects Linking
@@ -153,7 +126,7 @@ VK_USER_OBJS   = $(addsuffix .o, $(VM_USER_CLASSES))
 
 VK_GLOBAL_OBJS = $(addsuffix .o, $(VM_GLOBAL_FAST) $(VM_GLOBAL_SLOW))
 
-ifneq ($(VM_PARALLEL_BUILDS),0)
+ifneq ($(VM_PARALLEL_BUILDS),1)
   # Fast building, all .cpp's in one fell swoop
   # This saves about 5 sec per module, but can be slower if only a little changes
   VK_OBJS += $(VM_PREFIX)__ALLcls.o   $(VM_PREFIX)__ALLsup.o
@@ -175,16 +148,24 @@ $(VM_PREFIX)__ALL.a: $(VK_OBJS)
 ######################################################################
 ### Compile rules
 
-#Default rule embedded in make:  (Not defined so user makefiles can override it)
-#.cpp.o:
-#	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
-
+ifneq ($(VM_DEFAULT_RULES),0)
 $(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
 
 $(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
 
+$(VM_PREFIX)%__Slow.o: $(VM_PREFIX)%__Slow.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
+
+$(VM_PREFIX)%.o: $(VM_PREFIX)%.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
+endif
+
+#Default rule embedded in make:
+#.cpp.o:
+#	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
+
 ######################################################################
 ### Debugging
 

include/verilated.v

@@ -4,7 +4,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.

include/verilated_config.h.in

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.

include/verilated_cov.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Verilator coverage analysis
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #include "verilatedos.h"
@@ -52,7 +50,10 @@ public:  // But only local to this file
     // CONSTRUCTORS
     // Derived classes should call zero() in their constructor
     VerilatedCovImpItem() {
-	for (int i=0; i<MAX_KEYS; i++) m_keys[i]=KEY_UNDEF;
+	for (int i=0; i<MAX_KEYS; ++i) {
+	    m_keys[i]=KEY_UNDEF;
+	    m_vals[i]=0;
+	}
     }
     virtual ~VerilatedCovImpItem() {}
     virtual vluint64_t count() const = 0;
@@ -71,9 +72,11 @@ private:
     T*	m_countp;	///< Count value
 public:
     // METHODS
+    // cppcheck-suppress truncLongCastReturn
     virtual vluint64_t count() const { return *m_countp; }
     virtual void zero() const { *m_countp = 0; }
     // CONSTRUCTORS
+    // cppcheck-suppress noExplicitConstructor
     VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
     virtual ~VerilatedCoverItemSpec() {}
 };
@@ -128,7 +131,7 @@ private:
     string dequote(const string& text) {
 	// Quote any special characters
 	string rtn;
-	for (const char* pos = text.c_str(); *pos; pos++) {
+	for (const char* pos = text.c_str(); *pos; ++pos) {
 	    if (!isprint(*pos) || *pos=='%' || *pos=='"') {
 		char hex[10]; sprintf(hex,"%%%02X",pos[0]);
 		rtn += hex;
@@ -192,7 +195,7 @@ private:
 	return out;
     }
     bool itemMatchesString(VerilatedCovImpItem* itemp, const string& match) {
-	for (int i=0; i<MAX_KEYS; i++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (itemp->m_keys[i] != KEY_UNDEF) {
 		// We don't compare keys, only values
 		string val = m_indexValues[itemp->m_vals[i]];
@@ -260,8 +263,8 @@ public:
 	assert(m_insertp);
 	// First two key/vals are filename
 	ckeyps[0]="filename";	valps[0]=m_insertFilenamep;
-	VlCovCvtToCStr linestrp (m_insertLineno);
-	ckeyps[1]="lineno";	valps[1]=linestrp;
+	string linestr = vlCovCvtToStr(m_insertLineno);
+	ckeyps[1]="lineno";	valps[1]=linestr.c_str();
 	// Default page if not specified
 	const char* fnstartp = m_insertFilenamep;
 	while (const char* foundp = strchr(fnstartp,'/')) fnstartp=foundp+1;
@@ -272,15 +275,15 @@ public:
 
 	// Keys -> strings
 	string keys[MAX_KEYS];
-	for (int i=0; i<MAX_KEYS; i++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (ckeyps[i] && ckeyps[i][0]) {
 		keys[i] = ckeyps[i];
 	    }
 	}
 	// Ignore empty keys
-	for (int i=0; i<MAX_KEYS; i++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (keys[i]!="") {
-		for (int j=i+1; j<MAX_KEYS; j++) {
+		for (int j=i+1; j<MAX_KEYS; ++j) {
 		    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
 			keys[i] = "";
 			break;
@@ -290,7 +293,7 @@ public:
 	}
 	// Insert the values
 	int addKeynum=0;
-	for (int i=0; i<MAX_KEYS; i++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    const string key = keys[i];
 	    if (keys[i]!="") {
 		const string val = valps[i];
@@ -332,7 +335,7 @@ public:
 	    string hier;
 	    bool per_instance = false;
 
-	    for (int i=0; i<MAX_KEYS; i++) {
+	    for (int i=0; i<MAX_KEYS; ++i) {
 		if (itemp->m_keys[i] != KEY_UNDEF) {
 		    string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
 		    string val = m_indexValues[itemp->m_vals[i]];
@@ -439,8 +442,10 @@ void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
 // Backward compatibility for Verilator
 void VerilatedCov::_insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
 			     K(4),const string& val4,  A(5),A(6)) {
+    string val2str = vlCovCvtToStr(val2);
+    string val3str = vlCovCvtToStr(val3);
     _insertp(C(0),C(1),
-	     key2,VlCovCvtToCStr(val2),  key3,VlCovCvtToCStr(val3),  key4, val4.c_str(),
+	     key2,val2str.c_str(),  key3,val3str.c_str(),  key4, val4.c_str(),
 	     C(5),C(6),N(7),N(8),N(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));

include/verilated_cov.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Coverage analysis support
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #ifndef _VERILATED_COV_H_
@@ -62,9 +60,9 @@ using namespace std;
 ///
 ///	vluint32_t m_cases[10];
 ///	constructor {
-///	    for (int i=0; i<10; i++) { m_cases[i]=0; }
+///	    for (int i=0; i<10; ++i) { m_cases[i]=0; }
 ///     }
-///	for (int i=0; i<10; i++) {
+///	for (int i=0; i<10; ++i) {
 ///		VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i));
 ///	}
 
@@ -80,19 +78,6 @@ template< class T> std::string vlCovCvtToStr (const T& t) {
     ostringstream os; os<<t; return os.str();
 }
 
-/// Usage: something(VlCovCvtToCStr(i))
-/// Note the pointer will only be valid for as long as the object remains
-/// in scope!
-struct VlCovCvtToCStr {
-    string m_str;
-    // Casters
-    template< class T> VlCovCvtToCStr (const T& t) {
-	ostringstream os; os<<t; m_str=os.str();
-    }
-    ~VlCovCvtToCStr() {}
-    operator const char* () const { return m_str.c_str(); };
-};
-
 //=============================================================================
 //  VerilatedCov
 ///  Verilator coverage global class

include/verilated_cov_key.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Coverage item keys
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #ifndef _VERILATED_COV_KEY_H_

include/verilated_dpi.cpp

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2017 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.
@@ -58,31 +58,31 @@ const char* svDpiVersion() {
 //======================================================================
 // Bit-select utility functions.
 
-svBit svGetBitselBit(const svBitVecVal* s, int i) {
-    _VL_SVDPI_UNIMP(); return 0;
+svBit svGetBitselBit(const svBitVecVal* sp, int bit) {
+    return VL_BITISSET_W(sp,bit);
 }
-svLogic svGetBitselLogic(const svLogicVecVal* s, int i) {
+svLogic svGetBitselLogic(const svLogicVecVal* sp, int bit) {
     _VL_SVDPI_UNIMP(); return 0;
 }
 
-void svPutBitselBit(svBitVecVal* d, int i, svBit s) {
-    _VL_SVDPI_UNIMP();
+void svPutBitselBit(svBitVecVal* dp, int bit, svBit s) {
+    VL_ASSIGNBIT_WI(32, bit, dp, s);
 }
-void svPutBitselLogic(svLogicVecVal* d, int i, svLogic s) {
+void svPutBitselLogic(svLogicVecVal* dp, int bit, svLogic s) {
     _VL_SVDPI_UNIMP();
 }
 
-void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w) {
+void svGetPartselBit(svBitVecVal* dp, const svBitVecVal* sp, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
-void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
+void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
 
-void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w) {
+void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
-void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w) {
+void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
 

include/verilated_dpi.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.
@@ -37,25 +37,25 @@
 /// Return svBitVecVal from WData
 static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
     owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
 }
 static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
     owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
 }
 static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) {
     // Note we ignore X/Z in svLogicVecVal
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i].aval;
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i].aval;
     owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits);
 }
 static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) {
     // Note we don't create X/Z in svLogicVecVal
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words; i++) owp[i].bval=0;
-    for (int i=0; i<words-1; i++) owp[i].aval=lwp[i];
+    for (int i=0; i<words; ++i) owp[i].bval=0;
+    for (int i=0; i<words-1; ++i) owp[i].aval=lwp[i];
     owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits);
 }
 

include/verilated_heavy.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2010-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2010-2017 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.
@@ -38,29 +38,47 @@
 
 extern string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp);
 inline string VL_CVT_PACK_STR_NQ(QData lhs) {
-    IData lw[2];  VL_SET_WQ(lw, lhs);
+    WData lw[2];  VL_SET_WQ(lw, lhs);
     return VL_CVT_PACK_STR_NW(2, lw);
 }
-inline string VL_CVT_PACK_STR_NQ(const string& lhs) {
+inline string VL_CVT_PACK_STR_NN(const string& lhs) {
     return lhs;
 }
 inline string VL_CVT_PACK_STR_NI(IData lhs) {
-    IData lw[1];  lw[0] = lhs;
+    WData lw[1];  lw[0] = lhs;
     return VL_CVT_PACK_STR_NW(1, lw);
 }
 inline string VL_CONCATN_NNN(const string& lhs, const string& rhs) {
     return lhs+rhs;
 }
-inline string VL_REPLICATEN_NNQ(int,int,int rbits, const string& lhs, IData rep) {
+inline string VL_REPLICATEN_NNQ(int,int,int, const string& lhs, IData rep) {
     string out; out.reserve(lhs.length() * rep);
-    for (unsigned times=0; times<rep; times++) out += lhs;
+    for (unsigned times=0; times<rep; ++times) out += lhs;
     return out;
 }
 inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs, IData rep) {
     return VL_REPLICATEN_NNQ(obits,lbits,rbits,lhs,rep);
 }
 
+extern IData VL_FOPEN_NI(const string& filename, IData mode);
+extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb, int fnwords,
+                         const string& ofilename, void* memp, IData start, IData end);
+extern IData VL_SSCANF_INX(int lbits, const string& ld, const char* formatp, ...);
 extern void VL_SFORMAT_X(int obits_ignored, string &output, const char* formatp, ...);
 extern string VL_SFORMATF_NX(const char* formatp, ...);
+extern IData VL_VALUEPLUSARGS_INW(int rbits, const string& ld, WDataOutP rdp);
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const string& ld, IData& rdr) {
+    WData rwp[2];  // WData must always be at least 2
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = rwp[0];
+    return got;
+}
+inline IData VL_VALUEPLUSARGS_INQ(int rbits, const string& ld, QData& rdr) {
+    WData rwp[2];
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = VL_SET_QW(rwp);
+    return got;
+}
+extern IData VL_VALUEPLUSARGS_INN(int, const string& ld, string& rdr);
 
 #endif // Guard

include/verilated_imp.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2017 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.
@@ -49,7 +49,6 @@ class VerilatedImp {
     // TYPES
     typedef vector<string> ArgVec;
     typedef map<pair<const void*,void*>,void*> UserMap;
-    typedef map<const char*, const VerilatedScope*, VerilatedCStrCmp>  ScopeNameMap;
     typedef map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
 
     // MEMBERS
@@ -60,7 +59,7 @@ class VerilatedImp {
     ArgVec		m_argVec;	///< Argument list (NOT save-restored, may want different results)
     bool		m_argVecLoaded;	///< Ever loaded argument list
     UserMap	 	m_userMap;	///< Map of <(scope,userkey), userData>
-    ScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
+    VerilatedScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
     // Slow - somewhat static:
     ExportNameMap	m_exportMap;	///< Map of <export_func_proto, func number>
     int			m_exportNext;	///< Next export funcnum
@@ -93,8 +92,12 @@ public: // But only for verilated*.cpp
 
     // METHODS - arguments
     static void commandArgs(int argc, const char** argv) {
-	s_s.m_argVec.clear();
-	for (int i=0; i<argc; i++) s_s.m_argVec.push_back(argv[i]);
+	s_s.m_argVec.clear();  // Always clear
+	commandArgsAdd(argc, argv);
+    }
+    static void commandArgsAdd(int argc, const char** argv) {
+	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]);
 	s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
     }
     static string argPlusMatch(const char* prefixp) {
@@ -154,30 +157,33 @@ public: // But only for verilated*.cpp
     // METHODS - scope name
     static void scopeInsert(const VerilatedScope* scopep) {
 	// Slow ok - called once/scope at construction
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
 	if (it == s_s.m_nameMap.end()) {
 	    s_s.m_nameMap.insert(it, make_pair(scopep->name(),scopep));
 	}
     }
     static inline const VerilatedScope* scopeFind(const char* namep) {
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
 	if (VL_LIKELY(it != s_s.m_nameMap.end())) return it->second;
 	else return NULL;
     }
     static void scopeErase(const VerilatedScope* scopep) {
 	// Slow ok - called once/scope at destruction
 	userEraseScope(scopep);
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
 	if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
     }
     static void scopesDump() {
 	VL_PRINTF("  scopesDump:\n");
-	for (ScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
+	for (VerilatedScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
 	    const VerilatedScope* scopep = it->second;
 	    scopep->scopeDump();
 	}
 	VL_PRINTF("\n");
     }
+    static const VerilatedScopeNameMap* scopeNameMap() {
+        return &s_s.m_nameMap;
+    }
 
 public: // But only for verilated*.cpp
     // METHODS - export names
@@ -232,7 +238,7 @@ public: // But only for verilated*.cpp
 	    // Need to create more space in m_fdps and m_fdFree
 	    size_t start = s_s.m_fdps.size();
 	    s_s.m_fdps.resize(start*2);
-	    for (size_t i=start; i<start*2; i++) s_s.m_fdFree.push_back((IData)i);
+	    for (size_t i=start; i<start*2; ++i) s_s.m_fdFree.push_back((IData)i);
 	}
 	IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
 	s_s.m_fdps[idx] = fp;

include/verilated_save.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #include "verilatedos.h"
@@ -203,7 +201,7 @@ void VerilatedRestore::fill() {
     if (VL_UNLIKELY(!isOpen())) return;
     // Move remaining characters down to start of buffer.  (No memcpy, overlaps allowed)
     vluint8_t* rp = m_bufp;
-    for (vluint8_t* sp=m_cp; rp < m_endp;) *rp++ = *sp++;  // Overlaps
+    for (vluint8_t* sp=m_cp; sp < m_endp;) *rp++ = *sp++;  // Overlaps
     m_endp = m_bufp + (m_endp - m_cp);
     m_cp = m_bufp; // Reset buffer
     // Read into buffer starting at m_endp 

include/verilated_save.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2012-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Save-restore serialization of verilated modules
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #ifndef _VERILATED_SAVE_C_H_
@@ -50,6 +48,8 @@ protected:
 	m_bufp = new vluint8_t [bufferSize()];
 	m_cp = m_bufp;
     }
+private:
+    VerilatedSerialBase(const VerilatedSerialBase& );	///< N/A, no copy constructor
 public:
     // CREATORS
     virtual ~VerilatedSerialBase() {
@@ -225,7 +225,7 @@ inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   string& rhs) {
     return os.write(rhs.data(), len);
 }
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, string& rhs) {
-    vluint32_t len;
+    vluint32_t len=0;
     os>>len;
     rhs.resize(len);
     return os.read((void*)rhs.data(), len);

include/verilated_sc.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2017 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.

include/verilated_syms.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.
@@ -32,16 +32,6 @@
 
 #include <map>
 
-//======================================================================
-// Types
-
-struct VerilatedCStrCmp {
-    /// Ordering maps keyed by const char*'s
-    bool operator() (const char *a, const char *b) const {
-	return std::strcmp(a, b) < 0;
-    }
-};
-
 //===========================================================================
 /// Verilator range
 
@@ -93,6 +83,20 @@ public:
 //======================================================================
 /// Types
 
+struct VerilatedCStrCmp {
+    /// Ordering maps keyed by const char*'s
+    bool operator() (const char *a, const char *b) const {
+	return std::strcmp(a, b) < 0;
+    }
+};
+
+class VerilatedScopeNameMap
+    : public map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
+public:
+    VerilatedScopeNameMap() {}
+    ~VerilatedScopeNameMap() {}
+};
+
 class VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
 public:
     VerilatedVarNameMap() {}

include/verilated_vcd_c.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 
@@ -76,11 +74,48 @@ protected:
 	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
 };
 
+//=============================================================================
+//=============================================================================
+//=============================================================================
+// VerilatedVcdFile
+
+bool VerilatedVcdFile::open(const string& name) {
+    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
+    return (m_fd>=0);
+}
+
+void VerilatedVcdFile::close() {
+    ::close(m_fd);
+}
+
+ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) {
+    return ::write(m_fd, bufp, len);
+}
+
 //=============================================================================
 //=============================================================================
 //=============================================================================
 // Opening/Closing
 
+VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
+    : m_isOpen(false), m_rolloverMB(0), m_modDepth(0), m_nextCode(1) {
+    // Not in header to avoid link issue if header is included without this .cpp file
+    m_fileNewed = (filep == NULL);
+    m_filep = m_fileNewed ? new VerilatedVcdFile : filep;
+    m_namemapp = NULL;
+    m_timeRes = m_timeUnit = 1e-9;
+    m_timeLastDump = 0;
+    m_sigs_oldvalp = NULL;
+    m_evcd = false;
+    m_scopeEscape = '.';  // Backward compatibility
+    m_fullDump = true;
+    m_wrChunkSize = 8*1024;
+    m_wrBufp = new char [m_wrChunkSize*8];
+    m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
+    m_writep = m_wrBufp;
+    m_wroteBytes = 0;
+}
+
 void VerilatedVcd::open (const char* filename) {
     if (isOpen()) return;
 
@@ -142,9 +177,7 @@ void VerilatedVcd::openNext (bool incFilename) {
 	assert(0);	// Not supported yet.
     } else {
 	// cppcheck-suppress duplicateExpression
-	m_fd = ::open (m_filename.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
-		       , 0666);
-	if (m_fd<0) {
+	if (!m_filep->open(m_filename)) {
 	    // User code can check isOpen()
 	    m_isOpen = false;
 	    return;
@@ -199,6 +232,7 @@ VerilatedVcd::~VerilatedVcd() {
     if (m_wrBufp) { delete[] m_wrBufp; m_wrBufp=NULL; }
     if (m_sigs_oldvalp) { delete[] m_sigs_oldvalp; m_sigs_oldvalp=NULL; }
     deleteNameMap();
+    if (m_filep && m_fileNewed) { delete m_filep; m_filep = NULL; }
     // Remove from list of traces
     vector<VerilatedVcd*>::iterator pos = find(s_vcdVecp.begin(), s_vcdVecp.end(), this);
     if (pos != s_vcdVecp.end()) { s_vcdVecp.erase(pos); }
@@ -209,7 +243,7 @@ void VerilatedVcd::closePrev () {
 
     bufferFlush();
     m_isOpen = false;
-    ::close(m_fd);
+    m_filep->close();
 }
 
 void VerilatedVcd::closeErr () {
@@ -219,7 +253,7 @@ void VerilatedVcd::closeErr () {
 
     // No buffer flush, just fclose
     m_isOpen = false;
-    ::close(m_fd);  // May get error, just ignore it
+    m_filep->close();  // May get error, just ignore it
 }
 
 void VerilatedVcd::close() {
@@ -285,7 +319,7 @@ void VerilatedVcd::bufferFlush () {
 	ssize_t remaining = (m_writep - wp);
 	if (remaining==0) break;
 	errno = 0;
-	ssize_t got = write (m_fd, wp, remaining);
+	ssize_t got = m_filep->write(wp, remaining);
 	if (got>0) {
 	    wp += got;
 	    m_wroteBytes += got;
@@ -308,13 +342,11 @@ void VerilatedVcd::bufferFlush () {
 // Simple methods
 
 void VerilatedVcd::set_time_unit (const char* unitp) {
-    string unitstr (unitp);
     //cout<<" set_time_unit ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeUnit = timescaleToDouble(unitp);
 }
 
 void VerilatedVcd::set_time_resolution (const char* unitp) {
-    string unitstr (unitp);
     //cout<<"set_time_resolution ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeRes = timescaleToDouble(unitp);
 }
@@ -346,7 +378,7 @@ string VerilatedVcd::doubleToTimescale (double value) {
     else if (value>=1e-12) { suffixp="ps"; value *= 1e12; }
     else if (value>=1e-15) { suffixp="fs"; value *= 1e15; }
     else if (value>=1e-18) { suffixp="as"; value *= 1e18; }
-    char valuestr[100]; sprintf(valuestr,"%d%s",(int)(value), suffixp);
+    char valuestr[100]; sprintf(valuestr,"%3.0f%s", value, suffixp);
     return valuestr;  // Gets converted to string, so no ref to stack
 }
 
@@ -380,7 +412,7 @@ void VerilatedVcd::dumpHeader () {
     // We detect the spaces in module names to determine hierarchy.  This
     // allows signals to be declared without fixed ordering, which is
     // required as Verilog signals might be separately declared from
-    // "SP_TRACE" signals.
+    // SC module signals.
 
     // Print the signal names
     const char* lastName = "";
@@ -440,7 +472,7 @@ void VerilatedVcd::dumpHeader () {
     deleteNameMap();
 }
 
-void VerilatedVcd::module (string name) {
+void VerilatedVcd::module (const string& name) {
     m_modName = name;
 }
 
@@ -538,6 +570,7 @@ void VerilatedVcd::declDouble   (vluint32_t code, const char* name, int arraynum
 //=============================================================================
 
 void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
+    // cppcheck-suppress invalidPointerCast
     (*((double*)&m_sigs_oldvalp[code])) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
     sprintf(m_writep, "r%.16g", newval);
@@ -546,6 +579,7 @@ void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
     bufferCheck();
 }
 void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
+    // cppcheck-suppress invalidPointerCast
     (*((float*)&m_sigs_oldvalp[code])) = newval;
     // Buffer can't overflow before sprintf; we sized during declaration
     sprintf(m_writep, "r%.16g", (double)newval);

include/verilated_vcd_c.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 
@@ -36,6 +34,22 @@ class VerilatedVcd;
 class VerilatedVcdCallInfo;
 
 // SPDIFF_ON
+//=============================================================================
+// VerilatedFile
+/// File handling routines, which can be overrode for e.g. socket I/O
+
+class VerilatedVcdFile {
+private:
+    int			m_fd;		///< File descriptor we're writing to
+public:
+    // METHODS
+    VerilatedVcdFile() : m_fd(0) {}
+    virtual ~VerilatedVcdFile() {}
+    virtual bool open(const string& name);
+    virtual void close();
+    virtual ssize_t write(const char* bufp, ssize_t len);
+};
+
 //=============================================================================
 // VerilatedVcdSig
 /// Internal data on one signal being traced.
@@ -62,9 +76,10 @@ 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
-    int			m_fd;		///< File descriptor we're writing to
     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
@@ -129,27 +144,15 @@ private:
 	return out + ((char)((code)%94+33));
     }
 
+    VerilatedVcd(const VerilatedVcd& );	///< N/A, no copy constructor
+
 protected:
     // METHODS
     void evcd(bool flag) { m_evcd = flag; }
 
 public:
     // CREATORS
-    VerilatedVcd () : m_isOpen(false), m_rolloverMB(0), m_modDepth(0), m_nextCode(1) {
-	m_namemapp = NULL;
-	m_timeRes = m_timeUnit = 1e-9;
-	m_timeLastDump = 0;
-	m_sigs_oldvalp = NULL;
-	m_evcd = false;
-	m_scopeEscape = '.';  // Backward compatibility
-	m_fd = 0;
-	m_fullDump = true;
-	m_wrChunkSize = 8*1024;
-	m_wrBufp = new char [m_wrChunkSize*8];
-	m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
-	m_writep = m_wrBufp;
-	m_wroteBytes = 0;
-    }
+    explicit VerilatedVcd(VerilatedVcdFile* filep=NULL);
     ~VerilatedVcd();
 
     // ACCESSORS
@@ -191,7 +194,7 @@ public:
 		      void* userthis);
 
     /// Inside dumping routines, declare a module
-    void module (const string name);
+    void module (const 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);
@@ -379,11 +382,13 @@ public:
 	}
     }
     inline void chgDouble (vluint32_t code, const double newval) {
+	// cppcheck-suppress invalidPointerCast
 	if (VL_UNLIKELY((*((double*)&m_sigs_oldvalp[code])) != newval)) {
 	    fullDouble (code, newval);
 	}
     }
     inline void chgFloat (vluint32_t code, const float newval) {
+	// cppcheck-suppress invalidPointerCast
 	if (VL_UNLIKELY((*((float*)&m_sigs_oldvalp[code])) != newval)) {
 	    fullFloat (code, newval);
 	}
@@ -398,7 +403,7 @@ class VerilatedVcdC {
     VerilatedVcd		m_sptrace;	///< Trace file being created
 public:
     // CONSTRUCTORS
-    VerilatedVcdC() {}
+    explicit VerilatedVcdC(VerilatedVcdFile* filep=NULL) : m_sptrace(filep) {}
     ~VerilatedVcdC() {}
     // ACCESSORS
     /// Is file open?
@@ -425,6 +430,15 @@ public:
     void dump (double timestamp) { dump((vluint64_t)timestamp); }
     void dump (vluint32_t timestamp) { dump((vluint64_t)timestamp); }
     void dump (int timestamp) { dump((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 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 string& unit) { set_time_resolution(unit.c_str()); }
+
     /// Internal class access
     inline VerilatedVcd* spTrace () { return &m_sptrace; };
 };

include/verilated_vcd_sc.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Verilator tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 
@@ -32,6 +30,7 @@
 //--------------------------------------------------
 #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 **) {}
 
@@ -76,6 +75,7 @@ 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 **) {}
 
@@ -118,6 +118,7 @@ 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 **) {}
 

include/verilated_vcd_sc.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2014 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2017 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.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Verilator tracing in VCD format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 

include/verilatedos.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2017 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.
@@ -95,6 +95,12 @@
 // This is not necessarily the same as #UL, depending on what the IData typedef is.
 #define VL_UL(c) ((IData)(c##UL))	///< Add appropriate suffix to 32-bit constant
 
+#if defined(VL_CPPCHECK) || defined(__clang_analyzer__)
+# define VL_DANGLING(v)
+#else
+# define VL_DANGLING(v) do { (v) = NULL; } while(0)	///< After e.g. delete, set variable to NULL to indicate must not use later
+#endif
+
 //=========================================================================
 // C++-2011
 
@@ -139,7 +145,7 @@ typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward comp
 typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-# ifdef __uint32_t_defined      		// Newer Cygwin uint32_t in stdint.h as an unsigned int
+# if defined(__uint32_t_defined) || defined(___int32_t_defined)    // Newer Cygwin uint32_t in stdint.h as an unsigned int
 typedef int32_t			vlsint32_t;	///< 32-bit signed type
 typedef uint32_t		vluint32_t;	///< 32-bit unsigned type
 # else				 		// Older Cygwin has long==uint32_t
@@ -178,6 +184,7 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 #else // Linux or compliant Unix flavors, -m64
 
 # include <stdint.h>	// Linux and most flavors
+# include <unistd.h>	// Linux ssize_t
 # include <inttypes.h>	// Solaris
 typedef uint8_t			vluint8_t;	///< 32-bit unsigned type
 typedef uint16_t		vluint16_t;	///< 32-bit unsigned type
@@ -206,6 +213,18 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 # endif
 #endif
 
+#if defined(_WIN32) && defined(_MSC_VER)
+# if (_MSC_VER < 1900)
+#  define VL_SNPRINTF _snprintf
+# else
+#  define VL_SNPRINTF snprintf
+# endif
+# define VL_VSNPRINTF vsnprintf
+#else
+# define VL_SNPRINTF snprintf
+# define VL_VSNPRINTF vsnprintf
+#endif
+
 //=========================================================================
 // File system functions
 

include/vltstd/svdpi.h

@@ -155,7 +155,7 @@ XXTERN void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w);
 XXTERN void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
 
 XXTERN void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w);
-XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w);
+XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
 
 /*
  * Open array querying functions
@@ -427,7 +427,7 @@ XXTERN void svGetPartSelectLogic(svLogicVec32* d, const svLogicPackedArrRef s,
 /* actual <-- canonical */
 XXTERN void svPutPartSelectBit(svBitPackedArrRef d, const svBitVec32 s,
         int i, int w);
-XXTERN void svPutPartSelectLogic(svLogicPackedArrRef d, const svLogicVec32 s,
+XXTERN void svPutPartSelectLogic(svLogicPackedArrRef d, const svLogicVec32* s,
         int i, int w);
 
 /*

internals.pod

@@ -407,6 +407,18 @@ Tests that fail should by convention have the suffix C<_bad> in their name,
 and include C<fails =E<gt> 1> in either their C<compile> or C<execute> step as
 appropriate.
 
+=head2 Preparing to Run Tests
+
+For all tests to pass you must install the following packages:
+
+* SystemC to compile the SystemC outputs, see http://systemc.org
+
+* Parallel::Forker from CPAN to run tests in parallel, you can install this
+with e.g. "sudo cpan install Parallel::Forker".
+
+* vcddiff to find differences in VCD outputs. See the readme at
+https://github.com/veripool/vcddiff
+
 =head2 Controlling the Test Driver
 
 Test drivers are written in PERL. All invoke the main test driver script,
@@ -773,7 +785,7 @@ in C<src/Makefile_obj.in> and reconfigure.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2008-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2017 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.
 

nodist/bisondiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2014 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2017 by Wilson Snyder.  This package 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.

nodist/bisonreader

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2014 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2017 by Wilson Snyder.  This package 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.

nodist/dot_importer

@@ -143,7 +143,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2017 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.
 

nodist/dot_pruner

@@ -184,7 +184,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2017 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.
 

nodist/flexdiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2014 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2017 by Wilson Snyder.  This package 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.

nodist/install_test

@@ -115,7 +115,8 @@ sub write_verilog {
 
 sub cleanenv {
     foreach my $var (keys %ENV) {
-	if ($var eq "VERILATOR_ROOT") {
+	if ($var eq "VERILATOR_ROOT"
+	    || $var eq "VERILATOR_INCLUDE") {
 	    print "unset $var # Was '$ENV{$var}'\n";
 	    delete $ENV{$var}
 	}
@@ -183,7 +184,7 @@ Runs a specific test stage (see the script).
 
 =head1 DISTRIBUTION
 
-Copyright 2009-2014 by Wilson Snyder.  This package is free software; you
+Copyright 2009-2017 by Wilson Snyder.  This package 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.

nodist/invoke_atsim

@@ -28,7 +28,7 @@ invoke_atsim - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2017 by Wilson Snyder.  This package 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.

nodist/invoke_iccr

@@ -28,7 +28,7 @@ invoke_iccr - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2007-2014 by Wilson Snyder.  This package is free software; you
+Copyright 2007-2017 by Wilson Snyder.  This package 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.

nodist/invoke_ncverilog

@@ -28,7 +28,7 @@ invoke_ncverilog - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2017 by Wilson Snyder.  This package 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.

nodist/invoke_vcs

@@ -28,7 +28,7 @@ invoke_vcs - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2017 by Wilson Snyder.  This package 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.

nodist/vtree_importer

@@ -331,7 +331,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2014 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2017 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.
 

src/.gdbinit

@@ -1,6 +1,6 @@
 # DESCRIPTION: Verilator: GDB startup file with useful defines
 #
-# Copyright 2012-2014 by Wilson Snyder. This program is free software; you can
+# Copyright 2012-2017 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.

src/Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2017 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.
@@ -46,6 +46,8 @@ obj_opt:
 obj_dbg:
 	mkdir $@
 
+.SUFFIXES:
+
 .PHONY: ../verilator_bin ../verilator_bin_dbg ../verilator_coverage_bin_dbg
 
 opt: ../verilator_bin

src/Makefile_obj.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2017 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.
@@ -62,6 +62,8 @@ CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CPPFLAGS += @CPPFLAGS@
 LDFLAGS += @LDFLAGS@
 EXEEXT = @EXEEXT@
+CFG_CXXFLAGS_SRC = @CFG_CXXFLAGS_SRC@
+CFG_CXXFLAGS_PARSER = @CFG_CXXFLAGS_PARSER@
 
 #### End of system configuration section. ####
 
@@ -85,7 +87,8 @@ endif
 #CCMALLOC = /usr/local/lib/ccmalloc-gcc.o -lccmalloc -ldl
 
 # -lfl not needed as Flex invoked with %nowrap option
-LIBS = -lm
+# -lstdc++ needed for clang, believed harmless with gcc
+LIBS = -lm -lstdc++
 
 CPPFLAGS += -MMD
 CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir)
@@ -94,17 +97,13 @@ CPPFLAGS += -DYYDEBUG 	# Required to get nice error messages
 CPPFLAGS += $(COPT)
 CPPFLAGS += -MP # Only works on recent GCC versions
 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
-CPPFLAGS += -W -Wall -Wno-unused-parameter -Wno-char-subscripts -Werror
+CPPFLAGS += -W -Wall $(CFG_CXXFLAGS_SRC) -Werror
 #CPPFLAGS += -pedantic-errors
+else
+CPPFLAGS += $(CFG_CXXFLAGS_SRC)
 endif
 CPPFLAGSWALL   = $(CPPFLAGS)
-CPPFLAGSNOWALL = $(CPPFLAGS) -Wno-unused
-
-ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
- SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
-#else if set, leave as-is.
-#else if SYSTEMPERL="" don't set _INCLUDE so source will figure it out
-endif
+CPPFLAGSPARSER = $(CPPFLAGS) $(CFG_CXXFLAGS_PARSER)
 
 # Allow RPM builds to specify hardcoded data directories
 # To do this:
@@ -113,8 +112,6 @@ ifeq ($(CFG_WITH_DEFENV),yes)
  CPPFLAGS += -DDEFENV_SYSTEMC_ARCH=\"$(SYSTEMC_ARCH)\"
  CPPFLAGS += -DDEFENV_SYSTEMC_INCLUDE=\"$(SYSTEMC_INCLUDE)\"
  CPPFLAGS += -DDEFENV_SYSTEMC_LIBDIR=\"$(SYSTEMC_LIBDIR)\"
- CPPFLAGS += -DDEFENV_SYSTEMPERL=\"$(SYSTEMPERL)\"
- CPPFLAGS += -DDEFENV_SYSTEMPERL_INCLUDE=\"$(SYSTEMPERL_INCLUDE)\"
  ifeq ($(VERILATOR_ROOT),)	# Use what we're given, or intuit
   CPPFLAGS += -DDEFENV_VERILATOR_ROOT=\"$(pkgdatadir)\"
  else
@@ -161,6 +158,7 @@ RAW_OBJS = \
 	V3Begin.o \
 	V3Branch.o \
 	V3Broken.o \
+	V3CCtors.o \
 	V3Case.o \
 	V3Cast.o \
 	V3Cdc.o \
@@ -212,6 +210,7 @@ RAW_OBJS = \
 	V3Number.o \
 	V3Options.o \
 	V3Order.o \
+	V3Os.o \
 	V3Param.o \
 	V3PreShell.o \
 	V3Premit.o \
@@ -277,16 +276,16 @@ V3Number_test: V3Number_test.o
 	$(OBJCACHE) ${CC}  ${CPPFLAGSWALL} -c $<
 
 V3ParseLex.o:	V3ParseLex.cpp V3Lexer.yy.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3ParseGrammar.o:	V3ParseGrammar.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3ParseImp.o:	V3ParseImp.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3PreProc.o:	V3PreProc.cpp V3PreLex.yy.cpp
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 #### Generated files
 
@@ -295,7 +294,7 @@ serial:: V3Ast__gen_classes.h V3ParseBison.c
 
 serial_vlcov:: vlcovgen.d
 
-vlcovgen.d: $(VLCOVGEN) $(srcdir)/include/verilated_cov_key.h
+vlcovgen.d: $(VLCOVGEN) $(srcdir)/../include/verilated_cov_key.h
 	$(PERL) $(VLCOVGEN) --srcdir $(srcdir)
 	touch $@
 
@@ -323,6 +322,8 @@ V3PreLex_pregen.yy.cpp:	V3PreLex.l $(HEADERS)
 V3PreLex.yy.cpp: V3PreLex_pregen.yy.cpp $(FLEXFIX)
 	$(PERL) $(FLEXFIX) V3PreLex <$< >$@
 
+.SUFFIXES:
+
 ######################################################################
 ######################################################################
 

src/V3Active.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -73,7 +73,7 @@ private:
 	m_scopep->addActivep(nodep);
     }
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	m_scopep = nodep;
 	m_iActivep = NULL;
 	m_cActivep = NULL;
@@ -81,15 +81,15 @@ private:
 	nodep->iterateChildren(*this);
 	// Don't clear scopep, the namer persists beyond this visit
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Simplify sensitivity list
-	V3Const::constifyExpensiveEdit(nodep); nodep=NULL;
+	V3Const::constifyExpensiveEdit(nodep); VL_DANGLING(nodep);
     }
     // Empty visitors, speed things up
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) { }
+    virtual void visit(AstNodeStmt* nodep) { }
     //--------------------
     // Default
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	nodep->iterateChildren(*this);
     }
@@ -163,18 +163,20 @@ public:
 
 class ActiveDlyVisitor : public ActiveBaseVisitor {
 public:
-    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL };
+    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 private:
     CheckType 	m_check;	// Combo logic or other
     AstNode*	m_alwaysp;	// Always we're under
     AstNode*	m_assignp;	// In assign
     // VISITORS
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	if (m_check != CT_SEQ) {
 	    // Convert to a non-delayed assignment
 	    UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
 	    if (m_check == CT_INITIAL) {
 		nodep->v3warn(INITIALDLY,"Delayed assignments (<=) in initial or final block; suggest blocking assignments (=).");
+	    } else if (m_check == CT_LATCH) {
+		// Suppress. Shouldn't matter that the interior of the latch races 
 	    } else {
 		nodep->v3warn(COMBDLY,"Delayed assignments (<=) in non-clocked (non flop or latch) block; suggest blocking assignments (=).");
 	    }
@@ -182,10 +184,10 @@ private:
 					   nodep->lhsp()->unlinkFrBack(),
 					   nodep->rhsp()->unlinkFrBack());
 	    nodep->replaceWith(newp);
-	    nodep->deleteTree(); nodep = NULL;
+	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
-    virtual void visit(AstAssign* nodep, AstNUser*) {
+    virtual void visit(AstAssign* nodep) {
 	if (m_check == CT_SEQ) {
 	    AstNode* las = m_assignp;
 	    m_assignp = nodep;
@@ -193,7 +195,7 @@ private:
 	    m_assignp = las;
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	AstVar* varp=nodep->varp();
 	if (m_check == CT_SEQ
 	    && m_assignp
@@ -212,7 +214,7 @@ private:
 	}
     }
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -242,7 +244,7 @@ private:
     bool	m_itemSequent;	// Found a SenItem sequential
 
     // VISITORS
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// Create required actives and add to scope
 	UINFO(4," SCOPE   "<<nodep<<endl);
 	// Clear last scope's names, and collect this scope's existing names
@@ -250,10 +252,10 @@ private:
 	m_scopeFinalp = NULL;
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Actives are being formed, so we can ignore any already made
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	// Relink to IACTIVE, unless already under it
 	UINFO(4,"    INITIAL "<<nodep<<endl);
 	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
@@ -261,32 +263,32 @@ private:
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    ASSIGNW "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    ASSIGNW "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	// Relink to CACTIVE, unless already under it
 	UINFO(4,"    COVERTOGGLE "<<nodep<<endl);
 	AstActive* wantactivep = m_namer.getCActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	// Relink to CFUNC for the final
 	UINFO(4,"    FINAL "<<nodep<<endl);
 	if (!nodep->bodysp()) { // Empty, Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
@@ -302,11 +304,11 @@ private:
 	nodep->unlinkFrBack();
 	m_scopeFinalp->addStmtsp(new AstComment(nodep->fileline(), nodep->typeName()));
 	m_scopeFinalp->addStmtsp(nodep->bodysp()->unlinkFrBackWithNext());
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     // METHODS
-    void visitAlways(AstNode* nodep, AstSenTree* oldsensesp) {
+    void visitAlways(AstNode* nodep, AstSenTree* oldsensesp, VAlwaysKwd kwd) {
 	// Move always to appropriate ACTIVE based on its sense list
 	if (oldsensesp
 	    && oldsensesp->sensesp()
@@ -314,20 +316,22 @@ private:
 	    && oldsensesp->sensesp()->castSenItem()->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(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 
 	// Read sensitivitues
 	m_itemCombo = false;
 	m_itemSequent = false;
-	oldsensesp->iterateAndNext(*this);
+	if (oldsensesp) oldsensesp->iterateAndNext(*this);
 	bool combo = m_itemCombo;
 	bool sequent = m_itemSequent;
 
 	if (!combo && !sequent) combo=true;	// If no list, Verilog 2000: always @ (*)
 	if (combo && sequent) {
-	    nodep->v3error("Unsupported: Mixed edge (pos/negedge) and activity (no edge) sensitive activity list");
+	    if (!v3Global.opt.bboxUnsup()) {
+		nodep->v3error("Unsupported: Mixed edge (pos/negedge) and activity (no edge) sensitive activity list");
+	    }
 	    sequent = false;
 	}
 
@@ -349,7 +353,7 @@ private:
 
 	// Delete sensitivity list
 	if (oldsensesp) {
-	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); oldsensesp=NULL;
+	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); VL_DANGLING(oldsensesp);
 	}
 
 	// Move node to new active
@@ -358,31 +362,35 @@ private:
 
 	// Warn and/or convert any delayed assignments
 	if (combo && !sequent) {
-	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+	    if (kwd == VAlwaysKwd::ALWAYS_LATCH) {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_LATCH);
+	    } else {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+	    }
 	}
 	else if (!combo && sequent) {
 	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
 	}
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALW   "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
 
 	if (!nodep->bodysp()) {
 	    // Empty always.  Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
-	visitAlways(nodep, nodep->sensesp());
+	visitAlways(nodep, nodep->sensesp(), nodep->keyword());
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALWPub   "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
-	visitAlways(nodep, nodep->sensesp());
+	visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	AstSenItem* subitemp = nodep->sensesp();
 	if (subitemp->edgeType() != AstEdgeType::ET_ANYEDGE
 	    && subitemp->edgeType() != AstEdgeType::ET_POSEDGE
@@ -391,12 +399,12 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
 	    m_itemCombo = true;
 	    // Delete the sensitivity
 	    // We'll add it as a generic COMBO SenItem in a moment.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else if (nodep->varrefp()) {
 	    // V3LinkResolve should have cleaned most of these up
 	    if (!nodep->varrefp()->width1()) nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
@@ -407,15 +415,15 @@ private:
     }
 
     // Empty visitors, speed things up
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstVarScope* nodep, AstNUser*) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstVarScope* nodep) {}
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    ActiveVisitor(AstNetlist* nodep) {
+    explicit ActiveVisitor(AstNetlist* nodep) {
 	m_scopeFinalp = NULL;
 	m_itemCombo = false;
 	m_itemSequent = false;
@@ -430,4 +438,5 @@ public:
 void V3Active::activeAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ActiveVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("active.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Active.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3ActiveTop.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -65,19 +65,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	m_topscopep = nodep;
 	m_finder.main(m_topscopep);
 	nodep->iterateChildren(*this);
 	m_topscopep = NULL;
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    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);
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	UINFO(4,"   ACTIVE "<<nodep<<endl);
 	V3Const::constifyExpensiveEdit(nodep); // Remove duplicate clocks and such; sensesp() may change!
 	AstSenTree* sensesp = nodep->sensesp();
@@ -87,7 +87,7 @@ private:
 	    && sensesp->sensesp()->castSenItem()->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(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 	// Copy combo tree to settlement tree with duplicated statements
@@ -108,7 +108,7 @@ private:
 	    // Move the active's contents to the other active
 	    UINFO(4,"   merge active "<<sensesp<<" into "<<wantp<<endl);
 	    if (nodep->sensesStorep()) {
-		if (sensesp != nodep->sensesStorep()) nodep->v3fatalSrc("sensesStore should have been deleted earlier if different\n");
+		if (sensesp != nodep->sensesStorep()) nodep->v3fatalSrc("sensesStore should have been deleted earlier if different");
 		sensesp->unlinkFrBack();
 		// There may be other references to same sense tree,
 		// we'll be removing all references when we get to them,
@@ -120,34 +120,34 @@ private:
 	// No need to do statements under it, they're already moved.
 	//nodep->iterateChildren(*this);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
-    virtual void visit(AstFinal* nodep, AstNUser*) {
+    virtual void visit(AstFinal* nodep) {
 	nodep->v3fatalSrc("Node should have been deleted");
     }
     // Empty visitors, speed things up
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstVarScope* nodep, AstNUser*) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstVarScope* nodep) {}
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    ActiveTopVisitor(AstNetlist* nodep) {
+    explicit ActiveTopVisitor(AstNetlist* nodep) {
 	m_topscopep = NULL;
 	nodep->accept(*this);
     }
@@ -160,4 +160,5 @@ public:
 void V3ActiveTop::activeTopAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ActiveTopVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("activetop.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3ActiveTop.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Assert.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2017 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.
@@ -88,21 +88,6 @@ private:
 	return newp;
     }
 
-    AstNode* newIfCoverageOn(AstNode* nodep) {
-	// Add a internal if to check coverage is 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.coverage()
-			  ? (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicTrue()))
-			  : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
-			 nodep, NULL);
-	newp->user1(true); // Don't assert/cover this if
-	return newp;
-    }
-
     AstNode* newFireAssert(AstNode* nodep, const string& message) {
 	AstDisplay* dispp = new AstDisplay (nodep->fileline(), AstDisplayType::DT_ERROR, message, NULL, NULL);
 	AstNode* bodysp = dispp;
@@ -134,7 +119,7 @@ private:
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
-	if (stmtsp) bodysp = bodysp->addNext(stmtsp);
+	if (bodysp && stmtsp) bodysp = bodysp->addNext(stmtsp);
 	AstIf* ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
 	bodysp = ifp;
 	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
@@ -153,7 +138,7 @@ private:
 	    nodep->replaceWith(newp);
 	}
 	// Bye
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     void newVAssertion(AstVAssert* nodep, AstNode* propp) {
@@ -175,10 +160,10 @@ private:
 	// Install it
 	nodep->replaceWith(newp);
 	// Bye
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     
-    virtual void visit(AstIf* nodep, AstNUser*) {
+    virtual void visit(AstIf* nodep) {
 	if (nodep->user1SetOnce()) return;
 	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
 	    AstNodeIf* ifp = nodep;
@@ -220,8 +205,8 @@ private:
 	    // Note: if this ends with an 'else', then we don't need to validate that one of the
 	    // predicates evaluates to true.
 	    AstNode* ohot = ((allow_none || hasDefaultElse)
-			     ? (new AstOneHot0(nodep->fileline(), propp))->castNode()
-			     : (new AstOneHot (nodep->fileline(), propp))->castNode());
+			     ? 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"),
@@ -235,7 +220,7 @@ private:
     }
 
     // VISITORS  //========== Case assertions
-    virtual void visit(AstCase* nodep, AstNUser*) {
+    virtual void visit(AstCase* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->user1SetOnce()) {
 	    bool has_default=false;
@@ -260,17 +245,24 @@ private:
 		    AstNode* propp = NULL;
 		    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 			for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
-			    AstNode* onep = new AstEq(icondp->fileline(),
-						      nodep->exprp()->cloneTree(false),
-						      icondp->cloneTree(false));
+			    AstNode* onep;
+			    if (nodep->casex() || nodep->casez() || nodep->caseInside()) {
+				onep = AstEqWild::newTyped(itemp->fileline(),
+							   nodep->exprp()->cloneTree(false),
+							   icondp->cloneTree(false));
+			    } else {
+				onep = AstEq::newTyped(icondp->fileline(),
+						       nodep->exprp()->cloneTree(false),
+						       icondp->cloneTree(false));
+			    }
 			    if (propp) propp = new AstConcat(icondp->fileline(), onep, propp);
 			    else propp = onep;
 			}
 		    }
 		    bool allow_none = has_default || nodep->unique0Pragma();
 		    AstNode* ohot = (allow_none
-				     ? (new AstOneHot0(nodep->fileline(), propp))->castNode()
-				     : (new AstOneHot (nodep->fileline(), propp))->castNode());
+				     ? 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"),
@@ -283,7 +275,7 @@ private:
     }
 
     // VISITORS  //========== Statements
-    virtual void visit(AstDisplay* nodep, AstNUser*) {
+    virtual void visit(AstDisplay* nodep) {
 	nodep->iterateChildren(*this);
 	// Replace the special types with standard text
 	if (nodep->displayType()==AstDisplayType::DT_INFO) {
@@ -296,27 +288,27 @@ private:
 	}
     }
 
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
 	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
-			nodep->stmtsp(), nodep->name()); nodep=NULL;
+			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
 	++m_statAsCover;
     }
-    virtual void visit(AstVAssert* nodep, AstNUser*) {
+    virtual void visit(AstVAssert* nodep) {
 	nodep->iterateChildren(*this);
-	newVAssertion(nodep, nodep->propp()); nodep=NULL;
+	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
 	++m_statAsSV;
     }
 
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	//
 	nodep->iterateChildren(*this);
 	// Reset defaults
 	m_modp = NULL;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// This code is needed rather than a visitor in V3Begin,
 	// because V3Assert is called before V3Begin
 	AstBegin* lastp = m_beginp;
@@ -327,12 +319,12 @@ private:
 	m_beginp = lastp;
     }
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTRUCTORS
-    AssertVisitor(AstNetlist* nodep) {
+    explicit AssertVisitor(AstNetlist* nodep) {
 	m_beginp = NULL;
 	m_modp = NULL;
 	// Process
@@ -352,4 +344,5 @@ public:
 void V3Assert::assertAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     AssertVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("assert.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Assert.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2017 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.

src/V3AssertPre.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2017 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.
@@ -73,7 +73,7 @@ private:
     }
 
     // VISITORS  //========== Statements
-    virtual void visit(AstClocking* nodep, AstNUser*) {
+    virtual void visit(AstClocking* nodep) {
 	UINFO(8,"   CLOCKING"<<nodep<<endl);
 	// Store the new default clock, reset on new module
 	m_seniDefaultp = nodep->sensesp();
@@ -83,17 +83,17 @@ private:
 	} else {
 	    nodep->unlinkFrBack();
 	}
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    virtual void visit(AstPslCover* nodep) {
 	if (nodep->sentreep()) return;  // Already processed
 	clearAssertInfo();
 	nodep->iterateChildren(*this);
 	nodep->sentreep(newSenTree(nodep));
 	clearAssertInfo();
     }
-    virtual void visit(AstPslClocked* nodep, AstNUser*) {
+    virtual void visit(AstPslClocked* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_senip) {
 	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
@@ -109,20 +109,20 @@ private:
 	// Unlink and just keep a pointer to it, convert to sentree as needed
 	m_senip = nodep->sensesp();
 	nodep->replaceWith(blockp);
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	nodep->iterateChildren(*this);
 	// Reset defaults
 	m_seniDefaultp = NULL;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTRUCTORS
-    AssertPreVisitor(AstNetlist* nodep) {
+    explicit AssertPreVisitor(AstNetlist* nodep) {
 	m_seniDefaultp = NULL;
 	clearAssertInfo();
 	// Process
@@ -137,4 +137,5 @@ public:
 void V3AssertPre::assertPreAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     AssertPreVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("assertpre.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3AssertPre.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2017 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.

src/V3Ast.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -28,6 +28,7 @@
 #include "V3File.h"
 #include "V3Global.h"
 #include "V3Broken.h"
+#include "V3String.h"
 
 //======================================================================
 // Statics
@@ -79,30 +80,30 @@ void AstNode::init() {
     // Attributes
     m_didWidth = false;
     m_doingWidth = false;
-    m_user1p = NULL;
+    m_user1u = VNUser(0);
     m_user1Cnt = 0;
-    m_user2p = NULL;
+    m_user2u = VNUser(0);
     m_user2Cnt = 0;
-    m_user3p = NULL;
+    m_user3u = VNUser(0);
     m_user3Cnt = 0;
-    m_user4p = NULL;
+    m_user4u = VNUser(0);
     m_user4Cnt = 0;
-    m_user5p = NULL;
+    m_user5u = VNUser(0);
     m_user5Cnt = 0;
 }
 
 string AstNode::encodeName(const string& namein) {
     // Encode signal name raw from parser, then not called again on same signal
-    const char* start = namein.c_str();
     string out;
-    for (const char* pos = start; *pos; pos++) {
-	if ((pos==start) ? isalpha(pos[0])  // digits can't lead identifiers
+    for (string::const_iterator pos = namein.begin(); pos!=namein.end(); ++pos) {
+	if ((pos==namein.begin()) ? isalpha(pos[0])  // digits can't lead identifiers
 	    : isalnum(pos[0])) {
 	    out += pos[0];
 	} else if (pos[0]=='_') {
 	    if (pos[1]=='_') {
 		out += "_"; out += "__05F";  // hex(_) = 0x5F
-		pos++;
+		++pos;
+		if (pos==namein.end()) break;
 	    } else {
 		out += pos[0];
 	    }
@@ -115,6 +116,10 @@ string AstNode::encodeName(const string& namein) {
 	    out += hex;
 	}
     }
+    // Shorten names
+    // TODO long term use VName in place of "string name"
+    VName vname(out);
+    out = vname.hashedName();
     return out;
 }
 
@@ -161,40 +166,53 @@ string AstNode::vcdName(const string& namein) {
 }
 
 string AstNode::prettyName(const string& namein) {
+    // This function is somewhat hot, so we short-circuit some compares
     string pretty;
     pretty = "";
+    pretty.reserve(namein.length());
     for (const char* pos = namein.c_str(); *pos; ) {
-	if (0==strncmp(pos,"__BRA__",7)) {
-	    pretty += "[";
-	    pos += 7;
-	}
-	else if (0==strncmp(pos,"__KET__",7)) {
-	    pretty += "]";
-	    pos += 7;
-	}
-	else if (0==strncmp(pos,"__DOT__",7)) {
+	if (pos[0]=='-' && pos[1]=='>') { // ->
 	    pretty += ".";
-	    pos += 7;
+	    pos += 2;
+	    continue;
 	}
-	else if (0==strncmp(pos,"__PVT__",7)) {
-	    pretty += "";
-	    pos += 7;
-	}
-	else if (pos[0]=='_' && pos[1]=='_' && pos[2]=='0'
-		 && isxdigit(pos[3]) && isxdigit(pos[4])) {
-	    char value = 0;
-	    value += 16*(isdigit(pos[3]) ? (pos[3]-'0') : (tolower(pos[3])-'a'+10));
-	    value +=    (isdigit(pos[4]) ? (pos[4]-'0') : (tolower(pos[4])-'a'+10));
-	    pretty += value;
-	    pos += 5;
-	}
-	else {
-	    pretty += pos[0];
-	    pos++;
+	if (pos[0]=='_' && pos[1]=='_') { // Short-circuit
+	    if (0==strncmp(pos,"__BRA__",7)) {
+		pretty += "[";
+		pos += 7;
+		continue;
+	    }
+	    if (0==strncmp(pos,"__KET__",7)) {
+		pretty += "]";
+		pos += 7;
+		continue;
+	    }
+	    if (0==strncmp(pos,"__DOT__",7)) {
+		pretty += ".";
+		pos += 7;
+		continue;
+	    }
+	    if (0==strncmp(pos,"__PVT__",7)) {
+		pretty += "";
+		pos += 7;
+		continue;
+	    }
+	    if (pos[0]=='_' && pos[1]=='_' && pos[2]=='0'
+		     && isxdigit(pos[3]) && isxdigit(pos[4])) {
+		char value = 0;
+		value += 16*(isdigit(pos[3]) ? (pos[3]-'0') : (tolower(pos[3])-'a'+10));
+		value +=    (isdigit(pos[4]) ? (pos[4]-'0') : (tolower(pos[4])-'a'+10));
+		pretty += value;
+		pos += 5;
+		continue;
+	    }
 	}
+	// Default
+	pretty += pos[0];
+	++pos;
     }
-    if (pretty.substr(0,4) == "TOP.") pretty.replace(0,4,"");
-    if (pretty.substr(0,5) == "TOP->") pretty.replace(0,5,"");
+    if (pretty[0]=='T' && pretty.substr(0,4) == "TOP.") pretty.replace(0,4,"");
+    if (pretty[0]=='T' && pretty.substr(0,5) == "TOP->") pretty.replace(0,5,"");
     return pretty;
 }
 
@@ -226,20 +244,20 @@ inline void AstNode::debugTreeChange(const char* prefix, int lineno, bool next)
 #endif
 }
 
-AstNode* AstNode::addNext(AstNode* newp) {
+AstNode* AstNode::addNext(AstNode* nodep, AstNode* newp) {
     // Add to m_nextp, returns this
-    UASSERT(newp,"Null item passed to addNext\n");
-    this->debugTreeChange("-addNextThs: ", __LINE__, false);
+    UDEBUGONLY(if (!newp) nodep->v3fatalSrc("Null item passed to addNext"););
+    nodep->debugTreeChange("-addNextThs: ", __LINE__, false);
     newp->debugTreeChange("-addNextNew: ", __LINE__, true);
-    if (this == NULL) {
+    if (!nodep) {  // verilog.y and lots of other places assume this
 	return (newp);
     } else {
 	// Find end of old list
-	AstNode* oldtailp = this;
+	AstNode* oldtailp = nodep;
 	if (oldtailp->m_nextp) {
 	    if (oldtailp->m_headtailp) {
 		oldtailp = oldtailp->m_headtailp;  // This=beginning of list, jump to end
-		UASSERT(!oldtailp->m_nextp, "Node had next, but headtail says it shouldn't");
+		UDEBUGONLY(if (oldtailp->m_nextp) nodep->v3fatalSrc("Node had next, but headtail says it shouldn't"););
 	    } else {
 		// Though inefficent, we are occasionally passed a addNext in the middle of a list.
 		while (oldtailp->m_nextp != NULL) oldtailp = oldtailp->m_nextp;
@@ -258,21 +276,21 @@ AstNode* AstNode::addNext(AstNode* newp) {
 	newp->editCountInc();
 	if (oldtailp->m_iterpp) *(oldtailp->m_iterpp) = newp;	// Iterate on new item
     }
-    this->debugTreeChange("-addNextOut:", __LINE__, true);
-    return this;
+    nodep->debugTreeChange("-addNextOut:", __LINE__, true);
+    return nodep;
 }
 
-AstNode* AstNode::addNextNull(AstNode* newp) {
-    if (!newp) return this;
-    return addNext(newp);
+AstNode* AstNode::addNextNull(AstNode* nodep, AstNode* newp) {
+    if (!newp) return nodep;
+    return addNext(nodep, newp);
 }
 
 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(this,"Null base node");
     UASSERT(newp->backp()==NULL,"New node (back) already assigned?");
     this->debugTreeChange("-addHereThs: ", __LINE__, false);
     newp->debugTreeChange("-addHereNew: ", __LINE__, true);
@@ -596,12 +614,12 @@ void AstNode::swapWith (AstNode* bp) {
 // Clone
 
 AstNode* AstNode::cloneTreeIter() {
-    if (!this) return NULL;
+    // private: Clone single node and children
     AstNode* newp = this->clone();
-    newp->op1p(this->m_op1p->cloneTreeIterList());
-    newp->op2p(this->m_op2p->cloneTreeIterList());
-    newp->op3p(this->m_op3p->cloneTreeIterList());
-    newp->op4p(this->m_op4p->cloneTreeIterList());
+    if (this->m_op1p) newp->op1p(this->m_op1p->cloneTreeIterList());
+    if (this->m_op2p) newp->op2p(this->m_op2p->cloneTreeIterList());
+    if (this->m_op3p) newp->op3p(this->m_op3p->cloneTreeIterList());
+    if (this->m_op4p) newp->op4p(this->m_op4p->cloneTreeIterList());
     newp->m_iterpp = NULL;
     newp->clonep(this);		// Save pointers to/from both to simplify relinking.
     this->clonep(newp);		// Save pointers to/from both to simplify relinking.
@@ -609,10 +627,10 @@ AstNode* AstNode::cloneTreeIter() {
 }
 
 AstNode* AstNode::cloneTreeIterList() {
-    // Clone list of nodes, set m_headtailp
-    if (!this) return NULL;
+    // private: Clone list of nodes, set m_headtailp
     AstNode* newheadp = NULL;
     AstNode* newtailp = NULL;
+    // Audited to make sure this is never NULL
     for (AstNode* oldp = this; oldp; oldp=oldp->m_nextp) {
 	AstNode* newp = oldp->cloneTreeIter();
 	newp->m_headtailp = NULL;
@@ -627,7 +645,7 @@ AstNode* AstNode::cloneTreeIterList() {
 }
 
 AstNode* AstNode::cloneTree(bool cloneNextLink) {
-    if (!this) return NULL;
+    if (!this) return NULL;  // verilog.y relies on this
     this->debugTreeChange("-cloneThs: ", __LINE__, cloneNextLink);
     cloneClearTree();
     AstNode* newp;
@@ -648,7 +666,7 @@ AstNode* AstNode::cloneTree(bool cloneNextLink) {
 // Delete
 
 void AstNode::deleteNode() {
-    if (!this) return;
+    // private: Delete single node. Publicly call deleteTree() instead.
     UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
     editCountInc();
     // Change links of old node so we coredump if used
@@ -668,14 +686,15 @@ AstNode::~AstNode() {
 }
 
 void AstNode::deleteTreeIter() {
-    if (!this) return;
+    // private: Delete list of nodes. Publicly call deleteTree() instead.
+    // Audited to make sure this is never NULL
     for (AstNode* nodep=this, *nnextp; nodep; nodep=nnextp) {
 	nnextp = nodep->m_nextp;
 	// MUST be depth first!
-	nodep->m_op1p->deleteTreeIter();
-	nodep->m_op2p->deleteTreeIter();
-	nodep->m_op3p->deleteTreeIter();
-	nodep->m_op4p->deleteTreeIter();
+	if (nodep->m_op1p) nodep->m_op1p->deleteTreeIter();
+	if (nodep->m_op2p) nodep->m_op2p->deleteTreeIter();
+	if (nodep->m_op3p) nodep->m_op3p->deleteTreeIter();
+	if (nodep->m_op4p) nodep->m_op4p->deleteTreeIter();
 	nodep->m_nextp = NULL;
 	nodep->m_backp = NULL;
 	nodep->deleteNode();
@@ -685,7 +704,6 @@ 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.
-    if (!this) return;
     UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
     this->debugTreeChange("-delTree:  ", __LINE__, true);
     this->editCountInc();
@@ -714,53 +732,48 @@ void AstNode::operator delete(void* objp, size_t size) {
 //======================================================================
 // Iterators
 
-void AstNode::iterateChildren(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateChildren(AstNVisitor& v) {
     // This is a very hot function
-    if (!this) return;
     ASTNODE_PREFETCH(m_op1p);
     ASTNODE_PREFETCH(m_op2p);
     ASTNODE_PREFETCH(m_op3p);
     ASTNODE_PREFETCH(m_op4p);
-    // if () not needed since iterateAndNext accepts null this, but faster with it.
-    if (m_op1p) m_op1p->iterateAndNext(v, vup);
-    if (m_op2p) m_op2p->iterateAndNext(v, vup);
-    if (m_op3p) m_op3p->iterateAndNext(v, vup);
-    if (m_op4p) m_op4p->iterateAndNext(v, vup);
+    if (m_op1p) m_op1p->iterateAndNext(v);
+    if (m_op2p) m_op2p->iterateAndNext(v);
+    if (m_op3p) m_op3p->iterateAndNext(v);
+    if (m_op4p) m_op4p->iterateAndNext(v);
 }
 
-void AstNode::iterateChildrenConst(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateChildrenConst(AstNVisitor& v) {
     // This is a very hot function
-    if (!this) return;
     ASTNODE_PREFETCH(m_op1p);
     ASTNODE_PREFETCH(m_op2p);
     ASTNODE_PREFETCH(m_op3p);
     ASTNODE_PREFETCH(m_op4p);
-    // if () not needed since iterateAndNext accepts null this, but faster with it.
-    if (m_op1p) m_op1p->iterateAndNextConst(v, vup);
-    if (m_op2p) m_op2p->iterateAndNextConst(v, vup);
-    if (m_op3p) m_op3p->iterateAndNextConst(v, vup);
-    if (m_op4p) m_op4p->iterateAndNextConst(v, vup);
+    if (m_op1p) m_op1p->iterateAndNextConst(v);
+    if (m_op2p) m_op2p->iterateAndNextConst(v);
+    if (m_op3p) m_op3p->iterateAndNextConst(v);
+    if (m_op4p) m_op4p->iterateAndNextConst(v);
 }
 
-void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateAndNext(AstNVisitor& v) {
     // This is a very hot function
     // IMPORTANT: If you replace a node that's the target of this iterator,
     // then the NEW node will be iterated on next, it isn't skipped!
-    // if (!this) return;  // Part of for()
     // Future versions of this function may require the node to have a back to be iterated;
     // there's no lower level reason yet though the back must exist.
     AstNode* nodep=this;
 #ifdef VL_DEBUG  // Otherwise too hot of a function for debug
     if (VL_UNLIKELY(nodep && !nodep->m_backp)) nodep->v3fatalSrc("iterateAndNext node has no back");
 #endif
-    while (nodep) {
+    while (nodep) {   // effectively: if (!this) return;  // Callers rely on this
 	AstNode* niterp = nodep;  // This address may get stomped via m_iterpp if the node is edited
 	ASTNODE_PREFETCH(nodep->m_nextp);
 	// Desirable check, but many places where multiple iterations are OK
 	//if (VL_UNLIKELY(niterp->m_iterpp)) niterp->v3fatalSrc("IterateAndNext under iterateAndNext may miss edits");
 	// cppcheck-suppress nullPointer
 	niterp->m_iterpp = &niterp;
-	niterp->accept(v, vup);
+	niterp->accept(v);
 	// accept may do a replaceNode and change niterp on us...
 	//if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<(void*)nodep<<" now into "<<(void*)niterp<<endl);  // niterp maybe NULL, so need cast
 	if (!niterp) return;  // Perhaps node deleted inside accept
@@ -773,38 +786,37 @@ void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
     }
 }
 
-void AstNode::iterateListBackwards(AstNVisitor& v, AstNUser* vup) {
-    if (!this) return;
+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) {
 	// Edits not supported: nodep->m_iterpp = &nodep;
-	nodep->accept(v, vup);
+	nodep->accept(v);
 	if (nodep->backp()->m_nextp == nodep) nodep=nodep->backp();
 	else nodep = NULL;  // else: backp points up the tree.
     }
 }
 
-void AstNode::iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup) {
-    if (!this) return;
-    this->op1p()->iterateListBackwards(v,vup);
-    this->op2p()->iterateListBackwards(v,vup);
-    this->op3p()->iterateListBackwards(v,vup);
-    this->op4p()->iterateListBackwards(v,vup);
+void AstNode::iterateChildrenBackwards(AstNVisitor& v) {
+    if (m_op1p) m_op1p->iterateListBackwards(v);
+    if (m_op2p) m_op2p->iterateListBackwards(v);
+    if (m_op3p) m_op3p->iterateListBackwards(v);
+    if (m_op4p) m_op4p->iterateListBackwards(v);
 }
 
-void AstNode::iterateAndNextConst(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateAndNextConst(AstNVisitor& v) {
     // Keep following the current list even if edits change it
-    if (!this) return;
-    for (AstNode* nodep=this; nodep; ) {
+    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* nnextp = nodep->m_nextp;
 	ASTNODE_PREFETCH(nnextp);
-	nodep->accept(v, vup);
+	nodep->accept(v);
 	nodep = nnextp;
     }
 }
 
-AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
+AstNode* AstNode::iterateSubtreeReturnEdits(AstNVisitor& v) {
     // Some visitors perform tree edits (such as V3Const), and may even
     // replace/delete the exact nodep that the visitor is called with.  If
     // this happens, the parent will lose the handle to the node that was
@@ -814,15 +826,15 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
     AstNode* nodep = this;  // Note "this" may point to bogus point later in this function
     if (nodep->castNetlist()) {
 	// Calling on top level; we know the netlist won't get replaced
-	nodep->accept(v, vup);
+	nodep->accept(v);
     } else if (!nodep->backp()) {
 	// Calling on standalone tree; insert a shim node so we can keep track, then delete it on completion
 	AstBegin* tempp = new AstBegin(nodep->fileline(),"[EditWrapper]",nodep);
 	{
-	    tempp->stmtsp()->accept(v, vup);  nodep=NULL; // nodep to null as may be replaced
+	    tempp->stmtsp()->accept(v); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = tempp->stmtsp()->unlinkFrBackWithNext();
-	tempp->deleteTree(); tempp=NULL;
+	tempp->deleteTree(); VL_DANGLING(tempp);
     } else {
 	// Use back to determine who's pointing at us (IE assume new node grafts into same place as old one)
 	AstNode** nextnodepp = NULL;
@@ -833,7 +845,7 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 	else if (this->m_backp->m_nextp == this) nextnodepp = &(this->m_backp->m_nextp);
 	if (!nextnodepp) this->v3fatalSrc("Node's back doesn't point to forward to node itself");
 	{
-	    nodep->accept(v, vup); nodep=NULL; // nodep to null as may be replaced
+	    nodep->accept(v); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = *nextnodepp;  // Grab new node from point where old was connected
     }
@@ -843,44 +855,54 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 //======================================================================
 
 void AstNode::cloneRelinkTree() {
-    if (!this) return;
+    // private: Cleanup clone() operation on whole tree. Publicly call cloneTree() instead.
     for (AstNode* nodep=this; nodep; nodep=nodep->m_nextp) {
 	if (m_dtypep && m_dtypep->clonep()) {
-	    m_dtypep = m_dtypep->clonep()->castNodeDType();
+	    m_dtypep = m_dtypep->clonep();
 	}
 	nodep->cloneRelink();
-	nodep->m_op1p->cloneRelinkTree();
-	nodep->m_op2p->cloneRelinkTree();
-	nodep->m_op3p->cloneRelinkTree();
-	nodep->m_op4p->cloneRelinkTree();
+	if (nodep->m_op1p) nodep->m_op1p->cloneRelinkTree();
+	if (nodep->m_op2p) nodep->m_op2p->cloneRelinkTree();
+	if (nodep->m_op3p) nodep->m_op3p->cloneRelinkTree();
+	if (nodep->m_op4p) nodep->m_op4p->cloneRelinkTree();
     }
 }
 
 //======================================================================
 // Comparison
 
-bool AstNode::sameTreeIter(AstNode* node2p, bool ignNext, bool gateOnly) {
-    // Return true if the two trees are identical
-    if (this==NULL && node2p==NULL) return true;
-    if (this==NULL || node2p==NULL) return false;
-    if (this->type() != node2p->type()
-	|| this->dtypep() != node2p->dtypep()
-	|| !this->same(node2p)
-	|| (gateOnly && !this->isGateOptimizable())) {
+bool AstNode::gateTreeIter() {
+    // private: Return true if the two trees are identical
+    if (!isGateOptimizable()) return false;
+    if (m_op1p && !m_op1p->gateTreeIter()) return false;
+    if (m_op2p && !m_op2p->gateTreeIter()) return false;
+    if (m_op3p && !m_op3p->gateTreeIter()) return false;
+    if (m_op4p && !m_op4p->gateTreeIter()) return false;
+    return true;
+}
+
+bool AstNode::sameTreeIter(AstNode* node1p, 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;
+    if (node1p->type() != node2p->type()
+	|| node1p->dtypep() != node2p->dtypep()
+	|| !node1p->same(node2p)
+	|| (gateOnly && !node1p->isGateOptimizable())) {
 	return false;
     }
-    return (this->op1p()->sameTreeIter(node2p->op1p(),false,gateOnly)
-	    && this->op2p()->sameTreeIter(node2p->op2p(),false,gateOnly)
-	    && this->op3p()->sameTreeIter(node2p->op3p(),false,gateOnly)
-	    && this->op4p()->sameTreeIter(node2p->op4p(),false,gateOnly)
-	    && (ignNext || this->nextp()->sameTreeIter(node2p->nextp(),false,gateOnly))
+    return (sameTreeIter(node1p->m_op1p, node2p->m_op1p,false,gateOnly)
+	    && sameTreeIter(node1p->m_op2p, node2p->m_op2p,false,gateOnly)
+	    && sameTreeIter(node1p->m_op3p, node2p->m_op3p,false,gateOnly)
+	    && sameTreeIter(node1p->m_op4p, node2p->m_op4p,false,gateOnly)
+	    && (ignNext || sameTreeIter(node1p->m_nextp, node2p->m_nextp,false,gateOnly))
 	);
 }
 
 //======================================================================
 // Static utilities
 
-ostream& operator<<(ostream& os, V3Hash rhs) {
+ostream& operator<<(ostream& os, const V3Hash& rhs) {
     return os<<hex<<setw(2)<<setfill('0')<<rhs.depth()
 	     <<"_"<<setw(6)<<setfill('0')<<rhs.hshval();
 }
@@ -897,6 +919,7 @@ V3Hash::V3Hash(const string& name) {
 // Debugging
 
 void AstNode::checkTreeIter(AstNode* backp) {
+    // private: Check a tree and children
     if (backp != this->backp()) {
 	this->v3fatalSrc("Back node inconsistent");
     }
@@ -905,15 +928,15 @@ void AstNode::checkTreeIter(AstNode* backp) {
 	if (op1p()||op2p()||op3p()||op4p())
 	    this->v3fatalSrc("Terminal operation with non-terminals");
     }
-    if (op1p()) op1p()->checkTreeIterList(this);
-    if (op2p()) op2p()->checkTreeIterList(this);
-    if (op3p()) op3p()->checkTreeIterList(this);
-    if (op4p()) op4p()->checkTreeIterList(this);
+    if (m_op1p) m_op1p->checkTreeIterList(this);
+    if (m_op2p) m_op2p->checkTreeIterList(this);
+    if (m_op3p) m_op3p->checkTreeIterList(this);
+    if (m_op4p) m_op4p->checkTreeIterList(this);
 }
 
 void AstNode::checkTreeIterList(AstNode* backp) {
-    // Check a (possible) list of nodes, this is always the head of the list
-    if (!this) v3fatalSrc("Null nodep");
+    // private: Check a (possible) list of nodes, this is always the head of the list
+    // Audited to make sure this is never NULL
     AstNode* headp = this;
     AstNode* tailp = this;
     for (AstNode* nodep=headp; nodep; nodep=nodep->nextp()) {
@@ -927,7 +950,6 @@ void AstNode::checkTreeIterList(AstNode* backp) {
 }
 
 void AstNode::checkTree() {
-    if (!this) return;
     if (!debug()) return;
     if (this->backp()) {
 	// Linked tree- check only the passed node
@@ -938,17 +960,17 @@ void AstNode::checkTree() {
 }
 
 void AstNode::dumpGdb() {  // For GDB only
-    if (!this) { cout<<"This=NULL"<<endl; return; }
+    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 (!this) { cout<<"This=NULL"<<endl; return; }
+    if (!dynamic_cast<const AstNode*>(this)) { cout<<"This=NULL"<<endl; return; }
     dumpPtrs(cout);
     cout<<"  Fileline = "<<fileline()<<endl;
 }
 void AstNode::dumpTreeGdb() {  // For GDB only
-    if (!this) { cout<<"This=NULL"<<endl; return; }
+    if (!dynamic_cast<const AstNode*>(this)) { cout<<"This=NULL"<<endl; return; }
     dumpGdbHeader();
     dumpTree(cout);
 }
@@ -988,7 +1010,6 @@ void AstNode::dumpPtrs(ostream& os) const {
 }
 
 void AstNode::dumpTree(ostream& os, const string& indent, int maxDepth) {
-    if (!this) return;
     os<<indent<<" "<<this<<endl;
     if (debug()>8) { os<<indent<<"     "; dumpPtrs(os); }
     if (maxDepth==1) {
@@ -1002,17 +1023,17 @@ void AstNode::dumpTree(ostream& os, const string& indent, int maxDepth) {
 }
 
 void AstNode::dumpTreeAndNext(ostream& os, const string& indent, int maxDepth) {
-    if (!this) return;
+    // Audited to make sure this is never NULL
     for (AstNode* nodep=this; nodep; nodep=nodep->nextp()) {
 	nodep->dumpTree(os, indent, maxDepth);
     }
 }
 
 void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
-    if (v3Global.opt.dumpTree() && doDump) {
+    if (doDump) {
 	{   // Write log & close
 	    UINFO(2,"Dumping "<<filename<<endl);
-	    const auto_ptr<ofstream> logsp (V3File::new_ofstream(filename, append));
+	    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;
@@ -1036,8 +1057,16 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
     editCountSetLast();
 }
 
+void AstNode::v3errorEndFatal(ostringstream& str) const { v3errorEnd(str); assert(0); }
+
 void AstNode::v3errorEnd(ostringstream& str) const {
-    if (this && m_fileline) {
+    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) {
+	V3Error::v3errorEnd(str);
+    } else {
 	ostringstream nsstr;
 	nsstr<<str.str();
 	if (debug()) {
@@ -1045,14 +1074,11 @@ void AstNode::v3errorEnd(ostringstream& str) const {
 	    nsstr<<"-node: "; ((AstNode*)this)->dump(nsstr); nsstr<<endl;
 	}
 	m_fileline->v3errorEnd(nsstr);
-    } else {
-	V3Error::v3errorEnd(str);
     }
 }
 
 string AstNode::warnMore() const {
-    if (this) return this->fileline()->warnMore();
-    else return V3Error::warnMore();
+    return fileline()->warnMore();
 }
 
 //======================================================================

src/V3Ast.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -53,6 +53,7 @@ public:
     enum en m_e;
     // cppcheck-suppress uninitVar  // responsiblity of each subclass
     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; }
@@ -60,7 +61,7 @@ public:
   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, AstType rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstType& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -87,7 +88,9 @@ public:
 	return names[m_e];
     };
     inline AstNumeric () : m_e(UNSIGNED) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstNumeric (en _e) : m_e(_e) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstNumeric (VSignedState signst) {
 	if (signst==signedst_UNSIGNED) m_e=UNSIGNED;
 	else if (signst==signedst_SIGNED) m_e=SIGNED;
@@ -104,7 +107,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, AstNumeric rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstNumeric& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -121,6 +124,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -144,6 +148,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -212,6 +217,7 @@ public:
 	return names[m_e];
     };
     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; }
@@ -239,6 +245,7 @@ public:
 	//
 	DT_PUBLIC,			// V3LinkParse moves to AstTypedef::attrPublic
 	//
+	ENUM_BASE,			// V3LinkResolve creates for AstPreSel, V3LinkParam removes
 	ENUM_FIRST,			// V3Width processes
 	ENUM_LAST,			// V3Width processes
 	ENUM_NUM,			// V3Width processes
@@ -257,7 +264,9 @@ public:
 	VAR_PUBLIC_FLAT_RW,		// V3LinkParse moves to AstVar::sigPublic
 	VAR_ISOLATE_ASSIGNMENTS,	// V3LinkParse moves to AstVar::attrIsolateAssign
 	VAR_SC_BV,			// V3LinkParse moves to AstVar::attrScBv
-	VAR_SFORMAT			// V3LinkParse moves to AstVar::attrSFormat
+	VAR_SFORMAT,			// V3LinkParse moves to AstVar::attrSFormat
+	VAR_CLOCKER,                    // V3LinkParse moves to AstVar::attrClocker
+	VAR_NO_CLOCKER                  // V3LinkParse moves to AstVar::attrClocker
     };
     enum en m_e;
     const char* ascii() const {
@@ -266,15 +275,17 @@ public:
 	    "DIM_BITS", "DIM_DIMENSIONS", "DIM_HIGH", "DIM_INCREMENT", "DIM_LEFT",
 	    "DIM_LOW", "DIM_RIGHT", "DIM_SIZE", "DIM_UNPK_DIMENSIONS",
 	    "DT_PUBLIC",
-	    "ENUM_FIRST", "ENUM_LAST", "ENUM_NUM", "ENUM_NEXT", "ENUM_PREV", "ENUM_NAME",
+	    "ENUM_BASE", "ENUM_FIRST", "ENUM_LAST", "ENUM_NUM", "ENUM_NEXT", "ENUM_PREV", "ENUM_NAME",
 	    "MEMBER_BASE",
 	    "VAR_BASE", "VAR_CLOCK", "VAR_CLOCK_ENABLE", "VAR_PUBLIC",
 	    "VAR_PUBLIC_FLAT", "VAR_PUBLIC_FLAT_RD","VAR_PUBLIC_FLAT_RW",
-	    "VAR_ISOLATE_ASSIGNMENTS", "VAR_SC_BV", "VAR_SFORMAT"
+	    "VAR_ISOLATE_ASSIGNMENTS", "VAR_SC_BV", "VAR_SFORMAT", "VAR_CLOCKER",
+	    "VAR_NO_CLOCKER"
 	};
 	return names[m_e];
     };
     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; }
@@ -334,6 +345,7 @@ public:
 	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).dpiType()," MAX"),"Enum array mismatch");
     }
     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; }
@@ -384,7 +396,7 @@ public:
 	return (m_e==LOGIC || m_e==BIT);
     }
     bool isDpiUnsupported() const {
-	return (m_e==LOGIC || m_e==TIME);
+	return (m_e==TIME);
     }
     bool isDpiUnsignable() const {  // Can add "unsigned" to DPI
 	return (m_e==BYTE || m_e==SHORTINT || m_e==INT || m_e==LONGINT || m_e==INTEGER);
@@ -415,6 +427,7 @@ public:
 	SUPPLY0,
 	SUPPLY1,
 	WIRE,
+	WREAL,
 	IMPLICITWIRE,
 	TRIWIRE,
 	TRI0,
@@ -428,6 +441,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -435,13 +449,13 @@ public:
 	static const char* names[] = {
 	    "?","GPARAM","LPARAM","GENVAR",
 	    "VAR","INPUT","OUTPUT","INOUT",
-	    "SUPPLY0","SUPPLY1","WIRE","IMPLICITWIRE",
+	    "SUPPLY0","SUPPLY1","WIRE","WREAL","IMPLICITWIRE",
 	    "TRIWIRE","TRI0","TRI1",
 	    "PORT",
 	    "BLOCKTEMP","MODULETEMP","STMTTEMP","XTEMP",
 	    "IFACEREF"};
 	return names[m_e]; }
-    bool isSignal() const  { return (m_e==WIRE || m_e==IMPLICITWIRE
+    bool isSignal() const  { return (m_e==WIRE || m_e==WREAL || m_e==IMPLICITWIRE
 				     || m_e==TRIWIRE
 				     || m_e==TRI0 || m_e==TRI1
 				     || m_e==SUPPLY0 || m_e==SUPPLY1
@@ -450,7 +464,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, AstVarType rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstVarType& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 
@@ -465,6 +479,7 @@ public:
     enum en m_e;
     // CONSTRUCTOR - note defaults to *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; }
@@ -481,7 +496,40 @@ 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, AstBranchPred rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstBranchPred& rhs) { return os<<rhs.ascii(); }
+
+//######################################################################
+
+class AstVarAttrClocker {
+public:
+    enum en {
+	CLOCKER_UNKNOWN=0,
+	CLOCKER_YES,
+	CLOCKER_NO,
+	_ENUM_END
+    };
+    enum en m_e;
+    // CONSTRUCTOR - note defaults to *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; }
+    bool unknown() const { return m_e==CLOCKER_UNKNOWN; }
+    AstVarAttrClocker invert() const {
+	if (m_e==CLOCKER_YES) return CLOCKER_NO;
+	else if (m_e==CLOCKER_NO) return CLOCKER_YES;
+	else return m_e;
+    }
+    const char* ascii() const {
+	static const char* names[] = {
+	    "","clker","non_clker"};
+	return names[m_e]; }
+  };
+  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(); }
 
 //######################################################################
 
@@ -495,6 +543,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -519,6 +568,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -541,6 +591,7 @@ public:
     };
     enum en m_e;
     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; }
@@ -565,6 +616,7 @@ 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; }
@@ -576,7 +628,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, AstParseRefExp rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstParseRefExp& rhs) { return os<<rhs.ascii(); }
 
 //######################################################################
 // VNumRange - Structure containing numberic range information
@@ -628,7 +680,7 @@ struct VNumRange {
 	{ return (!m_ranged || (m_lo==0 && m_hi>=1 && !m_littleEndian)); }
     void dump(ostream& str) const { if (ranged()) str<<"["<<left()<<":"<<right()<<"]"; else str<<"[norg]"; }
 };
-inline ostream& operator<<(ostream& os, VNumRange rhs) { rhs.dump(os); return os; }
+inline ostream& operator<<(ostream& os, const VNumRange& rhs) { rhs.dump(os); return os; }
 
 //######################################################################
 
@@ -657,14 +709,14 @@ struct VBasicTypeKey {
 	if (!(m_nrange == rhs.m_nrange)) return false;  // lhs > rhs
 	return false; }
     VBasicTypeKey(int width, int widthMin, AstNumeric numeric, AstBasicDTypeKwd kwd,
-	     VNumRange nrange)
+		  const VNumRange& nrange)
 	: m_width(width), m_widthMin(widthMin), m_numeric(numeric),
 	  m_keyword(kwd), m_nrange(nrange) {}
     ~VBasicTypeKey() {}
 };
 
 //######################################################################
-// AstNUser - Generic pointer base class for AST User nodes.
+// AstNUser - Generic base class for AST User nodes.
 //	    - Also used to allow parameter passing up/down iterate calls
 
 class WidthVP;
@@ -673,26 +725,31 @@ class OrderBlockNU;
 class OrderVarNU;
 class V3GraphVertex;
 class VSymEnt;
-struct AstNUser {
-    AstNUser*	p() { return this; }	// So can take address of temporary: iterate(...,AstNUser(args).p())
+
+class VNUser {
+    union {
+	void* up;
+	int ui;
+    } m_u;
+public:
+    VNUser() {}
+    // non-explicit:
+    VNUser(int i) { m_u.up = 0; m_u.ui = i; }
+    explicit VNUser(void* p) { m_u.up = p; }
+    ~VNUser() {}
     // Casters
-    WidthVP*	c() { return ((WidthVP*)this); }
-    LinkVP*	castLinkVP() { return ((LinkVP*)this); }
-    VSymEnt*	castSymEnt() { return ((VSymEnt*)this); }
-    AstNode*	castNode() { return ((AstNode*)this); }
-    OrderBlockNU* castOrderBlock() { return ((OrderBlockNU*)this); }
-    OrderVarNU*	castOrderVar() { return ((OrderVarNU*)this); }
-    V3GraphVertex* castGraphVertex() { return ((V3GraphVertex*)this); }
-    inline int	castInt() {
-	union { AstNUser* up; int ui; } u;
-	u.up = this;
-	return u.ui;
-    }
-    static inline AstNUser* fromInt (int i) {
-	union { AstNUser* up; int ui; } u;
-	u.up=0; u.ui=i;
-	return u.up;
+    WidthVP*	c() { return ((WidthVP*)m_u.up); }
+    LinkVP*	toLinkVP() { return ((LinkVP*)m_u.up); }
+    VSymEnt*	toSymEnt() { return ((VSymEnt*)m_u.up); }
+    AstNode*	toNodep() { return ((AstNode*)m_u.up); }
+    OrderBlockNU* toOrderBlock() { return ((OrderBlockNU*)m_u.up); }
+    OrderVarNU*	toOrderVar() { return ((OrderVarNU*)m_u.up); }
+    V3GraphVertex* toGraphVertex() { return ((V3GraphVertex*)m_u.up); }
+    inline int	toInt() {
+	return m_u.ui;
     }
+    static inline VNUser fromZero () { return VNUser(0); }
+    static inline VNUser fromInt (int i) { return VNUser(i); }
 };
 
 //######################################################################
@@ -811,7 +868,8 @@ public:
     }
 #include "V3Ast__gen_visitor.h"	// From ./astgen
     // Things like:
-    //  virtual void visit(type*) = 0;
+    //  virtual void visit(AstBreak* nodep) { visit((AstNodeStmt*)(nodep)); }
+    //  virtual void visit(AstNodeStmt* nodep) { visit((AstNode*)(nodep)); }
 };
 
 //######################################################################
@@ -834,7 +892,7 @@ public:
     AstNode* oldp() const { return m_oldp; }
     void dump(ostream& str=cout) const;
 };
-inline ostream& operator<<(ostream& os, AstNRelinker& rhs) { rhs.dump(os); return os;}
+inline ostream& operator<<(ostream& os, const AstNRelinker& rhs) { rhs.dump(os); return os;}
 
 //######################################################################
 // V3Hash -- Node hashing for V3Combine
@@ -846,7 +904,8 @@ class V3Hash {
     uint32_t	m_both;
     static const uint32_t M24 = ((1<<24)-1);
     void setBoth(uint32_t depth, uint32_t hshval) {
-	if (depth==0) depth=1; if (depth>255) depth=255;
+	if (depth==0) depth=1;
+	if (depth>255) depth=255;
 	m_both = (depth<<24) | (hshval & M24);
     }
 public:
@@ -862,16 +921,19 @@ public:
     // CREATORS
     class Illegal {};		// for creator type-overload selection
     class FullValue {};		// for creator type-overload selection
-    V3Hash(Illegal) { m_both=0; }
+    explicit V3Hash(Illegal) { m_both=0; }
     // Saving and restoring inside a userp
-    V3Hash(AstNUser* up) { m_both=up->castInt(); }
+    explicit V3Hash(VNUser u) { m_both=u.toInt(); }
     V3Hash operator+= (const V3Hash& rh) {
 	setBoth(depth()+rh.depth(), (hshval()*31+rh.hshval()));
 	return *this; };
     // Creating from raw data (sameHash functions)
     V3Hash() { setBoth(1,0); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(uint32_t val) { setBoth(1,val); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(const void* vp) { setBoth(1,cvtToHash(vp)); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(const string& name);
     V3Hash(V3Hash h1, V3Hash h2) {
 	setBoth(1,h1.hshval()*31+h2.hshval()); }
@@ -880,7 +942,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, V3Hash rhs);
+ostream& operator<<(ostream& os, const V3Hash& rhs);
 
 //######################################################################
 // AstNode -- Base type of all Ast types
@@ -920,15 +982,15 @@ class AstNode {
     //		// Space for more bools here
 
     // This member ordering both allows 64 bit alignment and puts associated data together
-    AstNUser*	m_user1p;	// Pointer to any information the user iteration routine wants
+    VNUser	m_user1u;	// Contains any information the user iteration routine wants
     uint32_t	m_user1Cnt;	// Mark of when userp was set
     uint32_t	m_user2Cnt;	// Mark of when userp was set
-    AstNUser*	m_user2p;	// Pointer to any information the user iteration routine wants
-    AstNUser*	m_user3p;	// Pointer to any information the user iteration routine wants
+    VNUser	m_user2u;	// Contains any information the user iteration routine wants
+    VNUser	m_user3u;	// Contains any information the user iteration routine wants
     uint32_t	m_user3Cnt;	// Mark of when userp was set
     uint32_t	m_user4Cnt;	// Mark of when userp was set
-    AstNUser*	m_user4p;	// Pointer to any information the user iteration routine wants
-    AstNUser*	m_user5p;	// Pointer to any information the user iteration routine wants
+    VNUser	m_user4u;	// Contains any information the user iteration routine wants
+    VNUser	m_user5u;	// Contains any information the user iteration routine wants
     uint32_t	m_user5Cnt;	// Mark of when userp was set
 
     // METHODS
@@ -938,14 +1000,17 @@ 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, AstNUser* vup=NULL);
+    void	iterateListBackwards(AstNVisitor& v);
+private:
     AstNode*	cloneTreeIter();
     AstNode*	cloneTreeIterList();
     void	checkTreeIter(AstNode* backp);
     void	checkTreeIterList(AstNode* backp);
-    bool	sameTreeIter(AstNode* node2p, bool ignNext, bool gateOnly);
+    bool	gateTreeIter();
+    bool	sameTreeIter(AstNode* node1p, AstNode* node2p, bool ignNext, bool gateOnly);
     void	deleteTreeIter();
     void	deleteNode();
+public:
     static void	relinkOneLink(AstNode*& pointpr, AstNode* newp);
     // cppcheck-suppress functionConst
     void	debugTreeChange(const char* prefix, int lineno, bool next);
@@ -953,7 +1018,7 @@ class AstNode {
 protected:
     // CONSTUCTORS
     AstNode() {init(); }
-    AstNode(FileLine* fileline) {init(); m_fileline = fileline; }
+    explicit AstNode(FileLine* fileline) {init(); m_fileline = fileline; }
     virtual AstNode* clone() = 0;	// Generally, cloneTree is what you want instead
     virtual void cloneRelink() {}
     void 	cloneRelinkTree();
@@ -1045,6 +1110,7 @@ public:
     //TODO stomp these width functions out, and call via dtypep() instead
     int		width() const;
     int		widthMin() const;
+    int		widthMinV() const { return v3Global.widthMinUsage()==VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width(); }
     int		widthWords() const { return VL_WORDS_I(width()); }
     bool	isQuad() const { return (width()>VL_WORDSIZE && width()<=VL_QUADSIZE); }
     bool	isWide() const { return (width()>VL_QUADSIZE); }
@@ -1052,57 +1118,75 @@ public:
     bool	isSigned() const;
     bool	isString() const;
 
-    AstNUser*	user1p() const {
+    VNUser	user1u() const {
 	// Slows things down measurably, so disabled by default
 	//UASSERT_STATIC(AstUser1InUse::s_userBusy, "userp set w/o busy");
-	return ((m_user1Cnt==AstUser1InUse::s_userCntGbl)?m_user1p:NULL);
+	return ((m_user1Cnt==AstUser1InUse::s_userCntGbl) ? m_user1u : VNUser(0));
     }
-    void	user1p(void* userp) { m_user1p=(AstNUser*)(userp); m_user1Cnt=AstUser1InUse::s_userCntGbl; }
-    int		user1() const { return user1p()->castInt(); }
-    void	user1(int val) { user1p(AstNUser::fromInt(val)); }
-    int		user1Inc() { int v=user1(); user1(v+1); return v; }
+    AstNode*	user1p() const { return user1u().toNodep(); }
+    void	user1u(const VNUser& user) { m_user1u=user; m_user1Cnt=AstUser1InUse::s_userCntGbl; }
+    void	user1p(void* userp) { user1u(VNUser(userp)); }
+    int		user1() const { return user1u().toInt(); }
+    void	user1(int val) { user1u(VNUser(val)); }
+    int		user1Inc(int val=1) { int v=user1(); user1(v+val); return v; }
     int		user1SetOnce() { int v=user1(); if (!v) user1(1); return v; } // Better for cache than user1Inc()
     static void	user1ClearTree() { AstUser1InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    AstNUser*	user2p() const {
-	//UASSERT_STATIC(AstUser2InUse::s_userBusy, "user2p set w/o busy");
-	return ((m_user2Cnt==AstUser2InUse::s_userCntGbl)?m_user2p:NULL); }
-    void	user2p(void* userp) { m_user2p=(AstNUser*)(userp); m_user2Cnt=AstUser2InUse::s_userCntGbl; }
-    int		user2() const { return user2p()->castInt(); }
-    void	user2(int val) { user2p(AstNUser::fromInt(val)); }
-    int		user2Inc() { int v=user2(); user2(v+1); return v; }
-    int		user2SetOnce() { int v=user2(); if (!v) user2(1); return v; }
-    static void	user2ClearTree() { AstUser2InUse::clear(); }
+    VNUser	user2u() const {
+	// Slows things down measurably, so disabled by default
+	//UASSERT_STATIC(AstUser2InUse::s_userBusy, "userp set w/o busy");
+	return ((m_user2Cnt==AstUser2InUse::s_userCntGbl) ? m_user2u : VNUser(0));
+    }
+    AstNode*	user2p() const { return user2u().toNodep(); }
+    void	user2u(const VNUser& user) { m_user2u=user; m_user2Cnt=AstUser2InUse::s_userCntGbl; }
+    void	user2p(void* userp) { user2u(VNUser(userp)); }
+    int		user2() const { return user2u().toInt(); }
+    void	user2(int val) { user2u(VNUser(val)); }
+    int		user2Inc(int val=1) { int v=user2(); user2(v+val); return v; }
+    int		user2SetOnce() { int v=user2(); if (!v) user2(1); return v; } // Better for cache than user2Inc()
+    static void	user2ClearTree() { AstUser2InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    AstNUser*	user3p() const {
-	//UASSERT_STATIC(AstUser3InUse::s_userBusy, "user3p set w/o busy");
-	return ((m_user3Cnt==AstUser3InUse::s_userCntGbl)?m_user3p:NULL); }
-    void	user3p(void* userp) { m_user3p=(AstNUser*)(userp); m_user3Cnt=AstUser3InUse::s_userCntGbl; }
-    int		user3() const { return user3p()->castInt(); }
-    void	user3(int val) { user3p(AstNUser::fromInt(val)); }
-    int		user3Inc() { int v=user3(); user3(v+1); return v; }
-    int		user3SetOnce() { int v=user3(); if (!v) user3(1); return v; }
-    static void	user3ClearTree() { AstUser3InUse::clear(); }
+    VNUser	user3u() const {
+	// Slows things down measurably, so disabled by default
+	//UASSERT_STATIC(AstUser3InUse::s_userBusy, "userp set w/o busy");
+	return ((m_user3Cnt==AstUser3InUse::s_userCntGbl) ? m_user3u : VNUser(0));
+    }
+    AstNode*	user3p() const { return user3u().toNodep(); }
+    void	user3u(const VNUser& user) { m_user3u=user; m_user3Cnt=AstUser3InUse::s_userCntGbl; }
+    void	user3p(void* userp) { user3u(VNUser(userp)); }
+    int		user3() const { return user3u().toInt(); }
+    void	user3(int val) { user3u(VNUser(val)); }
+    int		user3Inc(int val=1) { int v=user3(); user3(v+val); return v; }
+    int		user3SetOnce() { int v=user3(); if (!v) user3(1); return v; } // Better for cache than user3Inc()
+    static void	user3ClearTree() { AstUser3InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    AstNUser*	user4p() const {
-	//UASSERT_STATIC(AstUser4InUse::s_userBusy, "user4p set w/o busy");
-	return ((m_user4Cnt==AstUser4InUse::s_userCntGbl)?m_user4p:NULL); }
-    void	user4p(void* userp) { m_user4p=(AstNUser*)(userp); m_user4Cnt=AstUser4InUse::s_userCntGbl; }
-    int		user4() const { return user4p()->castInt(); }
-    void	user4(int val) { user4p(AstNUser::fromInt(val)); }
-    int		user4Inc() { int v=user4(); user4(v+1); return v; }
-    int		user4SetOnce() { int v=user4(); if (!v) user4(1); return v; }
-    static void	user4ClearTree() { AstUser4InUse::clear(); }
+    VNUser	user4u() const {
+	// Slows things down measurably, so disabled by default
+	//UASSERT_STATIC(AstUser4InUse::s_userBusy, "userp set w/o busy");
+	return ((m_user4Cnt==AstUser4InUse::s_userCntGbl) ? m_user4u : VNUser(0));
+    }
+    AstNode*	user4p() const { return user4u().toNodep(); }
+    void	user4u(const VNUser& user) { m_user4u=user; m_user4Cnt=AstUser4InUse::s_userCntGbl; }
+    void	user4p(void* userp) { user4u(VNUser(userp)); }
+    int		user4() const { return user4u().toInt(); }
+    void	user4(int val) { user4u(VNUser(val)); }
+    int		user4Inc(int val=1) { int v=user4(); user4(v+val); return v; }
+    int		user4SetOnce() { int v=user4(); if (!v) user4(1); return v; } // Better for cache than user4Inc()
+    static void	user4ClearTree() { AstUser4InUse::clear(); }  // Clear userp()'s across the entire tree
 
-    AstNUser*	user5p() const {
-	//UASSERT_STATIC(AstUser5InUse::s_userBusy, "user5p set w/o busy");
-	return ((m_user5Cnt==AstUser5InUse::s_userCntGbl)?m_user5p:NULL); }
-    void	user5p(void* userp) { m_user5p=(AstNUser*)(userp); m_user5Cnt=AstUser5InUse::s_userCntGbl; }
-    int		user5() const { return user5p()->castInt(); }
-    void	user5(int val) { user5p(AstNUser::fromInt(val)); }
-    int		user5Inc() { int v=user5(); user5(v+1); return v; }
-    int		user5SetOnce() { int v=user5(); if (!v) user5(1); return v; }
-    static void	user5ClearTree() { AstUser5InUse::clear(); }
+    VNUser	user5u() const {
+	// Slows things down measurably, so disabled by default
+	//UASSERT_STATIC(AstUser5InUse::s_userBusy, "userp set w/o busy");
+	return ((m_user5Cnt==AstUser5InUse::s_userCntGbl) ? m_user5u : VNUser(0));
+    }
+    AstNode*	user5p() const { return user5u().toNodep(); }
+    void	user5u(const VNUser& user) { m_user5u=user; m_user5Cnt=AstUser5InUse::s_userCntGbl; }
+    void	user5p(void* userp) { user5u(VNUser(userp)); }
+    int		user5() const { return user5u().toInt(); }
+    void	user5(int val) { user5u(VNUser(val)); }
+    int		user5Inc(int val=1) { int v=user5(); user5(v+val); return v; }
+    int		user5SetOnce() { int v=user5(); if (!v) user5(1); return v; } // Better for cache than user5Inc()
+    static void	user5ClearTree() { AstUser5InUse::clear(); }  // Clear userp()'s across the entire tree
 
     vluint64_t	editCount() const { return m_editCount; }
     void	editCountInc() { m_editCount = ++s_editCntGbl; }  // Preincrement, so can "watch AstNode::s_editCntGbl=##"
@@ -1148,14 +1232,17 @@ public:
 
     // METHODS - dump and error
     void	v3errorEnd(ostringstream& str) const;
+    void	v3errorEndFatal(ostringstream& str) const VL_ATTR_NORETURN;
     string	warnMore() const;
     virtual void dump(ostream& str=cout);
     void	dumpGdb(); // For GDB only
     void	dumpGdbHeader() const;
 
     // METHODS - Tree modifications
-    AstNode*	addNext(AstNode* newp);		// Returns this, adds to end of list
-    AstNode*	addNextNull(AstNode* newp);	// Returns this, adds to end of list, NULL is OK
+    static AstNode* addNext(AstNode* nodep, AstNode* newp);	// Returns nodep, adds newp to end of nodep's list
+    static AstNode* addNextNull(AstNode* nodep, AstNode* newp);	// Returns nodep, adds newp (maybe NULL) to end of nodep's list
+    inline AstNode* addNext(AstNode* newp) { return addNext(this, newp); }
+    inline AstNode* addNextNull(AstNode* newp) { return addNextNull(this, newp); }
     void	addNextHere(AstNode* newp);	// Adds after speced node
     void	addPrev(AstNode* newp) { replaceWith(newp); newp->addNext(this); }
     void	addHereThisAsNext(AstNode* newp); // Adds at old place of this, this becomes next
@@ -1171,6 +1258,7 @@ public:
 
     // METHODS - Iterate on a tree
     AstNode*	cloneTree(bool cloneNextLink);
+    bool	gateTree() { return gateTreeIter(); }  // Is tree gateOptimizable?
     bool	sameTree(AstNode* node2p);	// Does tree of this == node2p?
     bool	sameGateTree(AstNode* node2p);	// Does tree of this == node2p?, not allowing non-isGateOptimizable
     void	deleteTree();	// Always deletes the next link
@@ -1203,18 +1291,16 @@ public:
     virtual const char* broken() const { return NULL; }
 
     // INVOKERS
-    virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) = 0;
-    void	iterate(AstNVisitor& v, AstNUser* vup=NULL) { this->accept(v,vup); } 	  // Does this; excludes following this->next
-    void	iterateAndNext(AstNVisitor& v, AstNUser* vup=NULL);
-    void	iterateAndNextConst(AstNVisitor& v, AstNUser* vup=NULL);
-    void	iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup=NULL) { iterateAndNextConst(v, vup); }
-    void	iterateChildren(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    void	iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    void	iterateChildrenConst(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
-    AstNode*	acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup=NULL);  // Return edited nodep; see comments in V3Ast.cpp
+    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
 
     // CONVERSION
-    AstNode*	castNode() { return this; }
 #include "V3Ast__gen_interface.h"	// From ./astgen
     // Things like:
     //  AstAlways*	castAlways();
@@ -1229,12 +1315,13 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
 
 #define ASTNODE_BASE_FUNCS(name)	\
     virtual ~Ast ##name() {} \
-    Ast ##name * cloneTree(bool cloneNext) { return AstNode::cloneTree(cloneNext)->cast ##name(); }
+    Ast ##name * cloneTree(bool cloneNext) { return static_cast<Ast ##name *>(AstNode::cloneTree(cloneNext)); } \
+    Ast ##name * clonep() const { return static_cast<Ast ##name *>(AstNode::clonep()); }
 
 class AstNodeMath : public AstNode {
     // Math -- anything that's part of an expression tree
 public:
-    AstNodeMath(FileLine* fl)
+    explicit AstNodeMath(FileLine* fl)
 	: AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeMath)
     // METHODS
@@ -1251,13 +1338,13 @@ public:
 class AstNodeTermop : public AstNodeMath {
     // Terminal operator -- a operator with no "inputs"
 public:
-    AstNodeTermop(FileLine* fl)
+    explicit AstNodeTermop(FileLine* fl)
 	: AstNodeMath(fl) {}
     ASTNODE_BASE_FUNCS(NodeTermop)
     // Know no children, and hot function, so skip iterator for speed
     // See checkTreeIter also that asserts no children
     // cppcheck-suppress functionConst
-    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
+    void iterateChildren(AstNVisitor& v) { }
 };
 
 class AstNodeUniop : public AstNodeMath {
@@ -1268,7 +1355,7 @@ public:
 	dtypeFrom(lhsp);
 	setOp1p(lhsp); }
     ASTNODE_BASE_FUNCS(NodeUniop)
-    AstNode*	lhsp() 	const { return op1p()->castNode(); }
+    AstNode*	lhsp() 	const { return op1p(); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
     // METHODS
     virtual void numberOperate(V3Number& out, const V3Number& lhs) = 0; // Set out to evaluation of a AstConst'ed lhs
@@ -1289,8 +1376,10 @@ public:
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); }
     ASTNODE_BASE_FUNCS(NodeBiop)
-    AstNode*	lhsp() 	const { return op1p()->castNode(); }
-    AstNode*	rhsp() 	const { return op2p()->castNode(); }
+    virtual AstNode* cloneType(AstNode* lhsp, AstNode* rhsp)=0;	// Clone single node, just get same type back.
+    // ACCESSORS
+    AstNode*	lhsp() 	const { return op1p(); }
+    AstNode*	rhsp() 	const { return op2p(); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
     void	rhsp(AstNode* nodep)  { return setOp2p(nodep); }
     // METHODS
@@ -1314,9 +1403,9 @@ public:
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); setOp3p(ths); }
     ASTNODE_BASE_FUNCS(NodeTriop)
-    AstNode*	lhsp() 	const { return op1p()->castNode(); }
-    AstNode*	rhsp() 	const { return op2p()->castNode(); }
-    AstNode*	thsp() 	const { return op3p()->castNode(); }
+    AstNode*	lhsp() 	const { return op1p(); }
+    AstNode*	rhsp() 	const { return op2p(); }
+    AstNode*	thsp() 	const { return op3p(); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
     void	rhsp(AstNode* nodep)  { return setOp2p(nodep); }
     void	thsp(AstNode* nodep)  { return setOp3p(nodep); }
@@ -1358,9 +1447,9 @@ public:
     ASTNODE_BASE_FUNCS(NodeCond)
     virtual void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs, const V3Number& ths) {
 	if (lhs.isNeqZero()) out.opAssign(rhs); else out.opAssign(ths); }
-    AstNode*	condp() 	const { return op1p()->castNode(); }	// op1 = Condition
-    AstNode*	expr1p() 	const { return op2p()->castNode(); }	// op2 = If true...
-    AstNode*	expr2p() 	const { return op3p()->castNode(); }	// op3 = If false...
+    AstNode*	condp() 	const { return op1p(); }	// op1 = Condition
+    AstNode*	expr1p() 	const { return op2p(); }	// op2 = If true...
+    AstNode*	expr2p() 	const { return op3p(); }	// op3 = If false...
     virtual string emitVerilog() { return "%k(%l %f? %r %k: %t)"; }
     virtual string emitC() { return "VL_COND_%nq%lq%rq%tq(%nw,%lw,%rw,%tw, %P, %li, %ri, %ti)"; }
     virtual bool cleanOut() { return false; } // clean if e1 & e2 clean
@@ -1378,10 +1467,10 @@ public:
 	: AstNode(fl) {
 	setOp1p(lhs); setOp2p(rhs); setNOp3p(ths); }
     ASTNODE_BASE_FUNCS(NodePreSel)
-    AstNode*	lhsp() 	const { return op1p()->castNode(); }
+    AstNode*	lhsp() 	const { return op1p(); }
     AstNode*	fromp() const { return lhsp(); }
-    AstNode*	rhsp() 	const { return op2p()->castNode(); }
-    AstNode*	thsp() 	const { return op3p()->castNode(); }
+    AstNode*	rhsp() 	const { return op2p(); }
+    AstNode*	thsp() 	const { return op3p(); }
     AstAttrOf*	attrp() const { return op4p()->castAttrOf(); }
     void	lhsp(AstNode* nodep)  { return setOp1p(nodep); }
     void	rhsp(AstNode* nodep)  { return setOp2p(nodep); }
@@ -1395,7 +1484,7 @@ public:
 class AstNodeStmt : public AstNode {
     // Statement -- anything that's directly under a function
 public:
-    AstNodeStmt(FileLine* fl)
+    explicit AstNodeStmt(FileLine* fl)
 	: AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeStmt)
     // METHODS
@@ -1413,8 +1502,8 @@ public:
     ASTNODE_BASE_FUNCS(NodeAssign)
     virtual AstNode*	cloneType(AstNode* lhsp, AstNode* rhsp)=0;	// Clone single node, just get same type back.
     // So iteration hits the RHS which is "earlier" in execution order, it's op1, not op2
-    AstNode* rhsp()		const { return op1p()->castNode(); }	// op1 = Assign from
-    AstNode* lhsp()		const { return op2p()->castNode(); }	// op2 = Assign to
+    AstNode* rhsp()		const { return op1p(); }	// op1 = Assign from
+    AstNode* lhsp()		const { return op2p(); }	// op2 = Assign to
     void rhsp(AstNode* np) { setOp1p(np); }
     void lhsp(AstNode* np) { setOp2p(np); }
     virtual bool hasDType() const { return true; }
@@ -1423,6 +1512,7 @@ public:
     virtual V3Hash sameHash() const { return V3Hash(); }
     virtual bool same(AstNode*) const { return true; }
     virtual string verilogKwd() const { return "="; }
+    virtual bool brokeLhsMustBeLvalue() const = 0;
 };
 
 class AstNodeFor : public AstNodeStmt {
@@ -1433,10 +1523,10 @@ public:
 	addNOp1p(initsp); setOp2p(condp); addNOp3p(incsp); addNOp4p(bodysp);
     }
     ASTNODE_BASE_FUNCS(NodeFor)
-    AstNode*	initsp()	const { return op1p()->castNode(); }	// op1= initial statements
-    AstNode*	condp()		const { return op2p()->castNode(); }	// op2= condition to continue
-    AstNode*	incsp()		const { return op3p()->castNode(); }	// op3= increment statements
-    AstNode*	bodysp()	const { return op4p()->castNode(); }	// op4= body of loop
+    AstNode*	initsp()	const { return op1p(); }	// op1= initial statements
+    AstNode*	condp()		const { return op2p(); }	// op2= condition to continue
+    AstNode*	incsp()		const { return op3p(); }	// op3= increment statements
+    AstNode*	bodysp()	const { return op4p(); }	// op4= body of loop
     virtual bool isGateOptimizable() const { return false; }
     virtual int  instrCount() const { return instrCountBranch(); }
     virtual V3Hash sameHash() const { return V3Hash(); }
@@ -1475,9 +1565,9 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeCase)
     virtual int   instrCount()	const { return instrCountBranch(); }
-    AstNode*	  exprp()	const { return op1p()->castNode(); }	// op1 = case condition <expression>
+    AstNode*	  exprp()	const { return op1p(); }	// op1 = case condition <expression>
     AstCaseItem*  itemsp()	const { return op2p()->castCaseItem(); }  // op2 = list of case expressions
-    AstNode*	  notParallelp() const { return op3p()->castNode(); }	// op3 = assertion code for non-full case's
+    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); }
 };
@@ -1485,7 +1575,7 @@ public:
 class AstNodeSenItem : public AstNode {
     // An AstSenItem or AstSenGate
 public:
-    AstNodeSenItem(FileLine* fl) : AstNode(fl) {}
+    explicit AstNodeSenItem(FileLine* fl) : AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeSenItem)
     virtual bool isClocked() const = 0;
     virtual bool isCombo() const = 0;
@@ -1539,7 +1629,7 @@ public:
     // Know no children, and hot function, so skip iterator for speed
     // See checkTreeIter also that asserts no children
     // cppcheck-suppress functionConst
-    void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
+    void iterateChildren(AstNVisitor& v) { }
 };
 
 class AstNodeText : public AstNode {
@@ -1572,7 +1662,7 @@ private:
     static int	s_uniqueNum;	// Unique number assigned to each dtype during creation for IEEE matching
 public:
     // CONSTRUCTORS
-    AstNodeDType(FileLine* fl) : AstNode(fl) {
+    explicit AstNodeDType(FileLine* fl) : AstNode(fl) {
 	m_width=0; m_widthMin=0; m_generic=false;
     }
     ASTNODE_BASE_FUNCS(NodeDType)
@@ -1589,6 +1679,7 @@ public:
     virtual bool maybePointedTo() const { return true; }
     virtual AstNodeDType* virtRefDTypep() const { return NULL; } // Iff has a non-null refDTypep(), as generic node function
     virtual void virtRefDTypep(AstNodeDType* nodep) { }	// Iff has refDTypep(), set as generic node function
+    virtual bool similarDType(AstNodeDType* samep) const = 0;  // Assignable equivalence.  Call skipRefp() on this and samep before calling
     //
     // Changing the width may confuse the data type resolution, so must clear TypeTable cache after use.
     void widthForce(int width, int sized) { m_width=width; m_widthMin=sized; }
@@ -1638,6 +1729,9 @@ public:
     virtual int widthAlignBytes() const; // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
     virtual int widthTotalBytes() const; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,...
     // op1 = members
+    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
     void addMembersp(AstNode* nodep) { addNOp1p(nodep); }
     bool packed() const { return m_packed; }
@@ -1661,22 +1755,30 @@ private:
     AstNodeDType*	m_refDTypep;	// Elements of this type (after widthing)
     AstNode*	rangenp() const { return op2p(); }	// op2 = Array(s) of variable
 public:
-    AstNodeArrayDType(FileLine* fl) : AstNodeDType(fl) {
+    explicit AstNodeArrayDType(FileLine* fl) : AstNodeDType(fl) {
 	m_refDTypep = NULL;
     }
     ASTNODE_BASE_FUNCS(NodeArrayDType)
     virtual void dump(ostream& str);
     virtual void dumpSmall(ostream& str);
     virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
-						     || (!m_refDTypep && childDTypep()))); return NULL; }
+						      || (!m_refDTypep && childDTypep()))); return NULL; }
     virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
-	m_refDTypep = m_refDTypep->clonep()->castNodeDType();
+	m_refDTypep = m_refDTypep->clonep();
     }}
     virtual bool same(AstNode* samep) const {
 	AstNodeArrayDType* sp = samep->castNodeArrayDType();
 	return (msb()==sp->msb()
 		&& subDTypep()==sp->subDTypep()
 		&& rangenp()->sameTree(sp->rangenp())); }  // HashedDT doesn't recurse, so need to check children
+    virtual bool similarDType(AstNodeDType* samep) const {
+	AstNodeArrayDType* sp = samep->castNodeArrayDType();
+	return (sp
+		&& type() == samep->type()
+		&& msb() == sp->msb()
+		&& rangenp()->sameTree(sp->rangenp())
+		&& subDTypep()->skipRefp()->similarDType(sp->subDTypep()->skipRefp()));
+    }
     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
@@ -1706,9 +1808,9 @@ public:
     AstNodeSel(FileLine* fl, AstNode* fromp, AstNode* bitp)
 	:AstNodeBiop(fl, fromp, bitp) {}
     ASTNODE_BASE_FUNCS(NodeSel)
-    AstNode* fromp() const { return op1p()->castNode(); }	// op1 = Extracting what (NULL=TBD during parsing)
+    AstNode* fromp() const { return op1p(); }	// op1 = Extracting what (NULL=TBD during parsing)
     void fromp(AstNode* nodep) { setOp1p(nodep); }
-    AstNode* bitp() const { return op2p()->castNode(); }	// op2 = Msb selection expression
+    AstNode* bitp() const { return op2p(); }	// op2 = Msb selection expression
     void bitp(AstNode* nodep) { setOp2p(nodep); }
     int	     bitConst()	const;
     virtual bool hasDType() const { return true; }
@@ -1754,16 +1856,17 @@ public:
     virtual void dump(ostream& str=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); }
     // {AstFunc only} op1 = Range output variable
     virtual void name(const string& name) 	{ m_name = name; }
     string cname() const { return m_cname; }
     void cname(const string& cname) { m_cname = cname; }
     // op1 = Output variable (functions only, NULL for tasks)
-    AstNode*	fvarp() 	const { return op1p()->castNode(); }
+    AstNode*	fvarp() 	const { return op1p(); }
     void 	addFvarp(AstNode* nodep) { addNOp1p(nodep); }
     bool	isFunction() const { return fvarp()!=NULL; }
     // op3 = Statements/Ports/Vars
-    AstNode*	stmtsp() 	const { return op3p()->castNode(); }	// op3 = List of statements
+    AstNode*	stmtsp() 	const { return op3p(); }	// op3 = List of statements
     void	addStmtsp(AstNode* nodep) { addNOp3p(nodep); }
     // op4 = scope name
     AstScopeName* scopeNamep() const { return op4p()->castScopeName(); }
@@ -1808,10 +1911,11 @@ public:
     ASTNODE_BASE_FUNCS(NodeFTaskRef)
     virtual const char* broken() const { BROKEN_RTN(m_taskp && !m_taskp->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
-	m_taskp = m_taskp->clonep()->castNodeFTask();
+	m_taskp = m_taskp->clonep();
     }}
     virtual void dump(ostream& str=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 ""
     string	prettyDotted() const { return prettyName(dotted()); }
     string	inlinedDots() const { return m_inlinedDots; }
@@ -1825,7 +1929,7 @@ public:
     // op1 = namep
     AstNode*	namep()		const { return op1p(); }
     // op2 = Pin interconnection list
-    AstNode*	pinsp() 	const { return op2p()->castNode(); }
+    AstNode*	pinsp() 	const { return op2p(); }
     void addPinsp(AstNode* nodep) { addOp2p(nodep); }
     // op3 = scope tracking
     AstScopeName* scopeNamep() const { return op3p()->castScopeName(); }
@@ -1857,7 +1961,7 @@ public:
     virtual void dump(ostream& str);
     virtual bool maybePointedTo() const { return true; }
     virtual string name()	const { return m_name; }
-    AstNode*	stmtsp() 	const { return op2p()->castNode(); }	// op2 = List of statements
+    AstNode*	stmtsp() 	const { return op2p(); }	// op2 = List of statements
     AstActive*  activesp()	const { return op3p()->castActive(); }	// op3 = List of i/sblocks
     // METHODS
     void addInlinesp(AstNode* nodep) { addOp1p(nodep); }
@@ -1907,8 +2011,8 @@ inline bool AstNode::isNeqZero()  { return (this->castConst() && this->castConst
 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(node2p, true, false); }
-inline bool AstNode::sameGateTree(AstNode* node2p) { return sameTreeIter(node2p, true, true); }
+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 void AstNodeVarRef::init() { if (m_varp) dtypep(m_varp->dtypep()); }
 
@@ -1919,8 +2023,8 @@ inline int AstNodeArrayDType::elementsConst() const { return rangep()->elementsC
 inline VNumRange AstNodeArrayDType::declRange() const { return VNumRange(msb(), lsb(), rangep()->littleEndian()); }
 
 inline void AstIfaceRefDType::cloneRelink() {
-    if (m_cellp && m_cellp->clonep()) m_cellp = m_cellp->clonep()->castCell();
-    if (m_ifacep && m_ifacep->clonep()) m_ifacep = m_ifacep->clonep()->castIface();
-    if (m_modportp && m_modportp->clonep()) m_modportp = m_modportp->clonep()->castModport(); }
+    if (m_cellp && m_cellp->clonep()) m_cellp = m_cellp->clonep();
+    if (m_ifacep && m_ifacep->clonep()) m_ifacep = m_ifacep->clonep();
+    if (m_modportp && m_modportp->clonep()) m_modportp = m_modportp->clonep(); }
 
 #endif // Guard

src/V3AstConstOnly.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3AstNodes.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -53,7 +53,7 @@ const char* AstNodeVarRef::broken() const {
 }
 
 void AstNodeVarRef::cloneRelink() {
-    if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep()->castVar(); }
+    if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep(); }
 }
 
 int AstNodeSel::bitConst() const {
@@ -140,6 +140,13 @@ AstNodeBiop* AstLte::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
     }
 }
 
+AstNodeBiop* AstEqWild::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
+    if (lhsp->isDouble() && rhsp->isDouble()) {
+	return new AstEqD(fl, lhsp, rhsp);
+    } else {
+	return new AstEqWild(fl, lhsp, rhsp);
+    }
+}
 
 bool AstVar::isSigPublic() const {
     return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp() && !isGenVar()));
@@ -195,6 +202,8 @@ string AstVar::verilogKwd() const {
 	return "tri";
     } else if (varType()==AstVarType::WIRE) {
 	return "wire";
+    } else if (varType()==AstVarType::WREAL) {
+	return "wreal";
     } else {
 	return dtypep()->name();
     }
@@ -350,6 +359,27 @@ string AstVar::scType() const {
     }
 }
 
+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 (anodep->isSc()) return anodep;
+	else return NULL;
+    }
+    else if (nodep->castVarRef()) {
+	if (nodep->castVarRef()->varp()->isSc()) return nodep->castVarRef()->varp();
+	else return NULL;
+    }
+    else if (nodep->castArraySel()) {
+	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;
+	if (nodep->op4p()) if (AstVar* p = scVarRecurse(nodep->op4p())) return p;
+    }
+    return NULL;
+}
+
 AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     // dimension passed from AstArraySel::dimension
     // Dimension 0 means the VAR itself, 1 is the closest SEL to the AstVar,
@@ -365,6 +395,7 @@ 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()) {
@@ -399,6 +430,7 @@ 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()) {
@@ -417,6 +449,7 @@ 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()) {
@@ -471,9 +504,9 @@ const char* AstScope::broken() const {
 }
 
 void AstScope::cloneRelink() {
-    if (m_aboveScopep && m_aboveScopep->clonep()) m_aboveScopep->clonep()->castScope();
-    if (m_aboveCellp && m_aboveCellp->clonep()) m_aboveCellp->clonep()->castCell();
-    if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep()->castNodeModule();
+    if (m_aboveScopep && m_aboveScopep->clonep()) m_aboveScopep->clonep();
+    if (m_aboveCellp && m_aboveCellp->clonep()) m_aboveCellp->clonep();
+    if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep();
 }
 
 string AstScope::nameDotless() const {
@@ -485,9 +518,9 @@ string AstScope::nameDotless() const {
     return out;
 }
 
-string AstScopeName::scopePrettyName() const {
+string AstScopeName::scopePrettyNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeAttrp(); textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
 	out += textp->text();
     }
     // TOP will be replaced by top->name()
@@ -497,27 +530,9 @@ string AstScopeName::scopePrettyName() const {
     return AstNode::prettyName(out);
 }
 
-string AstScopeName::scopeSymName() const {
+string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeAttrp(); textp; textp=textp->nextp()->castText()) {
-	out += textp->text();
-    }
-    if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
-    if (out.substr(0,7) == "__DOT__") out.replace(0,7,"");
-    if (out.substr(0,1) == ".") out.replace(0,1,"");
-    string::size_type pos;
-    while ((pos=out.find(".")) != string::npos) {
-	out.replace(pos, 1, "__");
-    }
-    while ((pos=out.find("__DOT__")) != string::npos) {
-	out.replace(pos, 7, "__");
-    }
-    return out;
-}
-
-string AstScopeName::scopeDpiName() const {
-    string out;
-    for (AstText* textp=scopeEntrp(); textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
 	out += textp->text();
     }
     if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
@@ -863,7 +878,7 @@ void AstNodeDType::dumpSmall(ostream& str) {
 void AstNodeArrayDType::dumpSmall(ostream& str) {
     this->AstNodeDType::dumpSmall(str);
     if (castPackArrayDType()) str<<"p"; else str<<"u";
-    str<<" "<<declRange();
+    str<<declRange();
 }
 void AstNodeArrayDType::dump(ostream& str) {
     this->AstNodeDType::dump(str);
@@ -918,7 +933,6 @@ void AstTypeTable::dump(ostream& str) {
 	for (DetailedMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
 	    AstBasicDType* dtypep = it->second;
 	    str<<endl;  // Newline from caller, so newline first
-	    stringstream nsstr;
 	    str<<"\t\tdetailed  ->  ";
 	    dtypep->dump(str);
 	}
@@ -972,6 +986,7 @@ void AstVar::dump(ostream& str) {
     if (attrFileDescr()) str<<" [aFD]";
     if (isFuncReturn()) str<<" [FUNCRTN]";
     else if (isFuncLocal()) str<<" [FUNC]";
+    if (!attrClocker().unknown()) str<<" ["<<attrClocker().ascii()<<"] ";
     str<<" "<<varType();
 }
 void AstSenTree::dump(ostream& str) {

src/V3Begin.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -56,7 +56,7 @@ public:
 	m_anyFuncInBegin = false;
     }
     ~BeginState() {}
-    void userMarkChanged(AstNodeFTask* nodep) {
+    void userMarkChanged(AstNode* nodep) {
 	nodep->user1(true);
 	m_anyFuncInBegin = true;
     }
@@ -84,13 +84,13 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_repeatNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	UINFO(8,"  "<<nodep<<endl);
 	// Rename it
 	if (m_unnamedScope != "") {
@@ -113,7 +113,7 @@ private:
 	m_namedScope = oldScope;
 	m_unnamedScope = oldUnnamed;
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// Begin blocks were only useful in variable creation, change names and delete
 	UINFO(8,"  "<<nodep<<endl);
 	string oldScope = m_namedScope;
@@ -160,21 +160,23 @@ private:
 	} else {
 	    nodep->unlinkFrBack();
 	}
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	if (m_unnamedScope != "") {
 	    // Rename it
 	    nodep->name(m_unnamedScope+"__DOT__"+nodep->name());
+	    m_statep->userMarkChanged(nodep);
 	    // Move to module
 	    nodep->unlinkFrBack();
 	    if (m_ftaskp) m_ftaskp->addStmtsp(nodep);   // Begins under funcs just move into the func
 	    else m_modp->addStmtp(nodep);
 	}
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	UINFO(8,"   CELL "<<nodep<<endl);
 	if (m_namedScope != "") {
+	    m_statep->userMarkChanged(nodep);
 	    // Rename it
 	    nodep->name(m_namedScope+"__DOT__"+nodep->name());
 	    UINFO(8,"     rename to "<<nodep->name()<<endl);
@@ -182,8 +184,16 @@ private:
 	    nodep->unlinkFrBack();
 	    m_modp->addStmtp(nodep);
 	}
+	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstVarXRef* nodep) {
+	UINFO(9, "   VARXREF "<<nodep<<endl);
+	if (m_namedScope != "" && nodep->inlinedDots() == "") {
+	    nodep->inlinedDots(m_namedScope);
+	    UINFO(9, "    rescope to "<<nodep<<endl);
+	}
+    }
+    virtual void visit(AstScopeName* nodep) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	// Similar code in V3Inline
 	if (nodep->user1SetOnce()) return;  // Don't double-add text's
@@ -196,13 +206,13 @@ private:
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCoverDecl* nodep, AstNUser*) {
+    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);
     }
     // VISITORS - LINT CHECK
-    virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
+    virtual void visit(AstIf* nodep) { // Note not AstNodeIf; other types don't get covered
 	// Check IFDEPTH warning - could be in other transform files if desire
 	int prevIfDepth = m_ifDepth;
 	if (m_ifDepth == -1 || v3Global.opt.ifDepth()<1) { // Turned off
@@ -215,8 +225,8 @@ private:
 	}
 	nodep->iterateChildren(*this);
 	m_ifDepth = prevIfDepth;
-     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    }
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -242,15 +252,30 @@ private:
     //   AstNodeFTask::user1p		// Node replaced, rename it
 
     // VISITORS
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	if (nodep->taskp()->user1()) { // It was converted
 	    UINFO(9, "    relinkFTask "<<nodep<<endl);
 	    nodep->name(nodep->taskp()->name());
 	}
 	nodep->iterateChildren(*this);
     }
+    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);
+    }
+    virtual void visit(AstIfaceRefDType* nodep) {
+	// May have changed cell names
+	// TypeTable is always after all modules, so names are stable
+	UINFO(8,"   IFACEREFDTYPE "<<nodep<<endl);
+	if (nodep->cellp()) nodep->cellName(nodep->cellp()->name());
+	UINFO(8,"       rename to "<<nodep<<endl);
+	nodep->iterateChildren(*this);
+    }
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -271,4 +296,5 @@ void V3Begin::debeginAll(AstNetlist* nodep) {
     if (state.anyFuncInBegin()) {
 	BeginRelinkVisitor brvisitor (nodep,&state);
     }
+    V3Global::dumpCheckGlobalTree("begin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Begin.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Branch.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -75,7 +75,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	UINFO(4," IF: "<<nodep<<endl);
 	int lastLikely = m_likely;
 	int lastUnlikely = m_unlikely;
@@ -101,17 +101,17 @@ private:
 	m_likely = lastLikely;
 	m_unlikely = lastUnlikely;
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	checkUnlikely(nodep);
 	nodep->funcp()->user1Inc();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	checkUnlikely(nodep);
 	m_cfuncsp.push_back(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	checkUnlikely(nodep);
 	nodep->iterateChildren(*this);
     }
@@ -128,7 +128,7 @@ private:
 
 public:
     // CONSTUCTORS
-    BranchVisitor(AstNetlist* nodep) {
+    explicit BranchVisitor(AstNetlist* nodep) {
 	reset();
 	nodep->iterateChildren(*this);
 	calc_tasks();

src/V3Branch.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Broken.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -62,7 +62,7 @@ public:
 	if (debug()>=9) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
-	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted\n");
+	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
 	}
 	if (iter!=s_nodes.end()) s_nodes.erase(iter);
     }
@@ -71,7 +71,7 @@ public:
 	if (debug()>=9) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter!=s_nodes.end() || (iter->second & FLAG_ALLOCATED)) {
-	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated\n");
+	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated");
 	}
 	if (iter == s_nodes.end()) {
 	    int flags = FLAG_ALLOCATED;  // This int needed to appease GCC 4.1.2
@@ -94,16 +94,16 @@ public:
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter == s_nodes.end()) {
 #ifdef VL_LEAK_CHECKS
-	    nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+	    nodep->v3fatalSrc("AstNode is in tree, but not allocated");
 #endif
 	} else {
 	    if (!(iter->second & FLAG_ALLOCATED)) {
 #ifdef VL_LEAK_CHECKS
-		nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+		nodep->v3fatalSrc("AstNode is in tree, but not allocated");
 #endif
 	    }
 	    if (iter->second & FLAG_IN_TREE) {
-		nodep->v3fatalSrc("AstNode is already in tree at another location\n");
+		nodep->v3fatalSrc("AstNode is already in tree at another location");
 	    }
 	}
 	int or_flags = FLAG_IN_TREE | (linkable?FLAG_LINKABLE:0);
@@ -186,14 +186,18 @@ private:
     // NODE STATE
     //  Nothing!	// This may be called deep inside other routines
     //			// so userp and friends may not be used
-    // VISITORS
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    // METHODS
+    void processAndIterate(AstNode* nodep) {
 	BrokenTable::addInTree(nodep, nodep->maybePointedTo());
 	nodep->iterateChildrenConst(*this);
     }
+    // VISITORS
+    virtual void visit(AstNode* nodep) {
+	processAndIterate(nodep);
+    }
 public:
     // CONSTUCTORS
-    BrokenMarkVisitor(AstNetlist* nodep) {
+    explicit BrokenMarkVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~BrokenMarkVisitor() {}
@@ -204,7 +208,13 @@ public:
 
 class BrokenCheckVisitor : public AstNVisitor {
 private:
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    void checkWidthMin(AstNode* nodep) {
+	if (nodep->width() != nodep->widthMin()
+	    && v3Global.widthMinUsage()==VWidthMinUsage::MATCHES_WIDTH) {
+	    nodep->v3fatalSrc("Width != WidthMin");
+	}
+    }
+    void processAndIterate(AstNode* nodep) {
 	BrokenTable::setUnder(nodep,true);
 	if (const char* whyp=nodep->broken()) {
 	    nodep->v3fatalSrc("Broken link in node (or something without maybePointedTo): "<<whyp);
@@ -220,24 +230,27 @@ 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()) {
-		if (dnodep->width() != dnodep->widthMin()
-		    && v3Global.assertWidthsMatch()) {
-		    dnodep->v3fatalSrc("Width != WidthMin");
-		}
-	    }
-	}
-	if (v3Global.assertWidthsMatch()) {
-	    if (nodep->width() != nodep->widthMin()) {
-		nodep->v3fatalSrc("Width != WidthMin");
-	    }
+	    if (AstNodeDType* dnodep = nodep->castNodeDType()) checkWidthMin(dnodep);
 	}
+	checkWidthMin(nodep);
 	nodep->iterateChildrenConst(*this);
 	BrokenTable::setUnder(nodep,false);
     }
+    virtual void visit(AstNodeAssign* nodep) {
+	processAndIterate(nodep);
+	if (v3Global.assertDTypesResolved()
+	    && nodep->brokeLhsMustBeLvalue()
+	    && nodep->lhsp()->castNodeVarRef()
+	    && !nodep->lhsp()->castNodeVarRef()->lvalue()) {
+	    nodep->v3fatalSrc("Assignment LHS is not an lvalue");
+	}
+    }
+    virtual void visit(AstNode* nodep) {
+	processAndIterate(nodep);
+    }
 public:
     // CONSTUCTORS
-    BrokenCheckVisitor(AstNetlist* nodep) {
+    explicit BrokenCheckVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~BrokenCheckVisitor() {}

src/V3Broken.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3CCtors.cpp

@@ -0,0 +1,123 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Generate C language constructors and AstCReset nodes.
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2017 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.
+//
+//*************************************************************************
+// V3CCtors's Transformations:
+//	Iterates over all modules and
+// 	for all AstVar, create a creates a AstCReset node in an _ctor_var_reset AstCFunc.
+//	for all AstCoverDecl, move the declaration into a _configure_coverage AstCFunc.
+//	For each variable that needs reset, add a AstCReset node.
+//
+//	This transformation honors outputSplitCFuncs.
+//*************************************************************************
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <cmath>
+#include <map>
+#include <vector>
+#include <algorithm>
+
+#include "V3Global.h"
+#include "V3EmitCBase.h"
+#include "V3CCtors.h"
+
+class V3CCtorsVisitor {
+private:
+    string 		m_basename;
+    string 		m_argsp;
+    string 		m_callargsp;
+    AstNodeModule*	m_modp;		// Current module
+    AstCFunc*		m_tlFuncp;	// Top level function being built
+    AstCFunc*		m_funcp;	// Current function
+    int			m_numStmts;	// Number of statements output
+    int			m_funcNum;	// Function number being built
+
+public:
+    void add(AstNode* nodep) {
+	if (v3Global.opt.outputSplitCFuncs()
+	    && v3Global.opt.outputSplitCFuncs() < m_numStmts) {
+	    m_funcp = NULL;
+	}
+	if (!m_funcp) {
+	    m_funcp = new AstCFunc(m_modp->fileline(), m_basename + "_" + cvtToStr(++m_funcNum), NULL, "void");
+	    m_funcp->isStatic(false);
+	    m_funcp->declPrivate(true);
+	    m_funcp->slow(true);
+	    m_funcp->argTypes(m_argsp);
+	    m_modp->addStmtp(m_funcp);
+
+	    // Add a top call to it
+	    AstCCall* callp = new AstCCall(m_modp->fileline(), m_funcp);
+	    callp->argTypes(m_callargsp);
+
+	    m_tlFuncp->addStmtsp(callp);
+	    m_numStmts = 0;
+	}
+	m_funcp->addStmtsp(nodep);
+	m_numStmts += 1;
+    }
+
+    V3CCtorsVisitor(AstNodeModule* nodep, string basename, string argsp="", string callargsp="",
+		    const string& stmt="") {
+	m_basename = basename;
+	m_argsp = argsp;
+	m_callargsp = callargsp;
+	m_modp = nodep;
+	m_numStmts = 0;
+	m_funcNum = 0;
+	m_tlFuncp = new AstCFunc(nodep->fileline(), basename, NULL, "void");
+	m_tlFuncp->declPrivate(true);
+	m_tlFuncp->isStatic(false);
+	m_tlFuncp->slow(true);
+	m_tlFuncp->argTypes(m_argsp);
+	if (stmt != "") {
+	    m_tlFuncp->addStmtsp(new AstCStmt(nodep->fileline(), stmt));
+	}
+	m_funcp = m_tlFuncp;
+	m_modp->addStmtp(m_tlFuncp);
+    }
+    ~V3CCtorsVisitor() {}
+};
+
+//######################################################################
+
+void V3CCtors::cctorsAll() {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castNodeModule()) {
+	// Process each module in turn
+	V3CCtorsVisitor var_reset (modp, "_ctor_var_reset");
+	V3CCtorsVisitor configure_coverage (modp, "_configure_coverage",
+					    EmitCBaseVisitor::symClassVar()+ ", bool first", "vlSymsp, first",
+					    "if (0 && vlSymsp && first) {} // Prevent unused\n");
+
+	for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
+	    AstVar* varp = np->castVar();
+	    if (varp) var_reset.add(new AstCReset(varp->fileline(), new AstVarRef(varp->fileline(), varp, true)));
+	    AstCoverDecl* coverp = np->castCoverDecl();
+	    if (coverp) {
+		AstNode* backp = coverp->backp();
+		coverp->unlinkFrBack();
+		configure_coverage.add(coverp);
+		np = backp;
+	    }
+	}
+    }
+}

src/V3CCtors.h

@@ -0,0 +1,36 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Emit CFunc's for class construction and configuration
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2017 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 _V3CCTORS_H_
+#define _V3CCTORS_H_ 1
+#include "config_build.h"
+#include "verilatedos.h"
+#include "V3Error.h"
+#include "V3Ast.h"
+
+//============================================================================
+
+class V3CCtors {
+public:
+    static void cctorsAll();
+};
+
+
+#endif // Guard

src/V3Case.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -65,7 +65,7 @@ private:
 	return level;
     }
 
-    virtual void visit(AstNodeCase* nodep, AstNUser*) {
+    virtual void visit(AstNodeCase* nodep) {
 	if (nodep->castCase() && nodep->castCase()->casex()) {
 	    nodep->v3warn(CASEX,"Suggest casez (with ?'s) in place of casex (with X's)");
 	}
@@ -90,7 +90,7 @@ private:
 	    m_caseExprp = NULL;
 	}
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	// See also neverItem
 	if (m_caseExprp && nodep->num().isFourState()) {
 	    if (m_caseExprp->castGenCase()) {
@@ -107,12 +107,12 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    CaseLintVisitor(AstNodeCase* nodep) {
+    explicit CaseLintVisitor(AstNodeCase* nodep) {
 	m_caseExprp = NULL;
 	nodep->accept(*this);
     }
@@ -174,7 +174,7 @@ private:
 	    for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 		//if (debug()>=9) icondp->dumpTree(cout," caseitem: ");
 		AstConst* iconstp = icondp->castConst();
-		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this\n");
+		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this");
 		if (neverItem(nodep, iconstp)) {
 		    // X in casez can't ever be executed
 		} else {
@@ -246,7 +246,7 @@ private:
 		if (m_valueItem[a] != m_valueItem[b]) { same=false; break; }
 	    }
 	    if (same) {
-		tree1p->deleteTree(); tree1p=NULL;
+		tree1p->deleteTree(); VL_DANGLING(tree1p);
 		return tree0p;
 	    }
 
@@ -295,8 +295,8 @@ private:
 
 	if (ifrootp) nodep->replaceWith(ifrootp);
 	else nodep->unlinkFrBack();
-	nodep->deleteTree(); nodep=NULL;
-	cexprp->deleteTree(); cexprp=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
+	cexprp->deleteTree(); VL_DANGLING(cexprp);
 	if (debug()>=9) ifrootp->dumpTree(cout,"    _simp: ");
     }
 
@@ -327,7 +327,7 @@ private:
 		    AstConst* iconstp = icondp->castConst();
 		    if (iconstp && neverItem(nodep, iconstp)) {
 			// X in casez can't ever be executed
-			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
+			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());
@@ -351,7 +351,7 @@ private:
 			AstNode* and2p = new AstAnd(itemp->fileline(),
 						    new AstConst(itemp->fileline(), numval),
 						    new AstConst(itemp->fileline(), nummask));
-			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
+			icondp->deleteTree(); VL_DANGLING(icondp); VL_DANGLING(iconstp);
 			condp = AstEq::newTyped(itemp->fileline(), and1p, and2p);
 		    } else {
 			// Not a caseX mask, we can simply build CASEEQ(cexpr icond)
@@ -369,7 +369,7 @@ private:
 		itemp->condsp(ifexprp);
 	    }
 	}
-	cexprp->deleteTree(); cexprp=NULL;
+	cexprp->deleteTree(); VL_DANGLING(cexprp);
 	if (!hadDefault) {
 	    // If there was no default, add a empty one, this greatly simplifies below code
 	    // and constant propagation will just eliminate it for us later.
@@ -408,9 +408,9 @@ private:
 		}
 	    }
 	    {   // Make the new lower IF and attach in the tree
-		AstNode* itemexprp = ifexprp;  ifexprp=NULL;
+		AstNode* itemexprp = ifexprp; VL_DANGLING(ifexprp);
 		if (depth == (CASE_ENCODER_GROUP_DEPTH)) { // End of group - can skip the condition
-		    itemexprp->deleteTree(); itemexprp=NULL;
+		    itemexprp->deleteTree(); VL_DANGLING(itemexprp);
 		    itemexprp = new AstConst(itemp->fileline(), AstConst::LogicTrue());
 		}
 		AstIf* newp = new AstIf(itemp->fileline(), itemexprp, istmtsp, NULL);
@@ -423,10 +423,10 @@ private:
 	// Handle any assertions
 	replaceCaseParallel(nodep, false);
 	// Replace the CASE... with IF...
-	if (debug()>=9) grouprootp->dumpTree(cout,"     _new: ");
+	if (debug()>=9 && grouprootp) grouprootp->dumpTree(cout,"     _new: ");
 	if (grouprootp) nodep->replaceWith(grouprootp);
 	else nodep->unlinkFrBack();
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     void replaceCaseParallel(AstCase* nodep, bool noOverlapsAllCovered) {
@@ -451,7 +451,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstCase* nodep, AstNUser*) {
+    virtual void visit(AstCase* nodep) {
 	V3Case::caseLint(nodep);
 	nodep->iterateChildren(*this);
 	if (debug()>=9) nodep->dumpTree(cout," case_old: ");
@@ -459,21 +459,21 @@ private:
 	    // It's a simple priority encoder or complete statement
 	    // we can make a tree of statements to avoid extra comparisons
 	    ++m_statCaseFast;
-	    replaceCaseFast(nodep); nodep=NULL;
+	    replaceCaseFast(nodep); VL_DANGLING(nodep);
 	} else {
 	    ++m_statCaseSlow;
-	    replaceCaseComplicated(nodep); nodep=NULL;
+	    replaceCaseComplicated(nodep); VL_DANGLING(nodep);
 	}
     }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    CaseVisitor(AstNetlist* nodep) {
+    explicit CaseVisitor(AstNetlist* nodep) {
 	m_caseNoOverlapsAllCovered = false;
 	nodep->accept(*this);
     }
@@ -489,6 +489,7 @@ public:
 void V3Case::caseAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CaseVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("case.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 void V3Case::caseLint(AstNodeCase* nodep) {
     UINFO(4,__FUNCTION__<<": "<<endl);

src/V3Case.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Cast.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2004-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2017 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.
@@ -107,19 +107,19 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->sizeMattersLhs()) insureCast(nodep->lhsp());
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	nodep->iterateChildren(*this);
 	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, AstNUser*) {
+    virtual void visit(AstNodeTriop* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1()
 		    | nodep->rhsp()->user1()
@@ -128,12 +128,12 @@ private:
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
 	if (nodep->sizeMattersThs()) insureCast(nodep->thsp());
     }
-    virtual void visit(AstCCast* nodep, AstNUser*) {
+    virtual void visit(AstCCast* nodep) {
 	nodep->iterateChildren(*this);
 	insureLower32Cast(nodep);
 	nodep->user1(1);
     }
-    virtual void visit(AstNegate* nodep, AstNUser*) {
+    virtual void visit(AstNegate* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->lhsp()->widthMin()==1) {
@@ -145,10 +145,11 @@ private:
 	    insureCast(nodep->lhsp());
 	}
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!nodep->lvalue()
 	    && !nodep->backp()->castCCast()
 	    && nodep->backp()->castNodeMath()
+	    && !nodep->backp()->castArraySel()
 	    && nodep->backp()->width()
 	    && castSize(nodep) != castSize(nodep->varp())) {
 	    // Cast vars to IData first, else below has upper bits wrongly set
@@ -157,7 +158,7 @@ private:
 	}
 	nodep->user1(1);
     }
-    virtual void visit(AstConst* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) {
 	// Constants are of unknown size if smaller than 33 bits, becase
 	// we're too lazy to wrap every constant in the universe in
 	// ((IData)#).
@@ -165,17 +166,17 @@ private:
     }
 
     // NOPs
-    virtual void visit(AstVar* nodep, AstNUser*) {}
+    virtual void visit(AstVar* nodep) {}
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    CastVisitor(AstNetlist* nodep) {
+    explicit CastVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CastVisitor() {}
@@ -187,4 +188,5 @@ public:
 void V3Cast::castAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CastVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("cast.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Cast.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2004-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2017 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.

src/V3Cdc.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -138,7 +138,7 @@ private:
     ofstream*		m_ofp;		// Output file
     string		m_prefix;
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	*m_ofp<<m_prefix;
 	if (nodep->user3()) *m_ofp<<" %%";
 	else *m_ofp<<"  ";
@@ -172,7 +172,7 @@ private:
     int		m_maxLineno;
     size_t	m_maxFilenameLen;
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	// Keeping line+filename lengths separate is much faster than calling ascii().length()
 	if (nodep->fileline()->lineno() >= m_maxLineno) {
@@ -184,7 +184,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    CdcWidthVisitor(AstNode* nodep) {
+    explicit CdcWidthVisitor(AstNode* nodep) {
 	m_maxLineno = 0;
 	m_maxFilenameLen = 0;
 	nodep->accept(*this);
@@ -496,7 +496,7 @@ private:
 	}
 
 	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc_edges.txt";
-	const auto_ptr<ofstream> ofp (V3File::new_ofstream(filename));
+	const VL_UNIQUE_PTR<ofstream> ofp (V3File::new_ofstream(filename));
 	if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
 	*ofp<<"Edge Report for "<<v3Global.opt.prefix()<<endl;
 
@@ -591,32 +591,32 @@ private:
 	    vertexp->dstDomainp(senoutp);
 	    if (debug()>=9) {
 		UINFO(9,spaces(level)+"     Tracedst "<<vertexp);
-		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+		if (senoutp) { V3EmitV::verilogForTree(senoutp, cout); cout<<endl; }
 	    }
 	} else {
 	    vertexp->srcDomainSet(true);  // Note it's set - domainp may be null, so can't use that
 	    vertexp->srcDomainp(senoutp);
 	    if (debug()>=9) {
 		UINFO(9,spaces(level)+"     Tracesrc "<<vertexp);
-		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+		if (senoutp) { V3EmitV::verilogForTree(senoutp, cout); cout<<endl; }
 	    }
 	}
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," SCOPE "<<nodep<<endl);
 	m_scopep = nodep;
 	m_logicVertexp = NULL;
 	nodep->iterateChildren(*this);
 	m_scopep = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Create required blocks and add to module
 	UINFO(4,"  BLOCK  "<<nodep<<endl);
 	AstNode::user2ClearTree();
@@ -627,11 +627,11 @@ private:
 	m_domainp = NULL;
 	AstNode::user2ClearTree();
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	if (m_scopep) {
-	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block\n");
+	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block");
 	    AstVarScope* varscp = nodep->varScopep();
-	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
 	    CdcVarVertex* varvertexp = makeVarVertex(varscp);
 	    UINFO(5," VARREF to "<<varscp<<endl);
 	    // We use weight of one for normal edges,
@@ -655,78 +655,78 @@ private:
 	    }
 	}
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
 	nodep->iterateChildren(*this);
 	m_inDly = false;
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    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);
 	m_inSenItem = false;
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPublic* nodep) {
 	// CDC doesn't care about public variables
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	// First handle the clock part will be handled in a minute by visit AstSenItem
 	// The logic gating term is delt with as logic
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	iterateNewStmt(nodep);
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	iterateNewStmt(nodep);
     }
 
     // Math that shouldn't cause us to clear hazard
-    virtual void visit(AstConst* nodep, AstNUser*) { }
-    virtual void visit(AstReplicate* nodep, AstNUser*) {
+    virtual void visit(AstConst* nodep) { }
+    virtual void visit(AstReplicate* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstConcat* nodep, AstNUser*) {
+    virtual void visit(AstConcat* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNot* nodep, AstNUser*) {
+    virtual void visit(AstNot* nodep) {
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	if (!nodep->lsbp()->castConst()) setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNodeSel* nodep, AstNUser*) {
+    virtual void visit(AstNodeSel* nodep) {
 	if (!nodep->bitp()->castConst()) setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
 
     // Ignores
-    virtual void visit(AstInitial* nodep, AstNUser*) { }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) { }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) { }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) { }
+    virtual void visit(AstInitial* nodep) { }
+    virtual void visit(AstTraceInc* nodep) { }
+    virtual void visit(AstCoverToggle* nodep) { }
+    virtual void visit(AstNodeDType* nodep) { }
 
     //--------------------
     // Default
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	setNodeHazard(nodep);
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    CdcVisitor(AstNode* nodep) {
+    explicit CdcVisitor(AstNode* nodep) {
 	m_logicVertexp = NULL;
 	m_scopep = NULL;
 	m_modp = NULL;

src/V3Cdc.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Changed.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -43,6 +43,176 @@
 #include "V3Changed.h"
 #include "V3EmitCBase.h"
 
+//######################################################################
+
+class ChangedState {
+public:
+    // STATE
+    AstNodeModule*	m_topModp;	// Top module
+    AstScope*		m_scopetopp;	// Scope under TOPSCOPE
+    AstCFunc*		m_chgFuncp;	// Change function we're building
+    AstCFunc*		m_tlChgFuncp;	// Top level change function we're building
+    int			m_numStmts;     // Number of statements added to m_chgFuncp
+    int 		m_funcNum;	// Number of change functions emitted
+
+    ChangedState() {
+	m_topModp = NULL;
+	m_chgFuncp = NULL;
+	m_scopetopp = NULL;
+	m_tlChgFuncp = NULL;
+	m_numStmts = 0;
+	m_funcNum = 0;
+    }
+    ~ChangedState() {}
+
+    void maybeCreateChgFuncp() {
+	// Don't create an extra function call if splitting is disabled
+	if (!v3Global.opt.outputSplitCFuncs()) {
+	    m_chgFuncp = m_tlChgFuncp;
+	    return;
+	}
+	if (!m_chgFuncp || v3Global.opt.outputSplitCFuncs() < m_numStmts) {
+	    m_chgFuncp = new AstCFunc(m_scopetopp->fileline(), "_change_request_" + cvtToStr(++m_funcNum), m_scopetopp, "QData");
+	    m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
+	    m_chgFuncp->symProlog(true);
+	    m_chgFuncp->declPrivate(true);
+	    m_scopetopp->addActivep(m_chgFuncp);
+
+	    // Add a top call to it
+	    AstCCall* callp = new AstCCall(m_scopetopp->fileline(), m_chgFuncp);
+	    callp->argTypes("vlSymsp");
+
+	    if (!m_tlChgFuncp->stmtsp()) {
+		m_tlChgFuncp->addStmtsp(new AstCReturn(m_scopetopp->fileline(), callp));
+	    } else {
+		AstCReturn* returnp = m_tlChgFuncp->stmtsp()->castCReturn();
+		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
+		// inside V3EmitC, however, it also means that verbose logging may miss to print change detect variables.
+		AstNode* newp = new AstCReturn(m_scopetopp->fileline(),
+					       new AstLogOr(m_scopetopp->fileline(), callp,
+							    returnp->lhsp()->unlinkFrBack()));
+		returnp->replaceWith(newp);
+		returnp->deleteTree(); VL_DANGLING(returnp);
+	    }
+	    m_numStmts = 0;
+	}
+    }
+};
+
+//######################################################################
+// Utility visitor to find elements to be compared
+
+class ChangedInsertVisitor : public AstNVisitor {
+private:
+    // STATE
+    ChangedState*	m_statep;	// Shared state across visitors
+    AstVarScope*	m_vscp;		// Original (non-change) variable we're change-detecting
+    AstVarScope*	m_newvscp;	// New (change detect) variable we're change-detecting
+    AstNode*		m_varEqnp;	// Original var's equation to get var value
+    AstNode*		m_newLvEqnp;	// New var's equation to read value 
+    AstNode*		m_newRvEqnp;	// New var's equation to set value 
+    uint32_t		m_detects;	// # detects created
+
+    // CONSTANTS
+    enum MiscConsts {
+	DETECTARRAY_MAX_INDEXES = 256	// How many indexes before error
+	// Ok to increase this, but may result in much slower model
+    };
+
+    void newChangeDet() {
+	if (++m_detects > DETECTARRAY_MAX_INDEXES) {
+	    m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect more than "<<cvtToStr(DETECTARRAY_MAX_INDEXES)
+			   <<" array indexes (probably with UNOPTFLAT warning suppressed): "<<m_vscp->prettyName()<<endl
+			   <<m_vscp->warnMore()
+			   <<"... Could recompile with DETECTARRAY_MAX_INDEXES increased"<<endl);
+	    return;
+	}
+	m_statep->maybeCreateChgFuncp();
+
+	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));
+	m_statep->m_chgFuncp->addFinalsp(initp);
+	EmitCBaseCounterVisitor visitor(initp);
+	m_statep->m_numStmts += visitor.count();
+    }
+
+    virtual void visit(AstBasicDType* nodep) {
+	newChangeDet();
+    }
+    virtual void visit(AstPackArrayDType* nodep) {
+	newChangeDet();
+    }
+    virtual void visit(AstUnpackArrayDType* nodep) {
+	for (int index=0; index < nodep->elementsConst(); ++index) {
+	    AstNode* origVEp = m_varEqnp;
+	    AstNode* origNLEp = m_newLvEqnp;
+	    AstNode* origNREp = m_newRvEqnp;
+
+	    m_varEqnp   = new AstArraySel(nodep->fileline(), m_varEqnp->cloneTree(true), index);
+	    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);
+
+	    m_varEqnp->deleteTree();
+	    m_newLvEqnp->deleteTree();
+	    m_newRvEqnp->deleteTree();
+
+	    m_varEqnp   = origVEp;
+	    m_newLvEqnp = origNLEp;
+	    m_newRvEqnp = origNREp;
+	}
+    }
+    virtual void visit(AstNodeClassDType* nodep) {
+	if (nodep->packedUnsup()) {
+	    newChangeDet();
+	} else {
+	    if (debug()) nodep->dumpTree(cout,"-DETECTARRAY-class-");
+	    m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<m_vscp->varp()->prettyName());
+	}
+    }
+    virtual void visit(AstNode* nodep) {
+	nodep->iterateChildren(*this);
+	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): "<<m_vscp->varp()->prettyName());
+    }
+public:
+    // CONSTUCTORS
+    ChangedInsertVisitor(AstVarScope* vscp, ChangedState* statep) {
+	m_statep = statep;
+	m_vscp = vscp;
+	m_detects = 0;
+	{
+	    AstVar* varp = m_vscp->varp();
+	    string newvarname = "__Vchglast__"+m_vscp->scopep()->nameDotless()+"__"+varp->shortName();
+	    // Create:  VARREF(_last)
+	    //          ASSIGN(VARREF(_last), VARREF(var))
+	    //          ...
+	    //          CHANGEDET(VARREF(_last), VARREF(var))
+	    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);
+
+	    m_varEqnp   = new AstVarRef(m_vscp->fileline(), m_vscp, false);
+	    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);
+	m_varEqnp->deleteTree();
+	m_newLvEqnp->deleteTree();
+	m_newRvEqnp->deleteTree();
+    }
+    virtual ~ChangedInsertVisitor() {}
+};
+
 //######################################################################
 // Changed state, as a visitor of each AstNode
 
@@ -54,15 +224,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // STATE
-    AstNodeModule*	m_topModp;	// Top module
-    AstScope*		m_scopetopp;	// Scope under TOPSCOPE
-    AstCFunc*		m_chgFuncp;	// Change function we're building
-
-    // CONSTANTS
-    enum MiscConsts {
-	DETECTARRAY_MAX_INDEXES = 256	// How many indexes before error
-	// Ok to increase this, but may result in much slower model
-    };
+    ChangedState*	m_statep;	// Shared state across visitors
 
     // METHODS
     static int debug() {
@@ -71,92 +233,43 @@ private:
 	return level;
     }
 
-    AstNode* aselIfNeeded(bool isArray, int index, AstNode* childp) {
-	if (isArray) {
-	    return new AstArraySel(childp->fileline(), childp,
-				   new AstConst(childp->fileline(), index));
-	} else {
-	    return childp;
-	}
-    }
-
     void genChangeDet(AstVarScope* vscp) {
-	AstVar* varp = vscp->varp();
 	vscp->v3warn(IMPERFECTSCH,"Imperfect scheduling of variable: "<<vscp);
-	AstUnpackArrayDType* uarrayp = varp->dtypeSkipRefp()->castUnpackArrayDType();
-	AstPackArrayDType* parrayp = varp->dtypeSkipRefp()->castPackArrayDType();
-	AstNodeClassDType *classp = varp->dtypeSkipRefp()->castNodeClassDType();
-	bool isUnpackArray = uarrayp;
-	bool isPackArray = parrayp;
-	bool isClass = classp && classp->packedUnsup();
-	int elements = isUnpackArray ? uarrayp->elementsConst() : 1;
-	if (isUnpackArray && (elements > DETECTARRAY_MAX_INDEXES)) {
-	    vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect more than "<<cvtToStr(DETECTARRAY_MAX_INDEXES)
-			 <<" array indexes (probably with UNOPTFLAT warning suppressed): "<<varp->prettyName()<<endl
-			 <<vscp->warnMore()
-			 <<"... Could recompile with DETECTARRAY_MAX_INDEXES increased to at least "<<cvtToStr(elements));
-	} else if (!isUnpackArray && !isClass && !isPackArray
-		   && !varp->dtypeSkipRefp()->castBasicDType()) {
-	    if (debug()) varp->dumpTree(cout,"-DETECTARRAY-");
-	    vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<varp->prettyName());
-	} else {
-	    string newvarname = "__Vchglast__"+vscp->scopep()->nameDotless()+"__"+varp->shortName();
-	    // Create:  VARREF(_last)
-	    //          ASSIGN(VARREF(_last), VARREF(var))
-	    //          ...
-	    //          CHANGEDET(VARREF(_last), VARREF(var))
-	    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);
-	    for (int index=0; index<elements; ++index) {
-		AstChangeDet* changep
-		    = new AstChangeDet (vscp->fileline(),
-					aselIfNeeded(isUnpackArray, index,
-						     new AstVarRef(vscp->fileline(), vscp, false)),
-					aselIfNeeded(isUnpackArray, index,
-						     new AstVarRef(vscp->fileline(), newvscp, false)),
-					false);
-		m_chgFuncp->addStmtsp(changep);
-		AstAssign* initp
-		    = new AstAssign (vscp->fileline(),
-				     aselIfNeeded(isUnpackArray, index,
-						  new AstVarRef(vscp->fileline(), newvscp, true)),
-				     aselIfNeeded(isUnpackArray, index,
-						  new AstVarRef(vscp->fileline(), vscp, false)));
-		m_chgFuncp->addFinalsp(initp);
-	    }
-	}
+	ChangedInsertVisitor visitor (vscp, m_statep);
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	if (nodep->isTop()) {
-	    m_topModp = nodep;
+	    m_statep->m_topModp = nodep;
 	}
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+
+    virtual void visit(AstTopScope* nodep) {
 	UINFO(4," TS "<<nodep<<endl);
 	// Clearing
 	AstNode::user1ClearTree();
 	// Create the change detection function
 	AstScope* scopep = nodep->scopep();
-	if (!scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
-	m_scopetopp = scopep;
-	// Create change detection function
-	m_chgFuncp = new AstCFunc(nodep->fileline(), "_change_request", scopep, "QData");
-	m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
-	m_chgFuncp->symProlog(true);
-	m_chgFuncp->declPrivate(true);
-	m_scopetopp->addActivep(m_chgFuncp);
-	// We need at least one change detect so we know to emit the correct code
-	m_chgFuncp->addStmtsp(new AstChangeDet(nodep->fileline(), NULL, NULL, false));
-	//
+	if (!scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?");
+	m_statep->m_scopetopp = scopep;
+
+	// Create a wrapper change detection function that calls each change detection function
+	m_statep->m_tlChgFuncp = new AstCFunc(nodep->fileline(), "_change_request", scopep, "QData");
+	m_statep->m_tlChgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
+	m_statep->m_tlChgFuncp->symProlog(true);
+	m_statep->m_tlChgFuncp->declPrivate(true);
+	m_statep->m_scopetopp->addActivep(m_statep->m_tlChgFuncp);
+	// Each change detection function needs at least one AstChangeDet
+	// to ensure that V3EmitC outputs the necessary code.
+	m_statep->maybeCreateChgFuncp();
+	m_statep->m_chgFuncp->addStmtsp(new AstChangeDet(nodep->fileline(), NULL, NULL, false));
+
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	if (nodep->isCircular()) {
 	    UINFO(8,"  CIRC "<<nodep<<endl);
 	    if (!nodep->user1SetOnce()) {
@@ -164,18 +277,19 @@ private:
 	    }
 	}
     }
+    virtual void visit(AstNodeMath* nodep) {
+	// Short-circuit 
+    }
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    ChangedVisitor(AstNetlist* nodep) {
-	m_topModp = NULL;
-	m_chgFuncp = NULL;
-	m_scopetopp = NULL;
+    ChangedVisitor(AstNetlist* nodep, ChangedState* statep) {
+	m_statep = statep;
 	nodep->accept(*this);
     }
     virtual ~ChangedVisitor() {}
@@ -186,5 +300,7 @@ public:
 
 void V3Changed::changedAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    ChangedVisitor visitor (nodep);
+    ChangedState state;
+    ChangedVisitor visitor (nodep, &state);
+    V3Global::dumpCheckGlobalTree("changed.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Changed.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Clean.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -78,7 +78,7 @@ private:
 	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()->castNode()->castNodeDType()) {
+	    if (AstNodeDType* new_dtypep = old_dtypep->user3p()->castNodeDType()) {
 		nodep->dtypep(new_dtypep);
 	    } else {
 		nodep->dtypeChgWidth(width, nodep->widthMin());
@@ -173,12 +173,12 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstNodeUniop* nodep, AstNUser*) {
+    virtual void visit(AstNodeUniop* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
 	if (nodep->cleanLhs()) {
@@ -186,45 +186,45 @@ private:
 	}
 	setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeBiop* nodep, AstNUser*) {
+    virtual void visit(AstNodeBiop* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstAnd* nodep, AstNUser*) {
+    virtual void visit(AstAnd* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) || isClean(nodep->rhsp()));
     }
-    virtual void visit(AstXor* nodep, AstNUser*) {
+    virtual void visit(AstXor* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstOr* nodep, AstNUser*) {
+    virtual void visit(AstOr* nodep) {
 	operandBiop(nodep);
 	setClean (nodep, isClean(nodep->lhsp()) && isClean(nodep->rhsp()));
     }
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
         setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
 	if (nodep->cleanRhs()) {
 	    insureClean(nodep->rhsp());
 	}
     }
-    virtual void visit(AstText* nodep, AstNUser*) {
+    virtual void visit(AstText* nodep) {
 	setClean (nodep, true);
     }
-    virtual void visit(AstScopeName* nodep, AstNUser*) {
+    virtual void visit(AstScopeName* nodep) {
 	setClean (nodep, true);
     }
-    virtual void visit(AstSel* nodep, AstNUser*) {
+    virtual void visit(AstSel* nodep) {
 	operandTriop(nodep);
         setClean (nodep, nodep->cleanOut());
     }
-    virtual void visit(AstUCFunc* nodep, AstNUser*) {
+    virtual void visit(AstUCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
         setClean (nodep, false);
@@ -234,53 +234,58 @@ private:
 	}
 	insureCleanAndNext (nodep->bodysp());
     }
-    virtual void visit(AstTraceInc* nodep, AstNUser*) {
+    virtual void visit(AstTraceInc* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->valuep());
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstTypedef* nodep) {
+	// No cleaning, or would loose pointer to enum
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstParamTypeDType* nodep) {
 	// No cleaning, or would loose pointer to enum
 	nodep->iterateChildren(*this);
     }
 
     // Control flow operators
-    virtual void visit(AstNodeCond* nodep, AstNUser*) {
+    virtual void visit(AstNodeCond* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
 	setClean(nodep, isClean(nodep->expr1p()) && isClean(nodep->expr2p()));
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
     }
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->exprsp());
 	setClean(nodep, true);  // generates a string, so not relevant
     }
-    virtual void visit(AstUCStmt* nodep, AstNUser*) {
+    virtual void visit(AstUCStmt* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->bodysp());
     }
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->argsp());
+	setClean (nodep, true);
     }
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
 	computeCppWidth(nodep);
     }
 
 public:
     // CONSTUCTORS
-    CleanVisitor(AstNetlist* nodep) {
+    explicit CleanVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CleanVisitor() {}
@@ -292,4 +297,5 @@ public:
 void V3Clean::cleanAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CleanVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clean.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Clean.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3ClkGater.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2008-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2008-2017 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.
@@ -66,7 +66,7 @@ class GaterVarVertex;
 class GaterVertex : public V3GraphVertex {
     static uint32_t s_rankNum;
 public:
-    GaterVertex(V3Graph* graphp)
+    explicit GaterVertex(V3Graph* graphp)
 	: V3GraphVertex(graphp) {
 	s_rankNum++; rank(s_rankNum);
     }
@@ -79,7 +79,7 @@ uint32_t GaterVertex::s_rankNum = 0;
 
 class GaterHeadVertex : public GaterVertex {
 public:
-    GaterHeadVertex(V3Graph* graphp)
+    explicit GaterHeadVertex(V3Graph* graphp)
 	: GaterVertex(graphp) {}
     virtual ~GaterHeadVertex() {}
     virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
@@ -89,7 +89,7 @@ public:
 
 class GaterPliVertex : public GaterVertex {
 public:
-    GaterPliVertex(V3Graph* graphp)
+    explicit GaterPliVertex(V3Graph* graphp)
 	: GaterVertex(graphp) {}
     virtual ~GaterPliVertex() {}
     virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
@@ -199,25 +199,25 @@ private:
 	if (m_isSimple) nodep->iterateChildren(*this);
     }
     // VISITORS
-    virtual void visit(AstOr* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstAnd* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstNot* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogOr* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogAnd* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstLogNot* nodep, AstNUser*) {	okIterate(nodep); }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {	okIterate(nodep); }
+    virtual void visit(AstOr* nodep) {	okIterate(nodep); }
+    virtual void visit(AstAnd* nodep) {	okIterate(nodep); }
+    virtual void visit(AstNot* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogOr* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogAnd* nodep) {	okIterate(nodep); }
+    virtual void visit(AstLogNot* nodep) {	okIterate(nodep); }
+    virtual void visit(AstVarRef* nodep) {	okIterate(nodep); }
 
     // Other possibilities are equals, etc
     // But, we don't want to get too complicated or it will take too much
     // effort to calculate the gater
 
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	m_isSimple = false;
 	//nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    GaterCondVisitor(AstNode* nodep) {
+    explicit GaterCondVisitor(AstNode* nodep) {
 	m_isSimple = true;
 	nodep->accept(*this);
     }
@@ -248,10 +248,10 @@ class GaterBodyVisitor : public GaterBaseVisitor {
     uint32_t	m_state;	// Parsing state
 
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue()) {
 	    AstVarScope* vscp = nodep->varScopep();
-	    if (vscp->user2p()->castNode() == m_exprp) {
+	    if (vscp->user2p() == m_exprp) {
 		// This variable's block needs to move to the new always
 		if (m_original) {
 		    UINFO(9,"  VARREF delete in old: "<<nodep<<endl);
@@ -272,11 +272,11 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	}
     }
 
-    //virtual void visit(AstNodeIf* nodep, AstNUser*) { ... }
+    //virtual void visit(AstNodeIf* nodep) { ... }
     // Not needed, it's the same handling as any other statement.  Cool, huh?
     // (We may get empty IFs but the constant propagater will rip them up for us)
 
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	uint32_t oldstate = m_state;
 	// Find if children want to delete this or not.
 	// Note children may bicker, and want to both keep and delete (branches on a if)
@@ -296,7 +296,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	}
 
 	if ((childstate & STATE_DELETE) && !(childstate & STATE_KEEP)) {
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    // Pass upwards we did delete
 	    m_state |= STATE_DELETE;
 	} else {
@@ -304,7 +304,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	    m_state |= STATE_KEEP;
 	}
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -427,7 +427,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    for (V3GraphEdge* nextp,* edgep = m_pliVertexp->outBeginp(); edgep; edgep = nextp) {
 		nextp = edgep->outNextp();  // We may edit the list
 		if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
-		    vVxp->unlinkDelete(&m_graph); vVxp=NULL; edgep=NULL;
+		    vVxp->unlinkDelete(&m_graph); VL_DANGLING(vVxp); VL_DANGLING(edgep);
 		} else {
 		    m_graph.dump();
 		    v3fatalSrc("PLI vertex points to non-signal");
@@ -463,7 +463,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		V3GraphVertex* toVxp = edgep->top();
 		//UINFO(9," to "<<toVxp->user()<<" "<<toVxp<<endl);
 		if ((toVxp->user() & VU_IF) && (toVxp->user() & VU_ELSE)) {
-		    edgep->unlinkDelete(); edgep = NULL;
+		    edgep->unlinkDelete(); VL_DANGLING(edgep);
 		    if (!(toVxp->user() & VU_MADE)) {   // Make an edge only once
 			toVxp->user(toVxp->user() | VU_MADE);
 			GaterEdge* inedgep = static_cast<GaterEdge*>(vertexp->inBeginp());
@@ -487,7 +487,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		if (toVxp->user() && toVxp->user() < depth) {
 		    // A recursion "above" us marked it,
 		    // Remove this edge, it's redundant with the upper edge
-		    edgep->unlinkDelete(); edgep=NULL;
+		    edgep->unlinkDelete(); VL_DANGLING(edgep);
 		} else {
 		    GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
 		    if (cedgep->ifelseBoth()) {
@@ -515,7 +515,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    if (GaterIfVertex* toVxp = dynamic_cast<GaterIfVertex*>(edgep->top())) {
 		if (!toVxp->outBeginp()) {
 		    if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
-			toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+			toVxp->unlinkDelete(&m_graph); VL_DANGLING(toVxp); VL_DANGLING(edgep);
 		    }
 		}
 	    }
@@ -529,7 +529,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    nextp = edgep->outNextp();  // We may edit the list
 	    if (GaterVarVertex* toVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
 		if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
-		    toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+		    toVxp->unlinkDelete(&m_graph); VL_DANGLING(toVxp); VL_DANGLING(edgep);
 		}
 	    }
 	}
@@ -559,7 +559,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		if (!vVxp->inBeginp()) {
 		    // At this point, any variable not linked is an error
 		    // (It should have at least landed under the Head node)
-		    vVxp->nodep()->v3fatalSrc("Variable became stranded in clk gate detection\n");
+		    vVxp->nodep()->v3fatalSrc("Variable became stranded in clk gate detection");
 		}
 		if (!lastVxp || vVxp->sortCmp(lastVxp)) {
 		    // Different sources for this new node
@@ -611,7 +611,8 @@ class GaterVisitor : public GaterBaseVisitor {
 		    // Edges from IFs represent a real IF branch in the equation tree
 		    //UINFO(9,"  ifver "<<(void*)(edgep)<<" cc"<<edgep->dotColor()<<endl);
 		    eqnp = cVxp->nodep()->condp()->cloneTree(true);
-		    if (eqnp && cedgep->ifelseFalse()) {
+		    if (!eqnp) cVxp->nodep()->v3fatalSrc("null condition");
+		    if (cedgep->ifelseFalse()) {
 			eqnp = new AstNot(eqnp->fileline(),eqnp);
 		    }
 		    // We need to AND this term onto whatever was found below it
@@ -701,7 +702,7 @@ class GaterVisitor : public GaterBaseVisitor {
     }
 
     // VISITORS
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	if (debug()>=9) cout<<endl<<endl<<endl;
 	UINFO(5, "Gater: ALWAYS: "<<nodep<<endl);
 	if (nodep->user4SetOnce()) return;
@@ -751,7 +752,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	}
 	UINFO(5, "  Gater done"<<endl);
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->lvalue()) {
 	    AstVarScope* vscp = nodep->varScopep();
 	    if (nodep->varp()->isSigPublic()) {
@@ -778,7 +779,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    }
 	}
     }
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	m_ifDepth++;
 	bool allowGater = m_directlyUnderAlw && m_ifDepth <= IF_DEPTH_MAX;
 	if (allowGater) {
@@ -819,12 +820,12 @@ class GaterVisitor : public GaterBaseVisitor {
 	m_ifDepth--;
     }
 
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	// iterateChildrenAlw will detect this is a statement for us
 	iterateChildrenAlw(nodep, false);
     }
 
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// Note NOT AssignDly; handled above, We'll just mark this block as
 	// not optimizable.
 	//
@@ -836,7 +837,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	// No reason to iterate.
     }
 
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	if (!nodep->isClocked()) {
 	    nonOptimizable(nodep, "Non-clocked sensitivity");
 	}
@@ -844,7 +845,7 @@ class GaterVisitor : public GaterBaseVisitor {
     }
 
     //--------------------
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (m_nonopt=="") {  // Else accelerate
 	    iterateChildrenAlw(nodep, false);
 	}
@@ -878,7 +879,7 @@ class GaterVisitor : public GaterBaseVisitor {
 
 public:
     // CONSTUCTORS
-    GaterVisitor(AstNode* nodep) {
+    explicit GaterVisitor(AstNode* nodep) {
 	// AstAlways visitor does the real work, so most zeroing needs to be in clear()
 	clear();
 	nodep->accept(*this);
@@ -914,4 +915,5 @@ void V3ClkGater::clkGaterAll(AstNetlist* nodep) {
     // While the gater does well at some modules, it seems to slow down many others
     UINFO(5,"ClkGater is disabled due to performance issues\n");
     //GaterVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clkgater.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3ClkGater.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Clock.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -99,18 +99,6 @@ private:
 	UINFO(4,"New Last: "<<newvscp<<endl);
 	return newvscp;
     }
-    AstVarScope* getCreateLocalVar(FileLine* fl, const string& name, AstVar* examplep, int width) {
-	AstVar* newvarp;
-	if (width) {
-	    newvarp = new AstVar (fl, AstVarType::BLOCKTEMP, name, VFlagLogicPacked(), width);
-	} else {
-	    newvarp = new AstVar (fl, AstVarType::BLOCKTEMP, name, examplep); // No range; 1 bit.
-	}
-	m_modp->addStmtp(newvarp);
-	AstVarScope* newvscp = new AstVarScope(fl, m_scopep, newvarp);
-	m_scopep->addVarp(newvscp);
-	return newvscp;
-    }
     AstNode* createSenItemEquation(AstSenItem* nodep) {
 	// We know the var is clean, and one bit, so we use binary ops
 	// for speed instead of logical ops.
@@ -120,6 +108,12 @@ private:
 	// HIGHEDGE:  var
 	// LOWEDGE:  ~var
 	AstNode* newp = NULL;
+	if (nodep->edgeType()==AstEdgeType::ET_ILLEGAL) {
+	    if (!v3Global.opt.bboxUnsup()) {
+		nodep->v3error("Unsupported: Complicated event expression in sensitive activity list");
+	    }
+	    return NULL;
+	}
 	AstVarScope* clkvscp = nodep->varrefp()->varScopep();
 	if (nodep->edgeType()==AstEdgeType::ET_POSEDGE) {
 	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
@@ -194,11 +188,11 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstTopScope* nodep, AstNUser*) {
+    virtual void visit(AstTopScope* nodep) {
 	UINFO(4," TOPSCOPE   "<<nodep<<endl);
 	m_topScopep=nodep;
 	m_scopep = nodep->scopep();
-	if (!m_scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
+	if (!m_scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?");
 	//VV*****  We reset all user1p()
 	AstNode::user1ClearTree();
 	// Make top functions
@@ -255,14 +249,14 @@ private:
 	m_topScopep=NULL;
 	m_scopep = NULL;
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	//UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_stableNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp= NULL;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	//UINFO(4," SCOPE   "<<nodep<<endl);
 	m_scopep = nodep;
 	nodep->iterateChildren(*this);
@@ -273,25 +267,25 @@ private:
 	}
 	m_scopep = NULL;
     }
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    virtual void visit(AstAlways* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstAlwaysPost* nodep, AstNUser*) {
+    virtual void visit(AstAlwaysPost* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	//nodep->dumpTree(cout,"ct:");
 	//COVERTOGGLE(INC, ORIG, CHANGE) ->
 	//   IF(ORIG ^ CHANGE) { INC; CHANGE = ORIG; }
@@ -309,18 +303,18 @@ private:
 	newp->addIfsp(new AstAssign(nodep->fileline(),
 				    changep->cloneTree(false),
 				    origp->cloneTree(false)));
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstInitial* nodep, AstNUser*) {
+    virtual void visit(AstInitial* nodep) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
 	nodep->replaceWith(cmtp);
 	if (AstNode* stmtsp = nodep->bodysp()) {
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	// Link to global function
 	if (nodep->formCallTree()) {
@@ -330,7 +324,7 @@ private:
 	    m_finalFuncp->addStmtsp(callp);
 	}
     }
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	// Delete it later; Actives still pointing to it
 	nodep->unlinkFrBack();
 	pushDeletep(nodep);
@@ -347,14 +341,14 @@ private:
 	if (m_untilp) m_untilp->addBodysp(stmtsp);  // In a until loop, add to body
 	else m_initFuncp->addStmtsp(stmtsp);  // else add to top level function
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	// Careful if adding variables here, ACTIVES can be under other ACTIVES
 	// Need to save and restore any member state in AstUntilStable block
 	if (!m_topScopep || !nodep->stmtsp()) {
 	    // Not at the top or empty block...
 	    // Only empty blocks should be leftover on the non-top.  Killem.
 	    if (nodep->stmtsp()) nodep->v3fatalSrc("Non-empty lower active");
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
 	    UINFO(4,"  ACTIVE  "<<nodep<<endl);
 	    AstNode* stmtsp = nodep->stmtsp()->unlinkFrBackWithNext();
@@ -386,19 +380,19 @@ private:
 		// Move statements to function
 		addToEvalLoop(stmtsp);
 	    }
-	    nodep->unlinkFrBack()->deleteTree(); nodep = NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	}
     }
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    ClockVisitor(AstNetlist* nodep) {
+    explicit ClockVisitor(AstNetlist* nodep) {
 	m_modp=NULL; m_activep=NULL;
 	m_evalFuncp = NULL;
 	m_topScopep=NULL;
@@ -419,4 +413,5 @@ public:
 void V3Clock::clockAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ClockVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clock.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Clock.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Combine.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -111,7 +111,7 @@ public:
 		    callp->unlinkFrBack();
 		}
 		callp->user3(true);	// Dead now
-		pushDeletep(callp); callp=NULL;
+		pushDeletep(callp); VL_DANGLING(callp);
 		m_callMmap.erase(eqit);	// Fix the table
 	    }
 	}
@@ -134,13 +134,13 @@ public:
     }
 private:
     // VISITORS
-    virtual void visit(AstCCall* nodep, AstNUser*) {
+    virtual void visit(AstCCall* nodep) {
 	addCall(nodep);
     }
     // Speed things up
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {}
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {}
+    virtual void visit(AstNodeMath* nodep) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
@@ -163,13 +163,13 @@ private:
     // OUTPUT:
     //  AstNode::user3()	-> bool. True to indicate duplicated
     // VISITORS
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->user3(true);
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTRUCTORS
-    CombMarkVisitor(AstNode* nodep) {
+    explicit CombMarkVisitor(AstNode* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CombMarkVisitor() {}
@@ -230,7 +230,7 @@ private:
 		CombMarkVisitor visitor(oldfuncp);
 		m_call.replaceFunc(oldfuncp, NULL);
 		oldfuncp->unlinkFrBack();
-		pushDeletep(oldfuncp); oldfuncp=NULL;
+		pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
 	    }
 	}
     }
@@ -239,7 +239,7 @@ private:
 	    V3Hash hashval = it->first;
 	    AstNode* node1p = it->second;
 	    if (!node1p->castCFunc()) continue;
-	    if (hashval.isIllegal()) node1p->v3fatalSrc("Illegal (unhashed) nodes\n");
+	    if (hashval.isIllegal()) node1p->v3fatalSrc("Illegal (unhashed) nodes");
 	    for (V3Hashed::iterator eqit = it; eqit != m_hashed.end(); ++eqit) {
 		AstNode* node2p = eqit->second;
 		if (!(eqit->first == hashval)) break;
@@ -262,7 +262,7 @@ private:
 	CombMarkVisitor visitor(oldfuncp);
 	m_call.replaceFunc(oldfuncp, newfuncp);
 	oldfuncp->unlinkFrBack();
-	pushDeletep(oldfuncp); oldfuncp=NULL;
+	pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
     }
     void replaceOnlyCallFunc(AstCCall* nodep) {
 	if (AstCFunc* oldfuncp = nodep->backp()->castCFunc()) {
@@ -274,7 +274,7 @@ private:
 		UINFO(9,"     Function only has call "<<oldfuncp<<endl);
 		m_call.deleteCall(nodep);
 		CombMarkVisitor visitor(oldfuncp);
-		replaceFuncWFunc(oldfuncp, nodep->funcp());  nodep=NULL;
+		replaceFuncWFunc(oldfuncp, nodep->funcp()); VL_DANGLING(nodep);
 	    }
 	}
     }
@@ -384,12 +384,12 @@ private:
 	m_call.addCall(call2p);
 	// If either new statement makes a func with only a single call, replace
 	// the above callers to call it directly
-	replaceOnlyCallFunc(call1p); call1p=NULL;
-	replaceOnlyCallFunc(call2p); call2p=NULL;
+	replaceOnlyCallFunc(call1p); VL_DANGLING(call1p);
+	replaceOnlyCallFunc(call2p); VL_DANGLING(call2p);
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Track all callers of each function
 	m_call.main(nodep);
 	//
@@ -398,7 +398,7 @@ private:
 	// Required so that a module instantiating another can benefit from collapsing.
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_modNFuncs = 0;
@@ -426,7 +426,7 @@ private:
 	}
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_funcp = nodep;
 	if (!nodep->dontCombine()) {
 	    if (m_state == STATE_HASH) {
@@ -437,7 +437,7 @@ private:
 	}
 	m_funcp = NULL;
     }
-    virtual void visit(AstNodeStmt* nodep, AstNUser*) {
+    virtual void visit(AstNodeStmt* nodep) {
 	if (m_state == STATE_HASH && m_funcp) {
 	    hashStatement(nodep);
 	}
@@ -448,16 +448,16 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstVar*, AstNUser*) {}
-    virtual void visit(AstTraceDecl*, AstNUser*) {}
-    virtual void visit(AstTraceInc*, AstNUser*) {}
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstVar*) {}
+    virtual void visit(AstTraceDecl*) {}
+    virtual void visit(AstTraceInc*) {}
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    CombineVisitor(AstNetlist* nodep) {
+    explicit CombineVisitor(AstNetlist* nodep) {
 	m_modp=NULL;
 	m_funcp = NULL;
 	m_state = STATE_IDLE;
@@ -474,4 +474,5 @@ public:
 void V3Combine::combineAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CombineVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("combine.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Combine.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Config.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2010-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2010-2017 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.
@@ -104,7 +104,7 @@ class V3ConfigIgnores {
 public:
     inline static V3ConfigIgnores& singleton() { return s_singleton; }
 
-    void addIgnore(V3ErrorCode code, string wildname, int lineno, bool on) {
+    void addIgnore(V3ErrorCode code, const string& wildname, int lineno, bool on) {
 	// Insert
 	IgnLines* linesp = findWilds(wildname);
 	UINFO(9,"config addIgnore "<<wildname<<":"<<lineno<<", "<<code<<", "<<on<<endl);
@@ -144,12 +144,12 @@ V3ConfigIgnores V3ConfigIgnores::s_singleton;
 //######################################################################
 // V3Config
 
-void V3Config::addIgnore(V3ErrorCode code, string filename, int min, int max) {
+void V3Config::addIgnore(V3ErrorCode code, bool on, string filename, int min, int max) {
     if (filename=="*") {
-	FileLine::globalWarnOff(code,true);
+	FileLine::globalWarnOff(code,!on);
     } else {
-	V3ConfigIgnores::singleton().addIgnore(code, filename, min, false);
-	if (max) V3ConfigIgnores::singleton().addIgnore(code, filename, max, true);
+	V3ConfigIgnores::singleton().addIgnore(code, filename, min, on);
+	if (max) V3ConfigIgnores::singleton().addIgnore(code, filename, max, !on);
     }
 }
 

src/V3Config.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2010-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2010-2017 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.
@@ -30,7 +30,7 @@
 
 class V3Config {
 public:
-    static void addIgnore(V3ErrorCode code, string filename, int min, int max);
+    static void addIgnore(V3ErrorCode code, bool on, string filename, int min, int max);
     static void applyIgnores(FileLine* filelinep);
 };
 

src/V3Const.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -33,6 +33,7 @@
 #include <algorithm>
 
 #include "V3Global.h"
+#include "V3String.h"
 #include "V3Const.h"
 #include "V3Ast.h"
 #include "V3Width.h"
@@ -46,15 +47,15 @@ class ConstVarMarkVisitor : public AstNVisitor {
     // AstVar::user4p		-> bool, Var marked, 0=not set yet
 private:
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp()) nodep->varp()->user4(1);
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    ConstVarMarkVisitor(AstNode* nodep) {
+    explicit ConstVarMarkVisitor(AstNode* nodep) {
 	AstNode::user4ClearTree();  // Check marked InUse before we're called
 	nodep->accept(*this);
     }
@@ -68,17 +69,17 @@ class ConstVarFindVisitor : public AstNVisitor {
     bool m_found;
 private:
     // VISITORS
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (nodep->varp() && nodep->varp()->user4()) m_found = true;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    ConstVarFindVisitor(AstNode* nodep) {
+    explicit ConstVarFindVisitor(AstNode* nodep) {
 	m_found = false;
-	nodep->iterateAndNext(*this, NULL);
+	nodep->iterateAndNext(*this);
     }
     virtual ~ConstVarFindVisitor() {}
     // METHODS
@@ -214,7 +215,7 @@ private:
 	if (!operandsSame(ap, bp)) return false;
 	// Do it
 	cp->unlinkFrBack();
-	andp->unlinkFrBack()->deleteTree(); andp=NULL; notp=NULL;
+	andp->unlinkFrBack()->deleteTree(); VL_DANGLING(andp); VL_DANGLING(notp);
 	// Replace whichever branch is now dangling
 	if (nodep->rhsp()) nodep->lhsp(cp);
 	else nodep->rhsp(cp);
@@ -319,7 +320,7 @@ private:
 	      && nodep->lsbConst()==0
 	      && (int)nodep->widthConst()==extendp->lhsp()->width()
 		)) return false;
-	replaceWChild(nodep, extendp->lhsp()); nodep=NULL;
+	replaceWChild(nodep, extendp->lhsp()); VL_DANGLING(nodep);
 	return true;
     }
     bool operandSelBiLower(AstSel* nodep) {
@@ -338,7 +339,7 @@ private:
 	bip->lhsp(new AstSel(nodep->fileline(), bilhsp, 0, nodep->widthConst()));
 	bip->rhsp(new AstSel(nodep->fileline(), birhsp, 0, nodep->widthConst()));
 	if (debug()>=9) bip->dumpTree(cout,"SEL(BI)-ou:");
-	replaceWChild(nodep, bip); nodep=NULL;
+	replaceWChild(nodep, bip); VL_DANGLING(nodep);
 	return true;
     }
 
@@ -364,7 +365,7 @@ private:
 	V3Number num (constp->fileline(), subsize);
 	num.opAssign(constp->num());
 	nodep->lhsp(new AstConst(constp->fileline(), num));
-	constp->deleteTree();  constp=NULL;
+	constp->deleteTree(); VL_DANGLING(constp);
 	if (debug()>=9) nodep->dumpTree(cout,"BI(EXTEND)-ou:");
 	return true;
     }
@@ -450,6 +451,8 @@ private:
 	if (!ifvarp || !elsevarp) return false;
 	if (ifvarp->isWide()) return false;  // Would need temporaries, so not worth it
 	if (!ifvarp->sameGateTree(elsevarp)) return false;
+	if (!ifp->rhsp()->gateTree()) return false;
+	if (!elsep->rhsp()->gateTree()) return false;
 	return true;
     }
     bool operandIfIf(AstNodeIf* nodep) {
@@ -552,65 +555,65 @@ private:
 	// Replace oldp node with a constant set to specified value
 	UASSERT (oldp, "Null old\n");
 	if (oldp->castConst() && !oldp->castConst()->num().isFourState()) {
-	    oldp->v3fatalSrc("Already constant??\n");
+	    oldp->v3fatalSrc("Already constant??");
 	}
 	AstNode* newp = new AstConst(oldp->fileline(), num);
 	newp->dtypeFrom(oldp);
 	if (debug()>5) oldp->dumpTree(cout,"  const_old: ");
 	if (debug()>5) newp->dumpTree(cout,"       _new: ");
 	oldp->replaceWith(newp);
-	oldp->deleteTree(); oldp=NULL;
+	oldp->deleteTree(); VL_DANGLING(oldp);
     }
     void replaceNum (AstNode* nodep, uint32_t val) {
 	V3Number num (nodep->fileline(), nodep->width(), val);
-	replaceNum(nodep, num); nodep=NULL;
+	replaceNum(nodep, num); VL_DANGLING(nodep);
     }
     void replaceNumSigned(AstNodeBiop* nodep, uint32_t val) {
 	// We allow both sides to be constant, as one may have come from parameter propagation, etc.
 	if (m_warn && !(nodep->lhsp()->castConst() && nodep->rhsp()->castConst())) {
 	    nodep->v3warn(UNSIGNED,"Comparison is constant due to unsigned arithmetic");
 	}
-	replaceNum(nodep, val); nodep=NULL;
+	replaceNum(nodep, val); VL_DANGLING(nodep);
     }
     void replaceNumLimited(AstNodeBiop* nodep, uint32_t val) {
 	// Avoids gcc warning about same
 	if (m_warn) nodep->v3warn(CMPCONST,"Comparison is constant due to limited range");
-	replaceNum(nodep, val); nodep=NULL;
+	replaceNum(nodep, val); VL_DANGLING(nodep);
     }
     void replaceZero(AstNode* nodep) {
-	replaceNum(nodep, 0); nodep=NULL;
+	replaceNum(nodep, 0); VL_DANGLING(nodep);
     }
     void replaceZeroChkPure(AstNode* nodep, AstNode* checkp) {
 	// For example, "0 * n" -> 0 if n has no side effects
 	// Else strength reduce it to 0 & n.
 	// If ever change the operation note AstAnd rule specially ignores this created pattern
 	if (isTPure(checkp)) {
-	    replaceNum(nodep, 0); nodep=NULL;
+	    replaceNum(nodep, 0); VL_DANGLING(nodep);
 	} else {
 	    AstNode* newp = new AstAnd(nodep->fileline(),
 				       new AstConst(nodep->fileline(), 0),
 				       checkp->unlinkFrBack());
 	    newp->dtypeFrom(nodep);
 	    nodep->replaceWith(newp);
-	    nodep->deleteTree(); nodep=NULL;
+	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
     void replaceAllOnes (AstNode* nodep) {
 	V3Number ones (nodep->fileline(), nodep->width(), 0);
 	ones.setMask(nodep->width());
-	replaceNum(nodep, ones); nodep=NULL;
+	replaceNum(nodep, ones); VL_DANGLING(nodep);
     }
     void replaceConst(AstNodeUniop* nodep) {
 	V3Number num (nodep->fileline(), nodep->width());
 	nodep->numberOperate(num, nodep->lhsp()->castConst()->num());
 	UINFO(4,"UNICONST -> "<<num<<endl);
-	replaceNum(nodep, num); nodep=NULL;
+	replaceNum(nodep, num); VL_DANGLING(nodep);
     }
     void replaceConst(AstNodeBiop* nodep) {
 	V3Number num (nodep->fileline(), nodep->width());
 	nodep->numberOperate(num, nodep->lhsp()->castConst()->num(), nodep->rhsp()->castConst()->num());
 	UINFO(4,"BICONST -> "<<num<<endl);
-	replaceNum(nodep, num); nodep=NULL;
+	replaceNum(nodep, num); VL_DANGLING(nodep);
     }
     void replaceConst(AstNodeTriop* nodep) {
 	V3Number num (nodep->fileline(), nodep->width());
@@ -618,7 +621,7 @@ private:
 			     nodep->rhsp()->castConst()->num(),
 			     nodep->thsp()->castConst()->num());
 	UINFO(4,"TRICONST -> "<<num<<endl);
-	replaceNum(nodep, num); nodep=NULL;
+	replaceNum(nodep, num); VL_DANGLING(nodep);
     }
 
     void replaceConstString (AstNode* oldp, const string& num) {
@@ -628,7 +631,7 @@ private:
 	if (debug()>5) oldp->dumpTree(cout,"  const_old: ");
 	if (debug()>5) newp->dumpTree(cout,"       _new: ");
 	oldp->replaceWith(newp);
-	oldp->deleteTree(); oldp=NULL;
+	oldp->deleteTree(); VL_DANGLING(oldp);
     }
     //----------------------------------------
     // Replacement functions.
@@ -641,7 +644,7 @@ private:
 	// This may adversly affect the operation of the node being replaced.
 	childp->dtypeFrom(nodep);
 	nodep->replaceWith(childp);
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     //! Replace a ternary node with its RHS after iterating
@@ -775,9 +778,9 @@ private:
 	UINFO(5, "merged two adjacent sel "<<lselp <<" and "<<rselp<< " to one "<<newselp<<endl);
 
 	nodep->replaceWith(newselp);
-	lselp->deleteTree(); lselp = NULL;
-	rselp->deleteTree(); rselp = NULL;
-	nodep->deleteTree(); nodep = NULL;
+	lselp->deleteTree(); VL_DANGLING(lselp);
+	rselp->deleteTree(); VL_DANGLING(rselp);
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replaceConcatMerge(AstConcat* nodep) {
 	AstNodeBiop* lp = nodep->lhsp()->castNodeBiop();
@@ -794,8 +797,8 @@ private:
 	    lp->rhsp()->replaceWith(newrp);
 	    lp->dtypeChgWidthSigned(newlp->width(), newlp->width(), AstNumeric::fromBool(true));
 	    UINFO(5, "merged "<< nodep <<endl);
-	    rp->unlinkFrBack()->deleteTree(); rp = NULL;
-	    nodep->replaceWith(lp->unlinkFrBack()); nodep->deleteTree(); nodep = NULL;
+	    rp->unlinkFrBack()->deleteTree(); VL_DANGLING(rp);
+	    nodep->replaceWith(lp->unlinkFrBack()); nodep->deleteTree(); VL_DANGLING(nodep);
 	    lp->lhsp()->accept(*this);
 	    lp->rhsp()->accept(*this);
 	} else nodep->v3fatalSrc("tried to merge two Concat which are not adjacent");
@@ -805,10 +808,10 @@ private:
 	// like a AstExtend{$rhsp}, but we need to set the width correctly from base node
 	arg0p->unlinkFrBack();
 	AstNode* newp = (nodep->castExtendS()
-			 ? (new AstExtendS(nodep->fileline(), arg0p))->castNode()
-			 : (new AstExtend (nodep->fileline(), arg0p))->castNode());
+			 ? static_cast<AstNode*>(new AstExtendS(nodep->fileline(), arg0p))
+			 : static_cast<AstNode*>(new AstExtend (nodep->fileline(), arg0p)));
 	newp->dtypeFrom(nodep);
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replacePowShift (AstNodeBiop* nodep) {  // Pow or PowS
 	UINFO(5,"POW(2,b)->SHIFTL(1,b) "<<nodep<<endl);
@@ -818,7 +821,7 @@ private:
 					rhsp);
 	newp->dtypeFrom(nodep);
 	newp->lhsp()->dtypeFrom(nodep);
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replaceMulShift (AstMul* nodep) {  // Mul, but not MulS as not simple shift
 	UINFO(5,"MUL(2^n,b)->SHIFTL(b,n) "<<nodep<<endl);
@@ -827,7 +830,7 @@ private:
 	AstShiftL* newp = new AstShiftL(nodep->fileline(),
 					opp, new AstConst(nodep->fileline(), amount));
 	newp->dtypeFrom(nodep);
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replaceDivShift (AstDiv* nodep) {  // Mul, but not MulS as not simple shift
 	UINFO(5,"DIV(b,2^n)->SHIFTR(b,n) "<<nodep<<endl);
@@ -836,7 +839,7 @@ private:
 	AstShiftR* newp = new AstShiftR(nodep->fileline(),
 					opp, new AstConst(nodep->fileline(), amount));
 	newp->dtypeFrom(nodep);
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replaceShiftOp (AstNodeBiop* nodep) {
 	UINFO(5,"SHIFT(AND(a,b),CONST)->AND(SHIFT(a,CONST),SHIFT(b,CONST)) "<<nodep<<endl);
@@ -867,8 +870,8 @@ private:
 	    int shift1 = shift1p->castConst()->toUInt();
 	    int shift2 = shift2p->castConst()->toUInt();
 	    int newshift = shift1+shift2;
-	    shift1p->deleteTree(); shift1p=NULL;
-	    shift2p->deleteTree(); shift2p=NULL;
+	    shift1p->deleteTree(); VL_DANGLING(shift1p);
+	    shift2p->deleteTree(); VL_DANGLING(shift2p);
 	    nodep->lhsp(ap);
 	    nodep->rhsp(new AstConst(nodep->fileline(), newshift));
 	    nodep->accept(*this);	// Further reduce, either node may have more reductions.
@@ -877,8 +880,8 @@ private:
 	    int shift1 = shift1p->castConst()->toUInt(); if (lhsp->castShiftR())  shift1=-shift1;
 	    int shift2 = shift2p->castConst()->toUInt(); if (nodep->castShiftR()) shift2=-shift2;
 	    int newshift = shift1+shift2;
-	    shift1p->deleteTree(); shift1p=NULL;
-	    shift2p->deleteTree(); shift2p=NULL;
+	    shift1p->deleteTree(); VL_DANGLING(shift1p);
+	    shift2p->deleteTree(); VL_DANGLING(shift2p);
 	    AstNode* newp;
 	    V3Number mask1 (nodep->fileline(), nodep->width());
 	    V3Number ones (nodep->fileline(), nodep->width());
@@ -906,11 +909,11 @@ private:
 			       newp,
 			       new AstConst (nodep->fileline(), mask));
 	    newp->dtypeFrom(nodep);
-	    nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	    nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
 	    //newp->dumpTree(cout, "  repShiftShift_new: ");
 	    newp->accept(*this);	// Further reduce, either node may have more reductions.
 	}
-	lhsp->deleteTree(); lhsp=NULL;
+	lhsp->deleteTree(); VL_DANGLING(lhsp);
     }
 
     bool replaceAssignMultiSel(AstNodeAssign* nodep) {
@@ -983,7 +986,7 @@ private:
 		nodep->v3error("Wire inputs its own output, creating circular logic (wire x=x)");
 		return false;  // Don't delete the assign, or V3Gate will freak out
 	    } else {
-		nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 		return true;
 	    }
 	}
@@ -1034,10 +1037,8 @@ private:
 		AstNodeAssign* asn2ap=nodep->cloneType(lc2p, sel2p)->castNodeAssign();
 		asn1ap->dtypeFrom(sel1p);
 		asn2ap->dtypeFrom(sel2p);
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn1ap);
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn2ap);
+		newp = AstNode::addNext(newp, asn1ap);
+		newp = AstNode::addNext(newp, asn2ap);
 	    } else {
 		if (!m_modp) nodep->v3fatalSrc("Not under module");
 		// We could create just one temp variable, but we'll get better optimization
@@ -1067,20 +1068,16 @@ private:
 		asn2ap->dtypeFrom(temp2p);
 		asn2bp->dtypeFrom(temp2p);
 		// This order matters
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn1ap);
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn2ap);
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn1bp);
-		// cppcheck-suppress nullPointer  // addNext deals with it
-		newp = newp->addNext(asn2bp);
+		newp = AstNode::addNext(newp, asn1ap);
+		newp = AstNode::addNext(newp, asn2ap);
+		newp = AstNode::addNext(newp, asn1bp);
+		newp = AstNode::addNext(newp, asn2bp);
 	    }
 	    if (debug()>=9 && newp) newp->dumpTreeAndNext(cout,"     _new: ");
 	    nodep->addNextHere(newp);
 	    // Cleanup
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
-	    conp->deleteTree(); conp=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+	    conp->deleteTree(); VL_DANGLING(conp);
 	    // Further reduce, either node may have more reductions.
 	    return true;
 	}
@@ -1093,8 +1090,8 @@ private:
 	    AstNode* streamp = nodep->rhsp()->castStreamR()->unlinkFrBack();
 	    nodep->rhsp(srcp);
 	    // Cleanup
-	    sizep->deleteTree(); sizep=NULL;
-	    streamp->deleteTree(); streamp=NULL;
+	    sizep->deleteTree(); VL_DANGLING(sizep);
+	    streamp->deleteTree(); VL_DANGLING(streamp);
 	    // Further reduce, any of the nodes may have more reductions.
 	    return true;
 	}
@@ -1137,8 +1134,8 @@ private:
 	    nodep->lhsp(dstp);
 	    nodep->rhsp(srcp);
 	    // Cleanup
-	    sizep->deleteTree(); sizep=NULL;
-	    streamp->deleteTree(); streamp=NULL;
+	    sizep->deleteTree(); VL_DANGLING(sizep);
+	    streamp->deleteTree(); VL_DANGLING(streamp);
 	    // Further reduce, any of the nodes may have more reductions.
 	    return true;
 	}
@@ -1171,7 +1168,7 @@ private:
 				  fromp);
 	newp->dtypeSetLogicSized(nodep->width(), nodep->width(), AstNumeric::UNSIGNED);  // widthMin no longer applicable if different C-expanded width
 	nodep->replaceWith(newp);
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
 	if (debug()>=9) newp->dumpTree(cout,"       _new: ");
     }
 
@@ -1185,36 +1182,36 @@ private:
 			   <<nodep->prettyTypeName()<<endl
 			   <<errorp->warnMore()<<"... Location of non-constant "
 			   <<errorp->prettyTypeName()<<": "<<simvis.whyNotMessage());
-	    replaceZero(nodep); nodep=NULL;
+	    replaceZero(nodep); VL_DANGLING(nodep);
 	} else {
 	    // Fetch the result
 	    V3Number* outnump = simvis.fetchNumberNull(nodep);
 	    if (!outnump) nodep->v3fatalSrc("No number returned from simulation");
 	    // Replace it
-	    replaceNum(nodep,*outnump); nodep=NULL;
+	    replaceNum(nodep,*outnump); VL_DANGLING(nodep);
 	}
     }
 
     //----------------------------------------
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Iterate modules backwards, in bottom-up order.  That's faster
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	// No ASSIGNW removals under funcs, we've long eliminated INITIALs
 	// (We should perhaps rename the assignw's to just assigns)
 	m_wremove = false;
 	nodep->iterateChildren(*this);
 	m_wremove = true;
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	// No ASSIGNW removals under scope, we've long eliminated INITIALs
 	m_scopep = nodep;
 	m_wremove = false;
@@ -1271,7 +1268,7 @@ private:
 	    // If bp was a concat, then we have this exact same form again!
 	    // Recurse rather then calling node->iterate to prevent 2^n recursion!
 	    if (operandConcatMove(abConcp)) moveConcat(abConcp);
-	    bcConcp->deleteTree(); bcConcp=NULL;
+	    bcConcp->deleteTree(); VL_DANGLING(bcConcp);
 	} else {
 	    AstConcat* abConcp = nodep->lhsp()->castConcat(); abConcp->unlinkFrBack();
 	    AstNode* ap = abConcp->lhsp()->unlinkFrBack();
@@ -1282,21 +1279,21 @@ private:
 	    nodep->lhsp(ap);
 	    nodep->rhsp(bcConcp);
 	    if (operandConcatMove(bcConcp)) moveConcat(bcConcp);
-	    abConcp->deleteTree(); abConcp=NULL;
+	    abConcp->deleteTree(); VL_DANGLING(abConcp);
 	}
     }
 
     // Special cases
-    virtual void visit(AstConst* nodep, AstNUser*) {}	// Already constant
+    virtual void visit(AstConst* nodep) {}	// Already constant
 
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	if (m_params) {
 	    nodep->paramsp()->iterateAndNext(*this);
 	} else {
 	    nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstPin* nodep, AstNUser*) {
+    virtual void visit(AstPin* nodep) {
 	nodep->iterateChildren(*this);
     }
 
@@ -1313,8 +1310,8 @@ private:
 	if (lsb1p->castConst() && lsb2p->castConst()) {
 	    newlsbp = new AstConst(lsb1p->fileline(),
 				   lsb1p->castConst()->toUInt() + lsb2p->castConst()->toUInt());
-	    lsb1p->deleteTree(); lsb1p=NULL;
-	    lsb2p->deleteTree(); lsb2p=NULL;
+	    lsb1p->deleteTree(); VL_DANGLING(lsb1p);
+	    lsb2p->deleteTree(); VL_DANGLING(lsb2p);
 	} else {
 	    // Width is important, we need the width of the fromp's
 	    // expression, not the potentially smaller lsb1p's width
@@ -1328,7 +1325,7 @@ private:
 				  newlsbp,
 				  widthp);
 	nodep->replaceWith(newp);
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     void replaceSelConcat(AstSel* nodep) {
@@ -1368,7 +1365,7 @@ private:
 			    conRhsp->width()-nodep->lsbConst()));
 	    nodep->replaceWith(newp);
 	}
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     void replaceSelReplicate(AstSel* nodep) {
@@ -1377,12 +1374,13 @@ private:
 	AstNode* fromp = repp->lhsp()->unlinkFrBack();
 	AstConst* lsbp = nodep->lsbp()->castConst();
 	AstNode* widthp = nodep->widthp()->unlinkFrBack();
+	if (!fromp->width()) nodep->v3fatalSrc("Not widthed");
 	AstSel* newp = new AstSel(nodep->fileline(),
 				  fromp,
 				  new AstConst(lsbp->fileline(), lsbp->toUInt() % fromp->width()),
 				  widthp);
 	newp->dtypeFrom(nodep);
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     void replaceSelIntoBiop(AstSel* nodep) {
@@ -1400,7 +1398,7 @@ private:
 	fromp->rhsp(new AstSel(nodep->fileline(),
 			       birhsp, lsbp, widthp));
 	fromp->dtypeFrom(nodep);
-	nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(fromp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     void replaceSelIntoUniop(AstSel* nodep) {
 	// SEL(NOT(a),1,bit) => NOT(SEL(a,bit))
@@ -1414,17 +1412,17 @@ private:
 	fromp->lhsp(new AstSel(nodep->fileline(),
 			       bilhsp, lsbp, widthp));
 	fromp->dtypeFrom(nodep);
-	nodep->replaceWith(fromp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(fromp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
-    virtual void visit(AstAttrOf* nodep, AstNUser*) {
+    virtual void visit(AstAttrOf* nodep) {
 	AstAttrOf* oldAttr = m_attrp;
 	m_attrp = nodep;
 	nodep->iterateChildren(*this);
 	m_attrp = oldAttr;
     }
 
-    virtual void visit(AstArraySel* nodep, AstNUser*) {
+    virtual void visit(AstArraySel* nodep) {
 	nodep->bitp()->iterateAndNext(*this);
 	if (nodep->bitp()->castConst()
 	    && nodep->fromp()->castVarRef()
@@ -1438,12 +1436,17 @@ private:
 	    if (!m_selp) {
 		nodep->v3error("Illegal assignment of constant to unpacked array");
 	    } else {
-		nodep->replaceWith(nodep->fromp()->unlinkFrBack());
+		AstNode* fromp = nodep->fromp()->unlinkFrBack();
+		nodep->replaceWith(fromp);
+		if (fromp->dtypep()->skipRefp()->castNodeArrayDType()) {
+		    // Strip off array to find what array references
+		    fromp->dtypeFrom(fromp->dtypep()->skipRefp()->castNodeArrayDType()->subDTypep());
+		}
 	    }
 	}
 	m_selp = NULL;
     }
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->varp()) nodep->v3fatalSrc("Not linked");
 	bool did=false;
@@ -1463,27 +1466,47 @@ private:
 		if (operandConst(valuep)) {
 		    const V3Number& num = valuep->castConst()->num();
 		    //UINFO(2,"constVisit "<<(void*)valuep<<" "<<num<<endl);
-		    replaceNum(nodep, num); nodep=NULL;
+		    replaceNum(nodep, num); VL_DANGLING(nodep);
 		    did=true;
 		}
 		else if (m_selp && valuep->castInitArray()) {
-		    int bit = m_selp->bitConst();
-		    AstNode* itemp = valuep->castInitArray()->initsp();
-		    for (int n=0; n<bit && itemp; ++n, itemp=itemp->nextp()) {}
+		    AstInitArray* initarp = valuep->castInitArray();
+		    uint32_t bit = m_selp->bitConst();
+		    int pos = 0;
+		    AstNode* itemp = initarp->initsp();
+		    for (; itemp; ++pos, itemp=itemp->nextp()) {
+			uint32_t index = initarp->posIndex(pos);
+			if (index == bit) break;
+			if (index > bit) {
+			    if (initarp->defaultp()) {
+				itemp = initarp->defaultp();
+			    } else {
+				initarp->v3fatalSrc("Not enough values in array initalizement");
+			    }
+			}
+		    }
 		    if (itemp->castConst()) {
 			const V3Number& num = itemp->castConst()->num();
 			//UINFO(2,"constVisit "<<(void*)valuep<<" "<<num<<endl);
-			replaceNum(nodep, num); nodep=NULL;
+			replaceNum(nodep, num); VL_DANGLING(nodep);
 			did=true;
 		    }
 		}
+		else if (m_params && valuep->castInitArray() && nodep->backp()->castPin()) {
+		    // Allow parameters to pass arrays
+		    // Earlier recursion of InitArray made sure each array value is constant
+		    // This exception is fairly fragile, i.e. doesn't support arrays of arrays or other stuff
+		    AstNode* newp = valuep->cloneTree(false);
+		    nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
+		    did = true;
+		}
 	    }
 	}
 	if (!did && m_required) {
 	    nodep->v3error("Expecting expression to be constant, but variable isn't const: "<<nodep->varp()->prettyName());
 	}
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (!nodep->itemp()) nodep->v3fatalSrc("Not linked");
 	bool did=false;
@@ -1492,7 +1515,7 @@ private:
 	    nodep->itemp()->valuep()->iterateAndNext(*this);
 	    if (AstConst* valuep = nodep->itemp()->valuep()->castConst()) {
 		const V3Number& num = valuep->num();
-		replaceNum(nodep, num); nodep=NULL;
+		replaceNum(nodep, num); VL_DANGLING(nodep);
 		did=true;
 	    }
 	}
@@ -1501,7 +1524,7 @@ private:
 	}
     }
 
-    // virtual void visit(AstCvtPackString* nodep, AstNUser*) {
+    // virtual void visit(AstCvtPackString* nodep) {
     // Not constant propagated (for today) because AstMath::isOpaque is set
     // Someday if lower is constant, convert to quoted "string".
 
@@ -1509,7 +1532,7 @@ private:
 	// Only one if it's not in a list
 	return (!nodep->nextp() && nodep->backp()->nextp() != nodep);
     }
-    virtual void visit(AstSenItem* nodep, AstNUser*) {
+    virtual void visit(AstSenItem* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst
 	    && (nodep->sensp()->castConst()
@@ -1519,13 +1542,13 @@ private:
 	    if (nodep->isClocked()) {  // A constant can never get a pos/negexge
 		if (onlySenItemInSenTree(nodep)) {
 		    nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Never()));
-		    nodep->deleteTree(); nodep=NULL;
+		    nodep->deleteTree(); VL_DANGLING(nodep);
 		} else {
-		    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 		}
 	    } else {  // Otherwise it may compute a result that needs to settle out
 		nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Combo()));
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	} else if (m_doNConst && nodep->sensp()->castNot()) {
 	    // V3Gate may propagate NOTs into clocks... Just deal with it
@@ -1541,30 +1564,31 @@ private:
 	    AstNodeVarRef* senvarp = lastSensp->unlinkFrBack()->castNodeVarRef();
 	    if (!senvarp) sensp->v3fatalSrc("Non-varref sensitivity variable");
 	    sensp->replaceWith(senvarp);
-	    sensp->deleteTree(); sensp=NULL;
+	    sensp->deleteTree(); VL_DANGLING(sensp);
 	} else if (!m_doNConst  // Deal with later when doNConst missing
 		   && (nodep->sensp()->castEnumItemRef()
 		       || nodep->sensp()->castConst())) {
+	} else if (nodep->isIllegal()) {  // Deal with later
 	} else {
 	    if (nodep->hasVar() && !nodep->varrefp()) nodep->v3fatalSrc("Null sensitivity variable");
 	}
     }
-    virtual void visit(AstSenGate* nodep, AstNUser*) {
+    virtual void visit(AstSenGate* nodep) {
 	nodep->iterateChildren(*this);
 	if (AstConst* constp = nodep->rhsp()->castConst()) {
 	    if (constp->isZero()) {
 		UINFO(4,"SENGATE(...,0)->NEVER"<<endl);
 		if (onlySenItemInSenTree(nodep)) {
 		    nodep->replaceWith(new AstSenItem(nodep->fileline(), AstSenItem::Never()));
-		    nodep->deleteTree(); nodep=NULL;
+		    nodep->deleteTree(); VL_DANGLING(nodep);
 		} else {
-		    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 		}
 	    } else {
 		UINFO(4,"SENGATE(SENITEM,0)->ALWAYS SENITEM"<<endl);
 		AstNode* senitemp = nodep->sensesp()->unlinkFrBack();
 		nodep->replaceWith(senitemp);
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	}
     }
@@ -1595,7 +1619,7 @@ private:
 	}
     };
 
-    virtual void visit(AstSenTree* nodep, AstNUser*) {
+    virtual void visit(AstSenTree* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doExpensive) {
 	    //cout<<endl; nodep->dumpTree(cout,"ssin: ");
@@ -1630,7 +1654,7 @@ private:
 				    // Found, push this item up to the top
 				    itemp->unlinkFrBack();
 				    nodep->addSensesp(itemp);
-				    gatep->unlinkFrBack()->deleteTree(); gatep=NULL; senp=NULL;
+				    gatep->unlinkFrBack()->deleteTree(); VL_DANGLING(gatep); VL_DANGLING(senp);
 				}
 			    }
 			}
@@ -1686,7 +1710,7 @@ private:
 				&& ritemp->edgeType()==AstEdgeType::ET_NEGEDGE)
 				litemp->edgeType(AstEdgeType::ET_BOTHEDGE);
 			    // Remove redundant node
-			    ritemp->unlinkFrBack()->deleteTree(); ritemp=NULL; cmpp=NULL;
+			    ritemp->unlinkFrBack()->deleteTree(); VL_DANGLING(ritemp); VL_DANGLING(cmpp);
 			    // Try to collapse again
 			    nextp=litemp;
 			}
@@ -1699,17 +1723,17 @@ private:
 
     //-----
     // Zero elimination
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst && replaceNodeAssign(nodep)) return;
     }
-    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+    virtual void visit(AstAssignAlias* nodep) {
 	// Don't perform any optimizations, keep the alias around
     }
-    virtual void visit(AstAssignVarScope* nodep, AstNUser*) {
+    virtual void visit(AstAssignVarScope* nodep) {
 	// Don't perform any optimizations, the node won't be linked yet
     }
-    virtual void visit(AstAssignW* nodep, AstNUser*) {
+    virtual void visit(AstAssignW* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst && replaceNodeAssign(nodep)) return;
 	AstNodeVarRef* varrefp = nodep->lhsp()->castVarRef();  // Not VarXRef, as different refs may set different values to each hierarchy
@@ -1729,14 +1753,14 @@ private:
 				 new AstAssign(nodep->fileline(),
 					       varrefp, exprp));
 	    m_modp->addStmtp(newinitp);
-	    nodep->unlinkFrBack()->deleteTree();  nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    // Set the initial value right in the variable so we can constant propagate
 	    AstNode* initvaluep = exprp->cloneTree(false);
 	    varrefp->varp()->valuep(initvaluep);
 	}
     }
 
-    virtual void visit(AstNodeIf* nodep, AstNUser*) {
+    virtual void visit(AstNodeIf* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
 	    if (AstConst* constp = nodep->condp()->castConst()) {
@@ -1754,12 +1778,12 @@ private:
 		} else {
 		    nodep->unlinkFrBack();
 		}
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (!afterComment(nodep->ifsp()) && !afterComment(nodep->elsesp())) {
 		// Empty block, remove it
 		// Note if we support more C++ then there might be side effects in the condition itself
-		nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (!afterComment(nodep->ifsp())) {
 		UINFO(4,"IF({x}) NULL {...} => IF(NOT{x}}: "<<nodep<<endl);
@@ -1781,7 +1805,7 @@ private:
 		AstIf* ifp = new AstIf(nodep->fileline(), condp, elsesp, ifsp);
 		ifp->branchPred(nodep->branchPred().invert());
 		nodep->replaceWith(ifp);
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (ifSameAssign(nodep)) {
 		UINFO(4,"IF({a}) ASSIGN({b},{c}) else ASSIGN({b},{d}) => ASSIGN({b}, {a}?{c}:{d})"<<endl);
@@ -1794,7 +1818,7 @@ private:
 		ifp->rhsp(new AstCond(truep->fileline(),
 				      condp, truep, falsep));
 		nodep->replaceWith(ifp);
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (0	// Disabled, as vpm assertions are faster without due to short-circuiting
 		     && operandIfIf(nodep)) {
@@ -1806,7 +1830,7 @@ private:
 		nodep->condp(new AstLogAnd(lowerIfp->fileline(),
 					   condp, lowerCondp));
 		lowerIfp->replaceWith(lowerIfsp);
-		lowerIfp->deleteTree(); lowerIfp=NULL;
+		lowerIfp->deleteTree(); VL_DANGLING(lowerIfp);
 	    }
 	    else if (operandBoolShift(nodep->condp())) {
 		replaceBoolShift(nodep->condp());
@@ -1814,7 +1838,7 @@ private:
 	}
     }
 
-    virtual void visit(AstSFormatF* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep) {
 	// Substitute constants into displays.  The main point of this is to
 	// simplify assertion methodologies which call functions with display's.
 	// This eliminates a pile of wide temps, and makes the C a whole lot more readable.
@@ -1825,7 +1849,7 @@ private:
 	}
 	if (m_doNConst && anyconst) {
 	    //UINFO(9,"  Display in  "<<nodep->text()<<endl);
-	    string dispout = "";
+	    string newFormat = "";
 	    string fmt = "";
 	    bool inPct = false;
 	    AstNode* argp = nodep->exprsp();
@@ -1843,84 +1867,82 @@ private:
 		    switch (tolower(ch)) {
 		    case '%': break;  // %% - just output a %
 		    case 'm': break;  // %m - auto insert "name"
+		    case 'l': break;  // %l - auto insert "library"
 		    default:  // Most operators, just move to next argument
 			if (argp) {
 			    AstNode* nextp=argp->nextp();
 			    if (argp && argp->castConst()) { // Convert it
-				string out = argp->castConst()->num().displayed(fmt);
+				string out = argp->castConst()->num().displayed(nodep->fileline(), fmt);
 				UINFO(9,"     DispConst: "<<fmt<<" -> "<<out<<"  for "<<argp<<endl);
-				{   // fmt = out w/ replace % with %% as it must be literal.
-				    fmt = "";
-				    for (string::iterator pos = out.begin(); pos != out.end(); ++pos) {
-					if (*pos == '%') fmt += '%';
-					fmt += *pos;
-				    }
-				}
+				// fmt = out w/ replace % with %% as it must be literal.
+				fmt = VString::quotePercent(out);
 				argp->unlinkFrBack()->deleteTree();
 			    }
 			    argp=nextp;
 			}
 			break;
 		    } // switch
-		    dispout += fmt;
+		    newFormat += fmt;
 		} else {
-		    dispout += ch;
+		    newFormat += ch;
 		}
 	    }
-	    nodep->text(dispout);
-	    //UINFO(9,"  Display out "<<nodep->text()<<endl);
+	    if (newFormat != nodep->text()) {
+		nodep->text(newFormat);
+		UINFO(9,"  Display out "<<nodep<<endl);
+	    }
 	}
 	if (!nodep->exprsp()
 	    && nodep->name().find("%") == string::npos
 	    && !nodep->hidden()) {
 	    // Just a simple constant string - the formatting is pointless
-	    replaceConstString(nodep, nodep->name()); nodep=NULL;
+	    replaceConstString(nodep, nodep->name()); VL_DANGLING(nodep);
 	}
     }
 
-    virtual void visit(AstFuncRef* nodep, AstNUser*) {
+    virtual void visit(AstFuncRef* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_params) {  // Only parameters force us to do constant function call propagation
 	    replaceWithSimulation(nodep);
 	}
     }
-    virtual void visit(AstArg* nodep, AstNUser*) {
+    virtual void visit(AstArg* nodep) {
 	// replaceWithSimulation on the Arg's parent FuncRef replaces these
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
 	    if (nodep->condp()->isZero()) {
 		UINFO(4,"WHILE(0) => nop "<<nodep<<endl);
 		if (nodep->precondsp()) nodep->replaceWith(nodep->precondsp());
 		else nodep->unlinkFrBack();
-		nodep->deleteTree(); nodep=NULL;
+		nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (operandBoolShift(nodep->condp())) {
 		replaceBoolShift(nodep->condp());
 	    }
 	}
     }
-    virtual void visit(AstInitArray* nodep, AstNUser*) {
+    virtual void visit(AstInitArray* nodep) {
 	// Constant if all children are constant
 	nodep->iterateChildren(*this);
     }
 
     // These are converted by V3Param.  Don't constify as we don't want the from() VARREF to disappear, if any
     // If output of a presel didn't get consted, chances are V3Param didn't visit properly
-    virtual void visit(AstNodePreSel* nodep, AstNUser*) {}
+    virtual void visit(AstNodePreSel* nodep) {}
 
     // Ignored, can eliminate early
-    virtual void visit(AstSysIgnore* nodep, AstNUser*) {
+    virtual void visit(AstSysIgnore* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doNConst) {
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	}
     }
 
     // Simplify
-    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+    virtual void visit(AstBasicDType* nodep) {
 	nodep->iterateChildren(*this);
 	nodep->cvtRangeConst();
     }
@@ -1928,12 +1950,12 @@ private:
     //-----
     // Jump elimination
 
-    virtual void visit(AstJumpGo* nodep, AstNUser*) {
+    virtual void visit(AstJumpGo* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_doExpensive) { nodep->labelp()->user4(true); }
     }
 
-    virtual void visit(AstJumpLabel* nodep, AstNUser*) {
+    virtual void visit(AstJumpLabel* nodep) {
 	// Because JumpLabels disable many optimizations,
 	// remove JumpLabels that are not pointed to by any AstJumpGos
 	// Note this assumes all AstJumpGos are underneath the given label; V3Broken asserts this
@@ -1945,7 +1967,7 @@ private:
 	    if (nodep->stmtsp()) underp = nodep->stmtsp()->unlinkFrBackWithNext();
 	    if (underp) nodep->replaceWith(underp);
 	    else nodep->unlinkFrBack();
-	    nodep->deleteTree(); nodep=NULL;
+	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
 
@@ -2262,11 +2284,15 @@ private:
     // Note we can't convert EqCase/NeqCase to Eq/Neq here because that would break 3'b1x1==3'b101
 
     //-----
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_required) {
-	    nodep->v3error("Expecting expression to be constant, but can't convert a "
-			   <<nodep->prettyTypeName()<<" to constant.");
+	    if (nodep->castNodeDType() || nodep->castRange()) {
+		// Ignore dtypes for parameter type pins
+	    } else {
+		nodep->v3error("Expecting expression to be constant, but can't convert a "
+			       <<nodep->prettyTypeName()<<" to constant.");
+	    }
 	} else {
 	    // Calculate the width of this operation
 	    if (m_params && !nodep->width()) {
@@ -2289,7 +2315,7 @@ public:
     };
 
     // CONSTUCTORS
-    ConstVisitor(ProcMode pmode) {
+    explicit ConstVisitor(ProcMode pmode) {
 	m_params = false;
 	m_required = false;
 	m_doExpensive = false;
@@ -2318,7 +2344,7 @@ public:
     virtual ~ConstVisitor() {}
     AstNode* mainAcceptEdit(AstNode* nodep) {
 	// Operate starting at a random place
-	return nodep->acceptSubtreeReturnEdits(*this);
+	return nodep->iterateSubtreeReturnEdits(*this);
     }
 };
 
@@ -2383,12 +2409,14 @@ void V3Const::constifyAllLint(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ConstVisitor visitor (ConstVisitor::PROC_V_WARN);
     (void)visitor.mainAcceptEdit(nodep);
+    V3Global::dumpCheckGlobalTree("const.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 
 void V3Const::constifyCpp(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ConstVisitor visitor (ConstVisitor::PROC_CPP);
     (void)visitor.mainAcceptEdit(nodep);
+    V3Global::dumpCheckGlobalTree("const_cpp.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 
 AstNode* V3Const::constifyEdit(AstNode* nodep) {
@@ -2404,6 +2432,7 @@ void V3Const::constifyAllLive(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ConstVisitor visitor (ConstVisitor::PROC_LIVE);
     (void)visitor.mainAcceptEdit(nodep);
+    V3Global::dumpCheckGlobalTree("const.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 
 void V3Const::constifyAll(AstNetlist* nodep) {
@@ -2411,6 +2440,7 @@ void V3Const::constifyAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ConstVisitor visitor (ConstVisitor::PROC_V_EXPENSIVE);
     (void)visitor.mainAcceptEdit(nodep);
+    V3Global::dumpCheckGlobalTree("const.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 
 AstNode* V3Const::constifyExpensiveEdit(AstNode* nodep) {

src/V3Const.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Coverage.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -83,11 +83,11 @@ private:
     const char* varIgnoreToggle(AstVar* nodep) {
 	// Return true if this shouldn't be traced
 	// See also similar rule in V3TraceDecl::varIgnoreTrace
-	string prettyName = nodep->prettyName();
 	if (!nodep->isToggleCoverable())
 	    return "Not relevant signal type";
 	if (!v3Global.opt.coverageUnderscore()) {
-	    if (prettyName.c_str()[0] == '_')
+	    string prettyName = nodep->prettyName();
+	    if (prettyName[0] == '_')
 	        return "Leading underscore";
 	    if (prettyName.find("._") != string::npos)
 	        return "Inlined leading underscore";
@@ -128,7 +128,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_inModOff = nodep->isTop();   // Ignore coverage on top module; it's a shell we created
 	m_fileps.clear();
@@ -138,7 +138,7 @@ private:
     }
 
     // VISITORS - TOGGLE COVERAGE
-    virtual void visit(AstNodeFTask* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTask* nodep) {
 	bool oldtog = m_inToggleOff;
 	{
 	    m_inToggleOff = true;
@@ -146,7 +146,7 @@ private:
 	}
 	m_inToggleOff = oldtog;
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	if (m_modp && !m_inModOff && !m_inToggleOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageToggle()) {
@@ -279,7 +279,7 @@ private:
     }
 
     // VISITORS - LINE COVERAGE
-    virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
+    virtual void visit(AstIf* nodep) { // Note not AstNodeIf; other types don't get covered
 	UINFO(4," IF: "<<nodep<<endl);
 	if (m_checkBlock) {
 	    // An else-if.  When we iterate the if, use "elsif" marking
@@ -312,7 +312,7 @@ private:
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
-    virtual void visit(AstCaseItem* nodep, AstNUser*) {
+    virtual void visit(AstCaseItem* nodep) {
 	UINFO(4," CASEI: "<<nodep<<endl);
 	if (m_checkBlock && !m_inModOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {
@@ -324,7 +324,7 @@ private:
 	    m_checkBlock = true;  // Reset as a child may have cleared it
 	}
     }
-    virtual void visit(AstPslCover* nodep, AstNUser*) {
+    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);
@@ -334,21 +334,21 @@ private:
 	}
 	m_checkBlock = true;  // Reset as a child may have cleared it
     }
-    virtual void visit(AstStop* nodep, AstNUser*) {
+    virtual void visit(AstStop* nodep) {
 	UINFO(4,"  STOP: "<<nodep<<endl);
 	m_checkBlock = false;
     }
-    virtual void visit(AstPragma* nodep, AstNUser*) {
+    virtual void visit(AstPragma* nodep) {
 	if (nodep->pragType() == AstPragmaType::COVERAGE_BLOCK_OFF) {
 	    // Skip all NEXT nodes under this block, and skip this if/case branch
 	    UINFO(4,"  OFF: "<<nodep<<endl);
 	    m_checkBlock = false;
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
 	    if (m_checkBlock) nodep->iterateChildren(*this);
 	}
     }
-    virtual void visit(AstBegin* nodep, AstNUser*) {
+    virtual void visit(AstBegin* nodep) {
 	// Record the hierarchy of any named begins, so we can apply to user
 	// coverage points.  This is because there may be cov points inside
 	// generate blocks; each point should get separate consideration.
@@ -368,7 +368,7 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	// Default: Just iterate
 	if (m_checkBlock) {
 	    nodep->iterateChildren(*this);
@@ -378,7 +378,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CoverageVisitor(AstNetlist* rootp) {
+    explicit CoverageVisitor(AstNetlist* rootp) {
 	// Operate on all modules
 	m_checkBlock = true;
 	m_beginHier = "";
@@ -395,4 +395,5 @@ public:
 void V3Coverage::coverage(AstNetlist* rootp) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CoverageVisitor visitor (rootp);
+    V3Global::dumpCheckGlobalTree("coverage.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Coverage.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3CoverageJoin.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -93,7 +93,7 @@ private:
 		    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)
-		    removep->unlinkFrBack();  pushDeletep(removep); removep=NULL;
+		    removep->unlinkFrBack();  pushDeletep(removep); VL_DANGLING(removep);
 		    // Remove node from comparison so don't hit it again
 		    hashed.erase(dupit);
 		    ++m_statToggleJoins;
@@ -103,25 +103,25 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	// Find all Coverage's
 	nodep->iterateChildren(*this);
 	// Simplify
 	detectDuplicates();
     }
-    virtual void visit(AstCoverToggle* nodep, AstNUser*) {
+    virtual void visit(AstCoverToggle* nodep) {
 	m_toggleps.push_back(nodep);
 	nodep->iterateChildren(*this);
     }
     //--------------------
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    CoverageJoinVisitor(AstNetlist* nodep) {
+    explicit CoverageJoinVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CoverageJoinVisitor() {
@@ -135,4 +135,5 @@ public:
 void V3CoverageJoin::coverageJoin(AstNetlist* rootp) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CoverageJoinVisitor visitor (rootp);
+    V3Global::dumpCheckGlobalTree("coveragejoin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3CoverageJoin.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.

src/V3Dead.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -25,7 +25,18 @@
 // dependencies easier to resolve.
 // NOTE: If redo this, consider using maybePointedTo()/broken() ish scheme
 // instead of needing as many visitors.
-//*************************************************************************
+//
+// The following nodes have package pointers and are cleaned up here:
+// AstRefDType, AstEnumItemRef, AstNodeVarRef, AstNodeFTask
+// These have packagep but will not exist at this stage
+// AstPackageImport, AstDot, AstPackageRef
+//
+// Note on packagep: After the V3Scope/V3LinkDotScoped stage, package links
+// are no longer used, but their presence prevents us from removing empty
+// packages. As the links as no longer used after V3Scope, we remove them
+// here after scoping to allow more dead node
+// removal.
+// *************************************************************************
 
 #include "config_build.h"
 #include "verilatedos.h"
@@ -47,18 +58,18 @@ private:
     // NODE STATE
     // ** Shared with DeadVisitor **
     // VISITORS
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCell* nodep) {
 	nodep->iterateChildren(*this);
-	nodep->modp()->user1(nodep->modp()->user1() - 1);
+	nodep->modp()->user1Inc(-1);
     }
     //-----
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}  // Accelerate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNodeMath* nodep) {}  // Accelerate
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTRUCTORS
-    DeadModVisitor(AstNodeModule* nodep) {
+    explicit DeadModVisitor(AstNodeModule* nodep) {
 	nodep->accept(*this);
     }
     virtual ~DeadModVisitor() {}
@@ -71,10 +82,10 @@ class DeadVisitor : public AstNVisitor {
 private:
     // NODE STATE
     // Entire Netlist:
-    //  AstNodeModule::user1()	-> int. Count of number of cells referencing this module.
-    //  AstVar::user1()		-> int. Count of number of references
-    //  AstVarScope::user1()	-> int. Count of number of references
-    //  AstNodeDType::user1()	-> int. Count of number of references
+    //	AstNodeModule::user1()	-> int. Count of number of cells referencing this module.
+    //	AstVar::user1()		-> int. Count of number of references
+    //	AstVarScope::user1()	-> int. Count of number of references
+    //	AstNodeDType::user1()	-> int. Count of number of references
     AstUser1InUse	m_inuser1;
 
     // TYPES
@@ -82,11 +93,16 @@ private:
 
     // STATE
     AstNodeModule*		m_modp;		// Current module
-    vector<AstNode*>		m_varEtcsp;	// List of all encountered to avoid another loop through tree
+    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
     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
+    bool			m_elimScopes;	// Allow removal of Scopes
+    bool			m_elimCells;	// Allow removal of Cells
     bool			m_sideEffect;	// Side effects discovered in assign RHS
 
     // METHODS
@@ -97,34 +113,56 @@ private:
     }
 
     void checkAll(AstNode* nodep) {
-	if (nodep != nodep->dtypep()) {  // NodeDTypes reference themselves
-	    if (AstNode* subnodep = nodep->dtypep()) subnodep->user1Inc();
+	if (nodep != nodep->dtypep()) {	 // NodeDTypes reference themselves
+	    if (AstNode* subnodep = nodep->dtypep()) {
+		subnodep->user1Inc();
+	    }
+	}
+	if (AstNode* subnodep = nodep->getChildDTypep()) {
+	    subnodep->user1Inc();
 	}
-	if (AstNode* subnodep = nodep->getChildDTypep()) subnodep->user1Inc();
     }
     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
 	    ) {
-	    m_varEtcsp.push_back(nodep);
+	    m_dtypesp.push_back(nodep);
+	}
+	if (AstNode* subnodep = nodep->virtRefDTypep()) {
+	    subnodep->user1Inc();
 	}
-	if (AstNode* subnodep = nodep->virtRefDTypep()) subnodep->user1Inc();
     }
 
     // VISITORS
-    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	m_modp = NULL;
     }
-    virtual void visit(AstCell* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
+	if (nodep->scopep()) nodep->scopep()->user1Inc();
+    }
+    virtual void visit(AstScope* nodep) {
+	nodep->iterateChildren(*this);
+	checkAll(nodep);
+	if (nodep->aboveScopep()) nodep->aboveScopep()->user1Inc();
+
+	if (!nodep->isTop() && !nodep->varsp() && !nodep->blocksp() && !nodep->finalClksp()) {
+	    m_scopesp.push_back(nodep);
+	}
+    }
+    virtual void visit(AstCell* nodep) {
+	nodep->iterateChildren(*this);
+	checkAll(nodep);
+	m_cellsp.push_back(nodep);
 	nodep->modp()->user1Inc();
     }
-    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+
+    virtual void visit(AstNodeVarRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->varScopep()) {
@@ -135,60 +173,79 @@ private:
 	    nodep->varp()->user1Inc();
 	}
 	if (nodep->packagep()) {
-	    nodep->packagep()->user1Inc();
+	    if (m_elimCells) nodep->packagep(NULL);
+	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+    virtual void visit(AstNodeFTaskRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->packagep()) {
-	    nodep->packagep()->user1Inc();
+	    if (m_elimCells) nodep->packagep(NULL);
+	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstRefDType* nodep, AstNUser*) {
+    virtual void visit(AstRefDType* nodep) {
 	nodep->iterateChildren(*this);
 	checkDType(nodep);
 	checkAll(nodep);
 	if (nodep->packagep()) {
-	    nodep->packagep()->user1Inc();
+	    if (m_elimCells) nodep->packagep(NULL);
+	    else nodep->packagep()->user1Inc();
 	}
     }
-    virtual void visit(AstNodeDType* nodep, AstNUser*) {
+    virtual void visit(AstNodeDType* nodep) {
 	nodep->iterateChildren(*this);
 	checkDType(nodep);
 	checkAll(nodep);
     }
-    virtual void visit(AstEnumItemRef* nodep, AstNUser*) {
+    virtual void visit(AstEnumItemRef* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->packagep()) {
-	    nodep->packagep()->user1Inc();
+	    if (m_elimCells) nodep->packagep(NULL);
+	    else nodep->packagep()->user1Inc();
 	}
+	checkAll(nodep);
     }
-    virtual void visit(AstTypedef* nodep, AstNUser*) {
+    virtual void visit(AstModport* nodep) {
 	nodep->iterateChildren(*this);
+	if (m_elimCells) {
+	    if (!nodep->varsp()) {
+		pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
+		return;
+	    }
+	}
+	checkAll(nodep);
+    }
+    virtual void visit(AstTypedef* nodep) {
+	nodep->iterateChildren(*this);
+	if (m_elimCells && !nodep->attrPublic()) {
+	    pushDeletep(nodep->unlinkFrBack()); VL_DANGLING(nodep);
+	    return;
+	}
 	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();
     }
-    virtual void visit(AstVarScope* nodep, AstNUser*) {
+    virtual void visit(AstVarScope* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
-	if (mightElim(nodep->varp())) {
+	if (nodep->scopep()) nodep->scopep()->user1Inc();
+	if (mightElimVar(nodep->varp())) {
 	    m_vscsp.push_back(nodep);
 	}
     }
-    virtual void visit(AstVar* nodep, AstNUser*) {
+    virtual void visit(AstVar* nodep) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
 	if (nodep->isSigPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
-	if (mightElim(nodep)) {
-	    m_varEtcsp.push_back(nodep);
+	if (mightElimVar(nodep)) {
+	    m_varsp.push_back(nodep);
 	}
     }
-
-    virtual void visit(AstNodeAssign* nodep, AstNUser*) {
+    virtual void visit(AstNodeAssign* nodep) {
 	// See if simple assignments to variables may be eliminated because that variable is never used.
 	// Similar code in V3Life
 	m_sideEffect = false;
@@ -199,7 +256,7 @@ private:
 	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()
+	    checkAll(varrefp);	// Must track reference to dtype()
 	} else {  // Track like any other statement
 	    nodep->lhsp()->iterateAndNext(*this);
 	}
@@ -207,7 +264,7 @@ private:
     }
 
     //-----
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	if (nodep->isOutputter()) m_sideEffect=true;
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
@@ -229,19 +286,51 @@ private:
 		    // And its children may now be killable too; correct counts
 		    // Recurse, as cells may not be directly under the module but in a generate
 		    DeadModVisitor visitor(modp);
-		    modp->unlinkFrBack()->deleteTree(); modp=NULL;
+		    modp->unlinkFrBack()->deleteTree(); VL_DANGLING(modp);
 		    retry = true;
 		}
 	    }
 	}
     }
-    bool mightElim(AstVar* nodep) {
+    bool mightElimVar(AstVar* nodep) {
 	return (!nodep->isSigPublic()	// Can't elim publics!
 		&& !nodep->isIO()
 		&& (nodep->isTemp()
 		    || (nodep->isParam() && !nodep->isTrace())
 		    || m_elimUserVars));  // Post-Trace can kill most anything
     }
+
+    void deadCheckScope() {
+	for (bool retry=true; retry; ) {
+	    retry = false;
+	    for (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);
+		    scp->aboveScopep()->user1Inc(-1);
+		    if (scp->dtypep()) {
+			scp->dtypep()->user1Inc(-1);
+		    }
+		    scp->unlinkFrBack()->deleteTree(); VL_DANGLING(scp);
+		    *it = NULL;
+		    retry = true;
+		}
+	    }
+	}
+    }
+
+    void deadCheckCells() {
+	for (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);
+		cellp->unlinkFrBack()->deleteTree(); VL_DANGLING(cellp);
+	    }
+	}
+    }
+
     void deadCheckVar() {
 	// Delete any unused varscopes
 	for (vector<AstVarScope*>::iterator it = m_vscsp.begin(); it!=m_vscsp.end(); ++it) {
@@ -251,34 +340,76 @@ private:
 		pair <AssignMap::iterator,AssignMap::iterator> eqrange = m_assignMap.equal_range(vscp);
 		for (AssignMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
 		    AstNodeAssign* assp = it->second;
-		    UINFO(4,"    Dead assign "<<assp<<endl);
-		    assp->unlinkFrBack()->deleteTree(); assp=NULL;
+		    UINFO(4,"	 Dead assign "<<assp<<endl);
+		    assp->dtypep()->user1Inc(-1);
+		    assp->unlinkFrBack()->deleteTree(); VL_DANGLING(assp);
 		}
-		vscp->unlinkFrBack()->deleteTree(); vscp=NULL;
+		if (vscp->scopep()) vscp->scopep()->user1Inc(-1);
+		vscp->dtypep()->user1Inc(-1);
+		vscp->unlinkFrBack()->deleteTree(); VL_DANGLING(vscp);
 	    }
 	}
-	for (vector<AstNode*>::iterator it = m_varEtcsp.begin(); it!=m_varEtcsp.end(); ++it) {
+	for (bool retry=true; retry; ) {
+	    retry = false;
+	    for (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);
+		    if (varp->dtypep()) {
+			varp->dtypep()->user1Inc(-1);
+		    }
+		    varp->unlinkFrBack()->deleteTree(); VL_DANGLING(varp);
+		    *it = NULL;
+		    retry = true;
+		}
+	    }
+	}
+	for (vector<AstNode*>::iterator it = m_dtypesp.begin(); it != m_dtypesp.end();++it) {
 	    if ((*it)->user1() == 0) {
-		UINFO(4,"  Dead "<<(*it)<<endl);
-		(*it)->unlinkFrBack()->deleteTree(); (*it)=NULL;
+		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())) {
+		    bool cont = true;
+		    for (AstMemberDType *memberp = classp->membersp(); memberp; memberp = memberp->nextp()->castMemberDType()) {
+			if (memberp->user1() != 0) {
+			    cont = false;
+			    break;
+			}
+		    }
+		    if (!cont)
+			continue;
+		}
+		(*it)->unlinkFrBack()->deleteTree(); VL_DANGLING(*it);
 	    }
 	}
     }
 
 public:
     // CONSTRUCTORS
-    DeadVisitor(AstNetlist* nodep, bool elimUserVars, bool elimDTypes) {
+    DeadVisitor(AstNetlist* nodep, bool elimUserVars, bool elimDTypes, bool elimScopes, bool elimCells) {
 	m_modp = NULL;
+	m_elimCells = elimCells;
 	m_elimUserVars = elimUserVars;
 	m_elimDTypes = elimDTypes;
+	m_elimScopes = elimScopes;
 	m_sideEffect = false;
 	// Prepare to remove some datatypes
 	nodep->typeTablep()->clearCache();
 	// Operate on whole netlist
 	nodep->accept(*this);
+
 	deadCheckVar();
+	// We only elimate scopes when in a flattened structure
+	// Otherwise we have no easy way to know if a scope is used
+	if (elimScopes) deadCheckScope();
+	if (elimCells) deadCheckCells();
 	// Modules after vars, because might be vars we delete inside a mod we delete
 	deadCheckMod();
+
 	// We may have removed some datatypes, cleanup
 	nodep->typeTablep()->repairCache();
     }
@@ -290,13 +421,30 @@ public:
 
 void V3Dead::deadifyModules(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    DeadVisitor visitor (nodep, false, false);
+    DeadVisitor visitor (nodep, false, false, false, false);
+    V3Global::dumpCheckGlobalTree("deadModules.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
 }
+
 void V3Dead::deadifyDTypes(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    DeadVisitor visitor (nodep, false, true);
+    DeadVisitor visitor (nodep, false, true, false, false);
+    V3Global::dumpCheckGlobalTree("deadDtypes.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
+
+void V3Dead::deadifyDTypesScoped(AstNetlist* nodep) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    DeadVisitor visitor (nodep, false, true, true, false);
+    V3Global::dumpCheckGlobalTree("deadDtypesScoped.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+}
+
 void V3Dead::deadifyAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    DeadVisitor visitor (nodep, true, true);
+    DeadVisitor visitor (nodep, true, true, false, true);
+    V3Global::dumpCheckGlobalTree("deadAll.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+}
+
+void V3Dead::deadifyAllScoped(AstNetlist* nodep) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    DeadVisitor visitor (nodep, true, true, true, true);
+    V3Global::dumpCheckGlobalTree("deadAllScoped.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Dead.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -33,8 +33,10 @@ public:
     static void deadifyModules(AstNetlist* nodep);
     // Modules, Data types
     static void deadifyDTypes(AstNetlist* nodep);
+    static void deadifyDTypesScoped(AstNetlist* nodep);
     // Everything that's possible
     static void deadifyAll(AstNetlist* nodep);
+    static void deadifyAllScoped(AstNetlist* nodep);
 };
 
 #endif // Guard

src/V3Delayed.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.
@@ -158,7 +158,7 @@ private:
 	if (oldactivep->sensesp() != m_activep->sensesp()) {
 	    if (!varrefp->varp()->fileline()->warnIsOff(V3ErrorCode::MULTIDRIVEN)
 		&& !varrefp->varp()->user2()) {
-		varrefp->varp()->v3warn(MULTIDRIVEN,"Signal has multiple driving blocks: "<<varrefp->varp()->prettyName()<<endl
+		varrefp->varp()->v3warn(MULTIDRIVEN,"Signal has multiple driving blocks with different clocking: "<<varrefp->varp()->prettyName()<<endl
 					<<varrefp->warnMore()<<"... Location of first driving block"<<endl
 					<<oldactivep->warnMore()<<"... Location of other driving block");
 		varrefp->varp()->user2(true);
@@ -207,8 +207,8 @@ private:
 	    dimvalp.push_front(valp);
 	}
 	AstVarRef* varrefp = dimselp->castVarRef();
-	if (!varrefp) nodep->v3fatalSrc("No var underneath arraysels\n");
-	if (!varrefp->varScopep()) varrefp->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+	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 = oldvarp->user4();  oldvarp->user4(modVecNum+1);
@@ -268,7 +268,7 @@ 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()->castNode()->castVarScope();
+	    setvscp = nodep->user3p()->castVarScope();
 	    ++m_statSharedSet;
 	} else {  // Create new one
 	    string setvarname = (string("__Vdlyvset__")+oldvarp->shortName()+"__v"+cvtToStr(modVecNum));
@@ -303,9 +303,9 @@ private:
 	// Build "IF (changeit) ...
 	UINFO(9,"   For "<<setvscp<<endl);
 	UINFO(9,"     & "<<varrefp<<endl);
-	AstAlwaysPost* finalp = varrefp->varScopep()->user4p()->castNode()->castAlwaysPost();
+	AstAlwaysPost* finalp = varrefp->varScopep()->user4p()->castAlwaysPost();
 	if (finalp) {
-	    AstActive* oldactivep = finalp->user2p()->castNode()->castActive();
+	    AstActive* oldactivep = finalp->user2p()->castActive();
 	    checkActivePost(varrefp, oldactivep);
 	    if (setinitp) oldactivep->addStmtsp(setinitp);
 	} else { // first time we've dealt with this memory
@@ -318,10 +318,10 @@ private:
 	    if (setinitp) newactp->addStmtsp(setinitp);
 	}
 	AstIf* postLogicp;
-	if (finalp->user3p()->castNode() == setvscp) {
+	if (finalp->user3p() == setvscp) {
 	    // Optimize as above; if sharing Vdlyvset *ON SAME VARIABLE*,
 	    // we can share the IF statement too
-	    postLogicp = finalp->user4p()->castNode()->castIf();
+	    postLogicp = finalp->user4p()->castIf();
 	    if (!postLogicp) nodep->v3fatalSrc("Delayed assignment misoptimized; prev var found w/o associated IF");
 	} else {
 	    postLogicp = new AstIf (nodep->fileline(),
@@ -338,22 +338,22 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstNetlist* nodep, AstNUser*) {
+    virtual void visit(AstNetlist* nodep) {
 	//VV*****  We reset all userp() on the netlist
 	m_modVarMap.clear();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstScope* nodep, AstNUser*) {
+    virtual void visit(AstScope* nodep) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	AstNode::user3ClearTree();
 	nodep->iterateChildren(*this);
     }
-    virtual void visit(AstCFunc* nodep, AstNUser*) {
+    virtual void visit(AstCFunc* nodep) {
 	m_cfuncp = nodep;
 	nodep->iterateChildren(*this);
 	m_cfuncp = NULL;
     }
-    virtual void visit(AstActive* nodep, AstNUser*) {
+    virtual void visit(AstActive* nodep) {
 	m_activep = nodep;
 	bool oldinit = m_inInitial;
 	m_inInitial = nodep->hasInitial();
@@ -361,7 +361,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_inInitial = oldinit;
     }
-    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+    virtual void visit(AstAssignDly* nodep) {
 	m_inDly = true;
 	m_nextDlyp = nodep->nextp()->castAssignDly();  // Next assignment in same block, maybe NULL.
 	if (m_cfuncp) nodep->v3error("Unsupported: Delayed assignment inside public function/task");
@@ -374,9 +374,9 @@ private:
 	    if (newlhsp) {
 		nodep->lhsp(newlhsp);
 	    } else {
-		nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+		nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    }
-	    lhsp->deleteTree(); lhsp=NULL;
+	    lhsp->deleteTree(); VL_DANGLING(lhsp);
 	}
 	else {
 	    nodep->iterateChildren(*this);
@@ -385,7 +385,7 @@ private:
 	m_nextDlyp = NULL;
     }
 
-    virtual void visit(AstVarRef* nodep, AstNUser*) {
+    virtual void visit(AstVarRef* nodep) {
 	if (!nodep->user2Inc()) {  // Not done yet
 	    if (m_inDly && nodep->lvalue()) {
 		UINFO(4,"AssignDlyVar: "<<nodep<<endl);
@@ -393,10 +393,10 @@ private:
 		if (!m_activep) nodep->v3fatalSrc("<= not under sensitivity block");
 		if (!m_activep->hasClocked()) nodep->v3error("Internal: Blocking <= assignment in non-clocked block, should have converted in V3Active");
 		AstVarScope* oldvscp = nodep->varScopep();
-		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
-		AstVarScope* dlyvscp = oldvscp->user1p()->castNode()->castVarScope();
+		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
+		AstVarScope* dlyvscp = oldvscp->user1p()->castVarScope();
 		if (dlyvscp) {  // Multiple use of delayed variable
-		    AstActive* oldactivep = dlyvscp->user2p()->castNode()->castActive();
+		    AstActive* oldactivep = dlyvscp->user2p()->castActive();
 		    checkActivePost(nodep, oldactivep);
 		}
 		if (!dlyvscp) {  // First use of this delayed variable
@@ -420,7 +420,7 @@ private:
 		}
 		AstVarRef* newrefp = new AstVarRef(nodep->fileline(), dlyvscp, true);
 		newrefp->user2(true);  // No reason to do it again
-		nodep->replaceWith(newrefp); nodep->deleteTree(); nodep=NULL;
+		nodep->replaceWith(newrefp); nodep->deleteTree(); VL_DANGLING(nodep);
 	    }
 	    else if (!m_inDly && nodep->lvalue()) {
 		//UINFO(9,"NBA "<<nodep<<endl);
@@ -432,10 +432,10 @@ private:
 	}
     }
 
-    virtual void visit(AstNodeFor* nodep, AstNUser*) {
-	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin\n");
+    virtual void visit(AstNodeFor* nodep) {
+	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin");
     }
-    virtual void visit(AstWhile* nodep, AstNUser*) {
+    virtual void visit(AstWhile* nodep) {
 	bool oldloop = m_inLoop;
 	m_inLoop = true;
 	nodep->iterateChildren(*this);
@@ -444,13 +444,13 @@ private:
 
     //--------------------
     // Default: Just iterate
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    virtual void visit(AstNode* nodep) {
 	nodep->iterateChildren(*this);
     }
 
 public:
     // CONSTUCTORS
-    DelayedVisitor(AstNetlist* nodep) {
+    explicit DelayedVisitor(AstNetlist* nodep) {
 	m_inDly = false;
 	m_activep=NULL;
 	m_cfuncp=NULL;
@@ -471,4 +471,5 @@ public:
 void V3Delayed::delayedAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     DelayedVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("delayed.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Delayed.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2014 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2017 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.