Version bump

Commentary
Turn off parser debug in optimized build, msg2203
2026-10-02 16:13:34 +02:00 · 2017-04-02 08:43:53 -04:00 · 2017-04-02 08:39:33 -04:00 · 2017-03-31 17:46:15 -04:00 · 2017-03-30 19:05:55 -04:00 · 2017-03-30 18:32:37 -04:00
587 changed files with 17077 additions and 6543 deletions
@@ -24,3 +24,4 @@ internals.txt
 verilator.txt
 verilator_bin*
 verilator_coverage_bin*
+verilator.pc
@@ -1,9 +1,326 @@
 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.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 +2820,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:
@@ -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$
@@ -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

@@ -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.

@@ -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.
@@ -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.
@@ -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.

@@ -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.
 ######################################################################
@@ -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.

@@ -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.902 2017-04-02])
+# 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,65 @@ 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,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-undefined-bool-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-delete-null-pointer-checks)
+AC_SUBST(CFG_CXXFLAGS_SRC)
+
+# Flags for compiling Verilator parser
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-null-conversion)
+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)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-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,-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)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)

 # Checks for library functions.
@@ -142,6 +177,8 @@ AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 # Other install directories
 pkgdatadir=${datadir}/verilator
 AC_SUBST(pkgdatadir)
+pkgconfigdir=${datadir}/pkgconfig
+AC_SUBST(pkgconfigdir)

 AC_OUTPUT

@@ -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.
@@ -374,7 +374,7 @@ 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--;
@@ -404,7 +404,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) {
@@ -438,6 +438,7 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 			output += ((lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb)) & 1) + '0';
 		    }
 		    break;
+		    break;
 		case 'o':
 		    for (; lsb>=0; lsb--) {
 			lsb = (lsb / 3) * 3; // Next digit
@@ -450,6 +451,28 @@ 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] >> 0) & 0xff);
+			output += (char)((lwp[i] >> 8) & 0xff);
+			output += (char)((lwp[i] >> 16) & 0xff);
+			output += (char)((lwp[i] >> 24) & 0xff);
+		    }
+		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] >> 0) & 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
+		    }
+		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 ";
+		    }
 		case 'x':
 		    for (; lsb>=0; lsb--) {
 			lsb = (lsb / 4) * 4; // Next digit
@@ -476,7 +499,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 +509,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;
@@ -547,6 +573,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 +584,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 +601,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;
@@ -591,15 +618,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		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;
@@ -609,8 +636,8 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    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 +647,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 +667,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;
@@ -704,8 +732,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) {
@@ -746,6 +774,11 @@ 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);
    return VL_FOPEN_WI(2, fnw, mode);
@@ -875,7 +908,7 @@ 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;
 }
@@ -885,7 +918,7 @@ IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...) {

    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;
 }
@@ -894,14 +927,21 @@ IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...) {

    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;
 }
@@ -916,11 +956,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,81 +982,81 @@ 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)) {
+                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 (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; }

    // 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");
    }
 }

@@ -1030,6 +1077,14 @@ IData VL_TESTPLUSARGS_I(const char* formatp) {
    else return 1;
 }

+IData VL_VALUEPLUSARGS_IN(int, const char* prefixp, char, string& ldr) {
+    const string& match = VerilatedImp::argPlusMatch(prefixp);
+    const char* dp = match.c_str() + 1 /*leading + */ + strlen(prefixp);
+    if (match == "") return 0;
+    ldr = string(dp);
+    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);
@@ -1135,7 +1190,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 +1214,10 @@ int Verilated::exportFuncNum(const char* namep) {
    return VerilatedImp::exportFind(namep);
 }

+const VerilatedScopeNameMap* Verilated::scopeNameMap() {
+    return VerilatedImp::scopeNameMap();
+}
+
 //===========================================================================
 // VerilatedModule:: Methods

@@ -1162,7 +1226,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 +1340,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)
@@ -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;

@@ -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; }
@@ -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,
@@ -594,13 +600,13 @@ 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) { \
@@ -1132,7 +1138,9 @@ 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]);
+    // cppcheck-suppress variableScope
    IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
    IData rwstore[VL_MULS_MAX_WORDS];
    WDataInP ltup = lwp;
    WDataInP rtup = rwp;
@@ -1151,7 +1159,9 @@ 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]);
+    // cppcheck-suppress variableScope
    IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
    IData rwstore[VL_MULS_MAX_WORDS];
    WDataInP ltup = lwp;
    WDataInP rtup = rwp;
@@ -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.
 ######################################################################
@@ -43,8 +43,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
@@ -120,26 +121,13 @@ ifeq ($(VM_SP),1)
 	 $(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
-
 #######################################################################
 ##### C/H builds

-ifeq ($(VM_PCLI),1)
-  LIBS   += -lm -lstdc++
-endif
+LIBS   += -lm -lstdc++

 #######################################################################
 # Overall Objects Linking
@@ -153,7 +141,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 +163,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

@@ -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.
@@ -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.
@@ -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;
@@ -74,6 +75,7 @@ public:
    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() {}
 };
@@ -260,8 +262,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;
@@ -439,8 +441,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));
@@ -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_
@@ -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
@@ -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_
@@ -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.
@@ -82,7 +82,7 @@ void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
 void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w) {
    _VL_SVDPI_UNIMP();
 }
-void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w) {
+void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
    _VL_SVDPI_UNIMP();
 }

@@ -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.
@@ -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.
@@ -41,7 +41,7 @@ inline string VL_CVT_PACK_STR_NQ(QData lhs) {
    IData 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) {
@@ -51,7 +51,7 @@ inline string VL_CVT_PACK_STR_NI(IData lhs) {
 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;
    return out;
@@ -60,7 +60,12 @@ inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs
    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_IN(int rbits, const char* prefixp, char fmt, string& ldr);

 #endif // Guard
@@ -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,7 +92,11 @@ public: // But only for verilated*.cpp

    // METHODS - arguments
    static void commandArgs(int argc, const char** argv) {
-	s_s.m_argVec.clear();
+	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
    }
@@ -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
@@ -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 
@@ -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);
@@ -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.
@@ -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() {}
@@ -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
 }

@@ -440,7 +472,7 @@ void VerilatedVcd::dumpHeader () {
    deleteNameMap();
 }

-void VerilatedVcd::module (string name) {
+void VerilatedVcd::module (const string& name) {
    m_modName = name;
 }

@@ -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);
@@ -398,7 +401,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?
@@ -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 **) {}

@@ -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

@@ -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

+#ifdef VL_CPPCHECK
+# 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

@@ -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);

 /*
@@ -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.

@@ -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.
@@ -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.
@@ -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.

@@ -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.

@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.
@@ -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.

@@ -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.
@@ -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
@@ -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,11 +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
+CPPFLAGSPARSER = $(CPPFLAGS) $(CFG_CXXFLAGS_PARSER)

 ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
 SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
@@ -161,6 +166,7 @@ RAW_OBJS = \
 	V3Begin.o \
 	V3Branch.o \
 	V3Broken.o \
+	V3CCtors.o \
 	V3Case.o \
 	V3Cast.o \
 	V3Cdc.o \
@@ -212,6 +218,7 @@ RAW_OBJS = \
 	V3Number.o \
 	V3Options.o \
 	V3Order.o \
+	V3Os.o \
 	V3Param.o \
 	V3PreShell.o \
 	V3Premit.o \
@@ -277,16 +284,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 +302,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 +330,8 @@ V3PreLex_pregen.yy.cpp:	V3PreLex.l $(HEADERS)
 V3PreLex.yy.cpp: V3PreLex_pregen.yy.cpp $(FLEXFIX)
 	$(PERL) $(FLEXFIX) V3PreLex <$< >$@

+.SUFFIXES:
+
 ######################################################################
 ######################################################################

@@ -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,7 +316,7 @@ 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;
 	}

@@ -327,7 +329,9 @@ private:

 	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);
 }
@@ -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.
@@ -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
@@ -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);
 }
@@ -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.
@@ -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;
@@ -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,34 @@ 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;
+			    AstConst* iconstp = icondp->castConst();
+			    if (iconstp && iconstp->num().isFourState()
+				&& (nodep->casex() || nodep->casez() || nodep->caseInside())) {
+				V3Number nummask (itemp->fileline(), iconstp->width());
+				nummask.opBitsNonX(iconstp->num());
+				V3Number numval  (itemp->fileline(), iconstp->width());
+				numval.opBitsOne(iconstp->num());
+				AstNode* and1p = new AstAnd(itemp->fileline(), nodep->exprp()->cloneTree(false),
+							    new AstConst(itemp->fileline(), nummask));
+				AstNode* and2p = new AstAnd(itemp->fileline(),
+							    new AstConst(itemp->fileline(), numval),
+							    new AstConst(itemp->fileline(), nummask));
+				onep = AstEq::newTyped(itemp->fileline(), and1p, and2p);
+
+			    } 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 +285,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 +298,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 +329,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 +354,5 @@ public:
 void V3Assert::assertAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    AssertVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("assert.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -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.
@@ -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);
 }
@@ -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.
@@ -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,37 +855,47 @@ 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))
 	);
 }

@@ -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;
@@ -1037,7 +1058,13 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
 }

 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 +1072,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();
 }

 //======================================================================
@@ -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; }
@@ -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;
@@ -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; }
@@ -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
@@ -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; }
@@ -485,6 +500,39 @@ public:

 //######################################################################

+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, AstVarAttrClocker rhs) { return os<<rhs.ascii(); }
+
+//######################################################################
+
 class VAlwaysKwd {
 public:
    enum en {
@@ -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; }
@@ -664,7 +716,7 @@ struct 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,30 @@ 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() {}
+    VNUser(int i) { m_u.up = 0; m_u.ui = i; }
+    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 +867,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)); }
 };

 //######################################################################
@@ -862,16 +919,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()); }
@@ -920,15 +980,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 +998,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 +1016,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 +1108,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 +1116,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=##"
@@ -1154,8 +1236,10 @@ public:
    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 +1255,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 +1288,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 +1312,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 +1335,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 +1352,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 +1373,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 +1400,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 +1444,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 +1464,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 +1481,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 +1499,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; }
@@ -1433,10 +1519,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 +1561,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 +1571,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 +1625,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 +1658,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)
@@ -1661,7 +1747,7 @@ 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)
@@ -1670,7 +1756,7 @@ public:
    virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
 						     || (!m_refDTypep && childDTypep()))); return NULL; }
    virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
-	m_refDTypep = m_refDTypep->clonep()->castNodeDType();
+	m_refDTypep = m_refDTypep->clonep();
    }}
    virtual bool same(AstNode* samep) const {
 	AstNodeArrayDType* sp = samep->castNodeArrayDType();
@@ -1706,9 +1792,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 +1840,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 +1895,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 +1913,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 +1945,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 +1995,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 +2007,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
@@ -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.
@@ -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 {
@@ -195,6 +195,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 +352,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 +388,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 +423,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 +442,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 +497,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 +511,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 +523,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 +871,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 +926,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 +979,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) {
@@ -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);
 }
@@ -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.
@@ -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();
@@ -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.
@@ -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.
@@ -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,18 @@ private:
 		if (nodep->dtypep()) nodep->v3fatalSrc("DType on node without hasDType(): "<<nodep->prettyTypeName());
 	    }
 	    if (nodep->getChildDTypep()) nodep->v3fatalSrc("childDTypep() non-null on node after should have removed");
-	    if (AstNodeDType* dnodep = nodep->castNodeDType()) {
-		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(AstNode* nodep) {
+	processAndIterate(nodep);
+    }
 public:
    // CONSTUCTORS
-    BrokenCheckVisitor(AstNetlist* nodep) {
+    explicit BrokenCheckVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
    }
    virtual ~BrokenCheckVisitor() {}
@@ -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.
@@ -0,0 +1,117 @@
+// -*- 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="") {
+	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);
+	m_funcp = m_tlFuncp;
+	m_modp->addStmtp(m_tlFuncp);
+    }
+};
+
+//######################################################################
+
+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");
+
+	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;
+	    }
+	}
+    }
+}
@@ -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
@@ -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);
    }
@@ -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);
@@ -426,7 +426,7 @@ private:
 	if (debug()>=9) 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);
@@ -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.
@@ -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);
 }
@@ -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.
@@ -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;

@@ -604,19 +604,19 @@ 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(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,7 +627,7 @@ 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");
 	    AstVarScope* varscp = nodep->varScopep();
@@ -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;
@@ -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.
@@ -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));
-	//
+	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);
 }
@@ -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.
@@ -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);
 }
@@ -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.
@@ -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);
 		}
 	    }
 	}
@@ -701,7 +701,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 +751,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 +778,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 +819,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 +836,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 +844,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 +878,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 +914,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);
 }
@@ -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.
@@ -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,7 +188,7 @@ 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();
@@ -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);
 }
@@ -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.
@@ -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);
 	    }
 	}
    }
@@ -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);
 }
@@ -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.
@@ -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.
@@ -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);
    }
 }

@@ -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);
 };

@@ -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) {
@@ -559,58 +562,58 @@ 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);
    }
    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) {
@@ -1382,7 +1379,7 @@ private:
 				  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 +1397,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 +1411,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 +1435,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,17 +1465,29 @@ 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;
 		    }
 		}
@@ -1483,7 +1497,7 @@ private:
 	    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 +1506,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 +1515,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 +1523,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 +1533,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 +1555,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 +1610,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 +1645,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 +1701,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 +1714,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 +1744,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 +1769,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 +1796,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 +1809,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 +1821,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 +1829,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 +1840,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 +1858,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 +1941,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 +1958,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 +2275,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 +2306,7 @@ public:
    };

    // CONSTUCTORS
-    ConstVisitor(ProcMode pmode) {
+    explicit ConstVisitor(ProcMode pmode) {
 	m_params = false;
 	m_required = false;
 	m_doExpensive = false;
@@ -2318,7 +2335,7 @@ public:
    virtual ~ConstVisitor() {}
    AstNode* mainAcceptEdit(AstNode* nodep) {
 	// Operate starting at a random place
-	return nodep->acceptSubtreeReturnEdits(*this);
+	return nodep->iterateSubtreeReturnEdits(*this);
    }
 };

@@ -2383,12 +2400,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 +2423,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 +2431,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) {
@@ -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.
@@ -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);
 }
@@ -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.
@@ -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);
 }
@@ -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.
@@ -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);
 }
@@ -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
@@ -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.
@@ -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);
@@ -394,9 +394,9 @@ private:
 		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();
+		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*) {
+    virtual void visit(AstNodeFor* nodep) {
 	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin\n");
    }
-    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);
 }
@@ -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.
--- a/Show More
+++ b/Show More