Version bump

Fix some clang-analyzer warnings
examples: Fix wide signal overflow, and stop on errors.
2026-10-03 00:23:35 +02:00 · 2017-11-25 15:42:11 -05:00 · 2017-11-25 15:41:49 -05:00 · 2017-11-25 15:14:31 -05:00 · 2017-11-23 14:55:32 -05:00 · 2017-11-23 11:38:09 -05:00
520 changed files with 15875 additions and 5781 deletions
@@ -1,3 +1,5 @@
+\#*
+.#*
 *~
 *.old
 *.gz
@@ -20,8 +22,10 @@ configure
 dddrun*
 doxygen-doc
 gdbrun*
+gmon.out
 internals.txt
 verilator.txt
 verilator_bin*
 verilator_coverage_bin*
 verilator.pc
+**/obj_dir/*
@@ -2,6 +2,193 @@ Revision history for Verilator

 The contributors that suggested a given feature are shown in []. Thanks!

+* Verilator 3.916 2017-11-25
+
+***   Support self-recursive modules, bug659. [Sean Moore, et al]
+
+***   Support $error/$warning in elaboration time blocks.
+
+***   Support $size/$bits/etc on type references.
+
+***   Add error when driving input-only modport, bug1110. [Trevor Elbourne]
+
+***   Add BSSPACE and COLONPLUS lint warnings.
+
+****  Detect MSB overflow when under VL_DEBUG, bug1238. [Junyi Xi]
+
+****  Add data types to --xml. [Rui Terra]
+
+****  Fix partial slicing with pattern assignments, bug991. [Johan Bjork]
+
+****  Fix false unused warning on interfaces, bug1241. [Laurens van Dam]
+
+****  Fix error on "unique case" with no cases.
+
+****  Fix MacOS portability, bug1232. [Jeff Bush]
+
+
+* Verilator 3.914 2017-10-14
+
+**    Added new examples/ directory with appropriate examples. This replaces the
+      old test_c and test_sc directories.
+
+***   Add --getenv option for simplifying Makefiles.
+
+***   Add --x-initial option for specifying initial value assignment behavior.
+
+***   Add --no-relative-cfuncs and related default optimization, bug1224. [John Coiner]
+
+***   Add /*verilator tag*/ for XML extraction applications. [Chris Randall]
+
+****  The internal test_verilated test directory is moved to be part of test_regress.
+
+****  The experimental VL_THREADED setting (only, not normal mode) now requires C++11.
+
+****  Fix over-aggressive inlining, bug1223. [John Coiner]
+
+****  Fix Ubuntu 17.10 issues, bug1223 partial. [John Coiner]
+
+****  Fix compiler warning when WIDTH warning ignored on large compare.
+
+****  Fix memory leak in VerilatedVcd dumps, bug1222 partial. [Shareef Jalloq]
+
+****  Fix unnecessary Vdly variables, bug1224 partial. [John Coiner]
+
+****  Fix conditional slices and add related optimizations.
+
+****  Fix `` expansion of `defines, bug1225, bug1227, bug1228. [Odd Magne Reitan]
+
+****  Fix -E duplicating output, bug1226. [Odd Magne Reitan]
+
+****  Fix float-conversion warning, bug1229. [Robert Henry]
+
+****  Fix MacOS portability, bug1230, bug1231. [Jeff Bush]
+
+
+* Verilator 3.912 2017-09-23
+
+**    Verilated headers no longer "use namespace std;"
+      User's code without "std::" prefixes may need "use namespace std;" to compile.
+
+***   Support or/and/xor array intrinsic methods, bug1210. [Mike Popoloski]
+
+***   Support package export, bug1217. [Usuario Eda]
+
+***   Fix ordering of arrayed cell wide connections, bug1202 partial. [Mike Popoloski]
+
+****  Support module port parameters without defaults, bug 1213. [Mike Popoloski]
+
+****  Add performance information to --stats file.
+
+****  Simplify VL_CONST_W macro generation for faster compiles.
+
+****  Fix LITENDIAN warning on arrayed cells, bug1202. [Mike Popoloski]
+
+****  Fix enum ranges without colons, bug1204. [Mike Popoloski]
+
+****  Fix GCC noreturn compile error, bug1209. [Mike Popoloski]
+
+****  Fix constant function default parameters, bug1211. [Mike Popoloski]
+
+****  Fix non-colon array of interface modports, bug1212. [Mike Popoloski]
+
+****  Fix .name connections on interfaces, bug1214. [Mike Popoloski]
+
+****  Fix wide array indices causing compile error.
+
+****  Better optimize Shift-And, and replication constructs.
+
+
+* Verilator 3.910 2017-09-07
+
+***   SystemPerl mode (-sp-deprecated) has been removed.
+
+****  Update keyword warnings to include C++11 and others.
+
+
+* Verilator 3.908 2017-08-28
+
+****  Support x in $readmem, bug1180. [Arthur Kahlich]
+
+****  Support packed struct DPI imports, bug1190. [Rob Stoddard]
+
+****  Fix GCC 6 warnings.
+
+****  Fix compile error on unused VL_VALUEPLUSARGS_IW, bug1181. [Thomas J Whatson]
+
+****  Fix undefined VL_POW_WWI. [Clifford Wolf]
+
+****  Fix internal error on unconnected inouts, bug1187. [Rob Stoddard]
+
+
+* Verilator 3.906 2017-06-22
+
+***   Support set_time_unit/set_time_precision in C traces, msg2261.
+
+***   Fix extract of packed array with non-zero LSB, bug1172. [James Pallister]
+
+***   Fix shifts by more than 32-bit numbers, bug1174. [Clifford Wolf]
+
+***   Fix power operator on wide constants, bug761. [Clifford Wolf]
+
+***   Fix .* on interface pins, bug1176. [Maciej Piechotka]
+
+
+* Verilator 3.904 2017-05-30
+
+***   Fix non-cutable ordering loops on clock arrays, bug1009. [Todd Strader]
+
+***   Support ports of array of reals, bug1154. [J Briquet]
+
+***   Support arrayed parameter overrides, bug1153. [John Stevenson]
+
+***   Support $value$plusargs with variables, bug1165. [Wesley Terpstra]
+
+****  Support modport access to un-modport objects, bug1161. [Todd Strader]
+
+****  Add stack trace when can't optimize function, bug1158. [Todd Strader]
+
+****  Add warning on mis-sized literal, bug1156. [Todd Strader]
+
+****  Fix interface functions returning wrong parameters, bug996. [Todd Strader]
+
+****  Fix non-arrayed cells with interface arrays, bug1153. [John Stevenson]
+
+****  Fix --assert with complex case statements, bug1164. [Enzo Chi]
+
+
+* Verilator 3.902 2017-04-02
+
+**    Add -FI option to force includes,msg2146. [Amir Gonnen]
+
+**    Add --relative-includes. [Rob Stoddard]
+
+***   Add error on duplicate pattern assignments, bug1145. [Johan Bjork]
+
+****  Fix error on improperly widthed default function, bug984. [Todd Strader]
+
+****  Fix 2009 localparam syntax, msg2139. [Galen Seitz]
+
+****  Fix ugly interface-to-non-interface errors, bug1112. [Johan Bjork]
+
+****  Fix LDFLAGS and CFLAGS not preserving order, bug1130. [Olof Kindgren]
+
+****  Fix internal error on initializing parameter array, bug1131. [Jie Xu]
+
+****  Fix internal error on interface arrays, bug1135. [John Stevenson]
+
+****  Fix calling sformatf to display, and elab $displays, bug1139. [Johan Bjork]
+
+****  Fix realpath compile issue on MSVC++, bug1141. [Miodrag Milanovic]
+
+****  Fix missing error on interface size mismatch, bug1143.  [Johan Bjork]
+
+****  Fix error on parameters with dotted references, bug1146. [Johan Bjork]
+
+****  Fix wreal not handling continuous assign, bug1150. [J Briquet]
+
+****  Fix nested structure parameter selects, bug1150. [J Briquet]
+

 * Verilator 3.900 2017-01-15

@@ -20,6 +20,8 @@
 /cov_work/
 /logs/
 ^Makefile$
+bin/verilator_bin.*
+bin/verilator_coverage_bin.*
 src/Makefile$
 src/Makefile_obj$
 include/verilated.mk$
@@ -39,5 +41,6 @@ nodist/
 /vc_hdrs.h$
 /csrc/
 doxygen-doc/.*
+obj_dir/.*
 TAGS
 .*~
@@ -92,6 +92,7 @@ datarootdir = @datarootdir@
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
+CFG_WITH_THREADED = @CFG_WITH_THREADED@
 PACKAGE_VERSION = @PACKAGE_VERSION@

 #### End of system configuration section. ####
@@ -101,7 +102,9 @@ PACKAGE_VERSION = @PACKAGE_VERSION@

 SHELL = /bin/sh

-SUBDIRS = src test_verilated test_c test_sc test_regress
+SUBDIRS = src test_regress \
+	examples/hello_world_c  examples/hello_world_sc \
+	examples/tracing_c  examples/tracing_sc \

 INFOS = README README.html README.pdf internals.txt internals.html \
        internals.pdf verilator.txt verilator.html verilator.pdf \
@@ -114,7 +117,11 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	*.in *.ac \
 	Changes TODO \
 	MANIFEST.SKIP \
-	bin/* \
+	bin/verilator \
+	bin/verilator_coverage \
+	bin/verilator_difftree \
+	bin/verilator_includer \
+	bin/verilator_profcfunc \
 	doxygen-mainpage doxygen.config veripool-logo.png \
 	install-sh configure mkinstalldirs *.pod \
 	include/*.[chv]* \
@@ -127,11 +134,14 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	src/vlcovgen \
 	src/.gdbinit \
 	src/*.pl src/*.pod \
+	examples/*/.*ignore examples/*/Makefile* \
+	examples/*/*.[chv]* examples/*/*.pl \
 	test_*/.*ignore test_*/Makefile* test_*/*.cpp \
 	test_*/*.pl test_*/*.v test_*/*.vc test_*/*.vh \
-	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 \
@@ -151,9 +161,9 @@ INST_PROJ_FILES = \
 	include/vltstd/*.[chv]* \

 INST_PROJ_BIN_FILES = \
-	verilator_bin \
-	verilator_bin_dbg \
-	verilator_coverage_bin_dbg \
+	bin/verilator_bin \
+	bin/verilator_bin_dbg \
+	bin/verilator_coverage_bin_dbg \

 DISTFILES := $(DISTFILES_INC)

@@ -180,33 +190,33 @@ verilator_exe verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg:
 msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
-	@echo "Type 'make test' to test."
+	@echo "Now type 'make test' to test."
 	@echo

-.PHONY:test
+.PHONY: test
 ifeq ($(CFG_WITH_LONGTESTS),yes)	# Local... Else don't burden users
-test: test_c test_sc test_verilated test_regress
+test: smoke-test examples test_regress
 else
-test: test_c test_sc
+test: smoke-test examples
 endif
 	@echo "Tests passed!"
 	@echo
-	@echo "Type 'make install' to install documentation."
+	@echo "Now type 'make install' to install."
+	@echo "Or type 'make' inside an examples subdirectory."
 	@echo

-test_c: all_nomsg
-	@(cd test_c && $(MAKE))
-test_c_debug: all_nomsg
-	@(cd test_c && $(MAKE) test_debug)
-test_sc: all_nomsg
-	@(cd test_sc && $(MAKE))
-test_sc_debug: all_nomsg
-	@(cd test_sc && $(MAKE) test_debug)
-test_verilated: all_nomsg
-	@(cd test_verilated && $(MAKE))
+smoke-test: all_nomsg
+	test_regress/t/t_a_first_cc.pl
+	test_regress/t/t_a_first_sc.pl
+
 test_regress: all_nomsg
 	@(cd test_regress && $(MAKE))

+examples: all_nomsg
+	for p in examples/* ; do \
+	  $(MAKE) -C $$p VERILATOR_ROOT=`pwd` || exit 10; \
+	done
+
 info: $(INFOS)

 # Use --no-split to avoid creating filenames > 14 chars.
@@ -279,18 +289,16 @@ VL_INST_INC_SRCDIR_FILES = \
 	include/vltstd/*.[chv]* \

 VL_INST_DATA_SRCDIR_FILES = \
-	test_v/*.[chv]* \
-	test_c/*.[chv]*   test_c/Makefile  test_c/Makefile_obj  \
-	test_sc/*.[chv]*  test_sc/Makefile test_sc/Makefile_obj \
+	examples/*/*.[chv]*  examples/*/Makefile* \

 installbin:
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir)
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage $(DESTDIR)$(bindir)/verilator_coverage )
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
-	( $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
-	( $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
-	( $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin $(DESTDIR)$(bindir)/verilator_bin )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_bin_dbg $(DESTDIR)$(bindir)/verilator_bin_dbg )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg )
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/bin
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )

@@ -312,12 +320,13 @@ installdata:
 	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_c
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_sc
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_v
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_c
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
-	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/examples/$$p; \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
 	done
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgconfigdir)
 	$(INSTALL_DATA) verilator.pc $(DESTDIR)$(pkgconfigdir)
@@ -329,15 +338,15 @@ uninstall:
 	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
 	-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)
+	-cd $(DESTDIR)$(pkgdatadir) && 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
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_c
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sc
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sp
-	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_v
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_c
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/hello_world_sc
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/tracing_c
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/tracing_sc
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
 	-rmdir $(DESTDIR)$(pkgdatadir)
 	-rmdir $(DESTDIR)$(pkgconfigdir)
@@ -356,8 +365,8 @@ INST_PROJ_CVS = cp_if_cvs_diff

 install-project: dist
 	@echo "Install-project to $(DIRPROJECT)"
-	strip verilator_bin*
-	strip verilator_coverage_bin*
+	strip bin/verilator_bin*
+	strip bin/verilator_coverage_bin*
 	$(MAKE) install-project-quick
 	for p in $(VL_INST_MAN_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \
@@ -380,8 +389,8 @@ endif

 install-cadtools: dist
 	@echo "Install-project to $(CAD_DIR)"
-	strip verilator_bin*
-	strip verilator_coverage_bin*
+	strip bin/verilator_bin*
+	strip bin/verilator_coverage_bin*
 	$(MAKE) install-cadtools-quick
 	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/man/man1
 	for p in $(VL_INST_MAN_FILES) ; do \
@@ -419,12 +428,23 @@ CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src

 cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 $(CPPCHECK_INC) $<
+	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $<
+
+analyzer-src:
+	-rm -rf src/obj_dbg
+	scan-build $(MAKE) -k verilator_coverage_bin_dbg verilator_bin_dbg
+
+analyzer-include:
+	-rm -rf examples/*/obj*
+	scan-build $(MAKE) -k examples

 ftp: info

 install-msg:
-	@echo "Installed!"
+	@echo
+	@echo "Installed binaries to $(DESTDIR)$(bindir)/verilator"
+	@echo "Installed man to $(DESTDIR)$(mandir)/man1"
+	@echo "Installed examples to $(DESTDIR)$(pkgdatadir)/examples"
 	@echo
 	@echo "For documentation see 'man verilator' or 'verilator --help'"
 	@echo "For forums and to report bugs see http://www.veripool.org/verilator"
@@ -452,7 +472,7 @@ endif
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
 	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* $(INFOS) configure
+	rm -f *.info* *.1 $(INFOS) configure

 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
@@ -466,10 +486,13 @@ clean mostlyclean distclean maintainer-clean::
 	rm -f *.pg *.pgs *.toc *.tp *.tps *.vr *.vrs *.idx
 	rm -f *.ev *.evs *.ov *.ovs *.cv *.cvs *.ma *.mas
 	rm -f *.tex
+	rm -rf test_*/obj_dir
+	rm -rf examples/*/obj_dir examples/*/logs

 distclean maintainer-clean::
 	rm -f Makefile config.status config.cache config.log TAGS
 	rm -f verilator_bin* verilator_coverage_bin*
+	rm -f bin/verilator_bin* bin/verilator_coverage_bin*
 	rm -f include/verilated.mk include/verilated_config.h

 TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
@@ -491,6 +514,9 @@ dist-file-list:
 	@echo $(wildcard $(DISTFILES))
 	@echo "end-dist-file-list:";  # Scripts look for this

+print-cfg-with-threaded:
+	@echo $(CFG_WITH_THREADED)
+
 ######################################################################
 # Distributions

@@ -51,7 +51,7 @@ output (not Verilator itself) compiles under MSVC++ 2008 and newer.

 =head1 INSTALLATION

-For more details see 
+For more details see
 L<http://www.veripool.org/projects/verilator/wiki/Installing>.

 If you will be modifying Verilator, you should use the "git" method as it
@@ -169,6 +169,9 @@ have the verilator binary directory in your PATH (this should already be
 true if using the default configure), and make sure VERILATOR_ROOT is not
 set.

+You may now wish to consult the examples directory. Type C<make> inside any
+example directory to run the example.
+
 =back

 =head1 USAGE DOCUMENTATION
@@ -190,10 +193,10 @@ The directories in the kit after de-taring are as follows:
    include/verilated.v         => Stub defines for linting
    include/verilated.mk        => Common makefile
    src/                        => Translator source code
-    test_v                      => Example Verilog code for other test dirs
-    test_c                      => Example Verilog->C++ conversion
-    test_sc                     => Example Verilog->SystemC conversion
-    test_verilated              => Internal tests
+    examples/hello_world_c      => Example simple Verilog->C++ conversion
+    examples/hello_world_sc     => Example simple Verilog->SystemC conversion
+    examples/tracing_c          => Example Verilog->C++ with tracing
+    examples/tracing_sc         => Example Verilog->SystemC with tracing
    test_regress                => Internal tests

 =head1 LIMITATIONS
@@ -41,7 +41,7 @@ Testing:
 	* // verilator debug in code so can see only tree affecting those nodes

 Usability:
-	* Detect and pre-remove most UNOPTFLATs (4.000) 
+	* Detect and pre-remove most UNOPTFLATs (4.000)
 	* Better reporting of unopt problems, including what lines of code
 	* Report more errors (all of them?) before exiting [Eugene Weber]
 	* Auto-create scons config files
@@ -182,7 +182,9 @@ sub run {
            warn "%Error: $command\n";
        }
        if ($status & 127) {
-            if (($status & 127) == 8 || ($status & 127) == 11) { # SIGFPA or SIGSEGV
+            if (($status & 127) == 4 # SIGILL
+                || ($status & 127) == 8 # SIGFPA
+                || ($status & 127) == 11) { # SIGSEGV
                warn "%Error: Verilator internal fault, sorry.  Consider trying --debug --gdbbt\n" if !$Debug;
            } elsif (($status & 127) == 6) {  # SIGABRT
                warn "%Error: Verilator aborted.  Consider trying --debug --gdbbt\n" if !$Debug;
@@ -280,9 +282,11 @@ descriptions in the next sections for more information.
    --exe                       Link to create executable
     -F <file>                  Parse options from a file, relatively
     -f <file>                  Parse options from a file
+     -FI <file>                 Force include of a file
     -G<name>=<value>           Overwrite toplevel parameter
    --gdb                       Run Verilator under GDB interactively
    --gdbbt                     Run Verilator under GDB for backtrace
+    --getenv <var>              Get environment variable with defaults
    --help                      Display this help
     -I<dir>                    Directory to search for includes
    --if-depth <value>          Tune IFDEPTH warning
@@ -323,6 +327,8 @@ descriptions in the next sections for more information.
    --private                   Debugging; see docs
    --public                    Debugging; see docs
     -pvalue+<name>=<value>     Overwrite toplevel parameter
+    --relative-includes         Resolve includes relative to current file
+    --no-relative-cfuncs        Disallow 'this->' in generated functions
    --report-unoptflat          Extra diagnostics for UNOPTFLAT
    --savable                   Enable model save-restore
    --sc                        Create SystemC output
@@ -347,13 +353,15 @@ descriptions in the next sections for more information.
     +verilog1995ext+<ext>      Synonym for +1364-1995ext+<ext>
     +verilog2001ext+<ext>      Synonym for +1364-2001ext+<ext>
    --vpi                       Enable VPI compiles
-     -Werror-<message>          Convert warning to error
+     -Wall                      Enable all style warnings
+     -Werror-<message>          Convert warnings to errors
     -Wfuture-<message>         Disable unknown message warnings
     -Wno-<message>             Disable warning
     -Wno-lint                  Disable all lint warnings
     -Wno-style                 Disable all style warnings
     -Wno-fatal                 Disable fatal exit on warnings
-    --x-assign <mode>           Initially assign Xs to this value
+    --x-assign <mode>           Assign non-initial Xs to this value
+    --x-initial <mode>          Assign initial Xs to this value
    --x-initial-edge            Enable initial X->0 and X->1 edge triggers
     -y <dir>                   Directory to search for modules

@@ -423,9 +431,6 @@ C<+1364-1995ext+> etc. specify both the syntax I<and> semantics to be used.

 Enable all assertions.

-See also --x-assign and --x-initial-edge; setting "--x-assign unique"
-and/or "--x-initial-edge" may be desirable.
-
 =item --autoflush

 After every $display or $fdisplay, flush the output stream.  This insures
@@ -481,7 +486,7 @@ interest in adding more traditional CDC checks, please contact the authors.
 Sometimes it is quite difficult for Verilator to distinguish clock signals from
 other data signals. Occasionally the clock signals can end up in the checking
 list of signals which determines if further evaluation is needed. This will
-heavily degrade the performance of verilated model.
+heavily degrade the performance of a Verilated model.

 With --clk <signal-name>, user can specified root clock into the model, then
 Verilator will mark the signal as clocker and propagate the clocker attribute
@@ -493,6 +498,10 @@ If the signal is the input to top-module, the directly the signal name. If you
 find it difficult to find the exact name, try to use C</*verilator clocker*/> in
 RTL file to mark the signal directly.

+If clock signals are assigned to vectors and then later used individually,
+Verilator will attempt to decompose the vector and connect the single-bit
+clock signals directly.  This should be transparent to the user.
+
 =item --compiler I<compiler-name>

 Enables tunings and workarounds for the specified C++ compiler.
@@ -507,7 +516,7 @@ breaking deep structures as for msvc as described below.

 =item gcc

-Tune for Gnu C++, although generated code should work on almost any
+Tune for GNU C++, although generated code should work on almost any
 compliant C++ compiler.  Currently the default.

 =item msvc
@@ -538,7 +547,7 @@ Coverage analysis adds statements at each code flow change point, which are
 the branches of IF and CASE statements, a super-set of normal Verilog Line
 Coverage.  At each such branch a unique counter is incremented.  At the end
 of a test, the counters along with the filename and line number
-corresponding to each counter are written into logs/coverage.pl.
+corresponding to each counter are written into logs/coverage.dat.

 Verilator automatically disables coverage of branches that have a $stop in
 them, as it is assumed $stop branches contain an error check that should
@@ -704,6 +713,14 @@ The file may contain // comments which are ignored to the end of the line.
 Any $VAR, $(VAR), or ${VAR} will be replaced with the specified environment
 variable.

+=item -FI <file>
+
+Force include of the specified C++ header file.  All generated C++ files
+will insert a #include of the specified file before any other includes. The
+specified file might be used to contain define prototypes of custom
+VL_VPRINTF functions, and may need to include verilatedos.h as this file is
+included before any other standard includes.
+
 =item -GI<name>=I<value>

 Overwrites the given parameter of the toplevel module. The value is limited
@@ -745,6 +762,14 @@ backtrace on exit, then exit GDB immediately.  Without --debug or if GDB
 doesn't seem to work, this flag is ignored.  Intended for easy creation of
 backtraces by users; otherwise see the --gdb flag.

+=item --getenv I<variable>
+
+If the variable is declared in the environment, print it and exit
+immediately. Otherwise, if it's built into Verilator (e.g. VERILATOR_ROOT),
+print that and exit immediately. Otherwise, print a newline and exit
+immediately. This can be useful in makefiles. See also -V, and the various
+*.mk files.
+
 =item --help

 Displays this message and program version and exits.
@@ -856,6 +881,22 @@ change the ultimate model's performance, but may in some cases.

 Backward compatible alias for "--pins-bv 33".

+=item --no-relative-cfuncs
+
+Disable 'this->' references in generated functions, and instead Verilator
+will generate absolute references starting from 'vlTOPp->'.  This prevents
+V3Combine from merging functions from multiple instances of the same
+module, so it can grow the instruction stream.
+
+This is a work around for old compilers. Don't set this if your C++
+compiler supports __restrict__ properly, as GCC 4.5.x and newer do.  For
+older compilers, test if this switch gives you better performance or not.
+
+Compilers which don't honor __restrict__ will suspect that 'this->'
+references and 'vlTOPp->' references may alias, and may write slow code
+with extra loads and stores to handle the (imaginary) aliasing. Using only
+'vlTOPp->' references allows these old compilers to produce tight code.
+
 =item --no-skip-identical

 Rarely needed.  Disables skipping execution of Verilator if all source
@@ -897,7 +938,7 @@ developers.

 =item --output-split I<bytes>

-Enables splitting the output .cpp/.sp files into multiple outputs.  When a
+Enables splitting the output .cpp files into multiple outputs.  When a
 C++ file exceeds the specified number of operations, a new file will be
 created at the next function boundary.  In addition, any slow routines will
 be placed into __Slow files.  This accelerates compilation by as
@@ -909,7 +950,7 @@ one-minute-compile chunks.

 =item --output-split-cfuncs I<statements>

-Enables splitting functions in the output .cpp/.sp files into multiple
+Enables splitting functions in the output .cpp files into multiple
 functions.  When a generated function exceeds the specified number of
 operations, a new function will be created.  With --output-split, this will
 enable GCC to compile faster, at a small loss in performance that gets
@@ -919,7 +960,7 @@ function.

 =item --output-split-ctrace I<statements>

-Enables splitting trace functions in the output .cpp/.sp files into
+Enables splitting trace functions in the output .cpp files into
 multiple functions.  Defaults to same setting as --output-split-cfuncs.

 =item -P
@@ -1014,6 +1055,12 @@ inlining.  This will also turn off inlining as if all modules had a
 Overwrites the given parameter(s) of the toplevel module. See -G for a
 detailed description.

+=item --relative-includes
+
+When a file references an include file, resolve the filename relative to
+the path of the referencing file, instead of relative to the current
+directory.
+
 =item --report-unoptflat

 Extra diagnostics for UNOPTFLAT warnings. This includes for each loop, the
@@ -1158,7 +1205,7 @@ Setting it to "" disables matching.
 =item -V

 Shows the verbose version, including configuration information compiled
-into Verilator.  (Similar to perl -V.)
+into Verilator.  (Similar to perl -V.)  See also --getenv.

 =item -v I<filename>

@@ -1178,8 +1225,9 @@ Enable use of VPI and linking against the verilated_vpi.cpp files.

 =item -Wall

-Enable all warnings, including code style warnings that are normally
-disabled by default.
+Enable all code style warnings, including code style warnings that are
+normally disabled by default. Equivelent to "-Wwarn-lint -Wwarn-style".
+Excludes some specialty warnings, i.e. IMPERFECTSCH.

 =item -Werror-I<message>

@@ -1203,11 +1251,11 @@ directives in the source, i.e. the warning will still not be printed.
 =item -Wno-lint

 Disable all lint related warning messages, and all style warnings.  This is
-equivalent to "-Wno-ALWCOMBORDER -Wno-CASEINCOMPLETE -Wno-CASEOVERLAP
-Wno-CASEX -Wno-CASEWITHX -Wno-CMPCONST -Wno-ENDLABEL -Wno-IMPLICIT
-Wno-LITENDIAN -Wno-PINCONNECTEMPTY -Wno-PINMISSING -Wno-SYNCASYNCNET
-Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED -Wno-WIDTH" plus the list shown for
-Wno-style.
+equivalent to "-Wno-ALWCOMBORDER -Wno-BSSPACE -Wno-CASEINCOMPLETE
+-Wno-CASEOVERLAP -Wno-CASEX -Wno-CASEWITHX -Wno-CMPCONST -Wno-COLONPLUS
+-Wno-ENDLABEL -Wno-IMPLICIT -Wno-LITENDIAN -Wno-PINCONNECTEMPTY
+-Wno-PINMISSING -Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED
+-Wno-WIDTH" plus the list shown for Wno-style.

 It is strongly recommended you cleanup your code rather than using this
 option, it is only intended to be use when running test-cases of code
@@ -1236,10 +1284,10 @@ Enables the specified warning message.

 Enable all lint related warning messages (note by default they are already
 enabled), but do not affect style messages.  This is equivalent to
-"-Wwarn-ALWCOMBORDER -Wwarn-CASEINCOMPLETE -Wwarn-CASEOVERLAP -Wwarn-CASEX
-Wwarn-CASEWITHX -Wwarn-CMPCONST -Wwarn-ENDLABEL -Wwarn-IMPLICIT
-Wwarn-LITENDIAN -Wwarn-PINMISSING -Wwarn-REALCVT -Wwarn-UNSIGNED
-Wwarn-WIDTH".
+"-Wwarn-ALWCOMBORDER -Wwarn-BSSPACE -Wwarn-CASEINCOMPLETE
+-Wwarn-CASEOVERLAP -Wwarn-CASEX -Wwarn-CASEWITHX -Wwarn-CMPCONST
+-Wwarn-COLONPLUS -Wwarn-ENDLABEL -Wwarn-IMPLICIT -Wwarn-LITENDIAN
+-Wwarn-PINMISSING -Wwarn-REALCVT -Wwarn-UNSIGNED -Wwarn-WIDTH".

 =item -Wwarn-style

@@ -1274,7 +1322,30 @@ enable rerunning with that same seed so you can reproduce bugs.
 B<Note.> This option applies only to variables which are explicitly assigned
 to X in the Verilog source code. Initial values of clocks are set to 0 unless
 --x-initial-edge is specified. Initial values of all other state holding
-variables are set as though --x-assign unique had been specified.
+variables are controlled with --x-initial.
+
+=item --x-initial 0
+
+=item --x-initial fast
+
+=item --x-initial unique (default)
+
+Controls the two-state value that is used to initialize variables that are
+not otherwise initialized.
+
+--x-initial=0, initializes all otherwise uninitialized variables to zero.
+
+--x-initial=unique, the default, initializes variables using a function,
+which determines the value to use each initialization. This gives greatest
+flexibility and allows finding reset bugs.  See L</"Unknown states">
+
+--x-initial=fast, is best for performance, and initializes all variables to
+a state Verilator determines is optimal.  This may allow further code
+optimizations, but will likely hide any code bugs relating to missing
+resets.
+
+B<Note.> This option applies only to initial values of variables. Initial
+values of clocks are set to 0 unless --x-initial-edge is specified.

 =item --x-initial-edge

@@ -1336,7 +1407,7 @@ We'll compile this example into C++.
    cat <<EOF >sim_main.cpp
      #include "Vour.h"
      #include "verilated.h"
-      int main(int argc, char **argv, char **env) {
+      int main(int argc, char** argv, char** env) {
          Verilated::commandArgs(argc, argv);
          Vour* top = new Vour;
          while (!Verilated::gotFinish()) { top->eval(); }
@@ -1385,8 +1456,8 @@ And we get as output

 Really, you're better off writing a Makefile to do all this for you.  Then,
 when your source changes it will automatically run all of these steps; to
-aid this Verilator can create a makefile dependency file.  See the test_c
-directory in the distribution for an example.
+aid this Verilator can create a makefile dependency file.  See the examples
+directory in the distribution.


 =head1 EXAMPLE SYSTEMC EXECUTION
@@ -1410,8 +1481,8 @@ This is an example similar to the above, but using SystemC.
          Verilated::commandArgs(argc, argv);
          sc_clock clk ("clk",10, 0.5, 3, true);
          Vour* top;
-          top = new Vour("top");   // SP_CELL (top, Vour);
-          top->clk(clk);           // SP_PIN  (top, clk, clk);
+          top = new Vour("top");
+          top->clk(clk);
          while (!Verilated::gotFinish()) { sc_start(1, SC_NS); }
          delete top;
          exit(0);
@@ -1463,15 +1534,16 @@ And we get the same output as the C++ example:

 Really, you're better off using a Makefile to do all this for you.  Then,
 when your source changes it will automatically run all of these steps.  See
-the test_sc directory in the distribution for an example.
+the examples directory in the distribution.


 =head1 BENCHMARKING & OPTIMIZATION

 For best performance, run Verilator with the "-O3 --x-assign=fast
--noassert" flags.  The -O3 flag will require longer compile times, and
--x-assign=fast may increase the risk of reset bugs in trade for
-performance; see the above documentation for these flags.
+--x-initial=fast --noassert" flags.  The -O3 flag will require longer
+compile times, and --x-assign=fast --x-initial=fast may increase the risk
+of reset bugs in trade for performance; see the above documentation for
+these flags.

 Minor Verilog code changes can also give big wins.  You should not have any
 UNOPTFLAT warnings from Verilator.  Fixing these warnings can result in
@@ -1490,7 +1562,7 @@ OPT, OPT_FAST, or OPT_SLOW lib/verilated.mk.  Or, use the -CFLAGS and/or
 the compiler or linker.  Or, just for one run, pass them on the command
 line to make:

-    make OPT_FAST="-O2" -f Vour.mk Vour__ALL.a
+    make OPT_FAST="-O2 -fno-stack-protector" -f Vour.mk Vour__ALL.a

 OPT_FAST specifies optimizations for those programs that are part of the
 fast path, mostly code that is executed every cycle.  OPT_SLOW specifies
@@ -1662,7 +1734,7 @@ Verilator RPM as the hardcoded value should be correct.
 =head1 CONNECTING TO C++

 Verilator creates a .h and .cpp file for the top level module and all
-modules under it.  See the test_c directory in the kit for an example.
+modules under it.  See the examples directory in the kit for examples.

 After the modules are completed, there will be a I<module>.mk file that may
 be used with Make to produce a I<module>__ALL.a file with all required
@@ -1897,54 +1969,71 @@ documented below.
 Verilator has an important difference from an event based simulator; signal
 values that are changed by the VPI will not immediately propagate their
 values, instead the top level header file's eval() method must be called.
-Normally this would be part of the normal evaluation (IE the next clock
+Normally this would be part of the normal evaluation (i.e. the next clock
 edge), not as part of the value change.  This makes the performance of VPI
 routines extremely fast compared to event based simulators, but can confuse
 some test-benches that expect immediate propagation.

-Note the VPI by it's specified implementation will always be much slower
+Note the VPI by its specified implementation will always be much slower
 than accessing the Verilator values by direct reference
 (structure->module->signame), as the VPI accessors perform lookup in
 functions at runtime requiring at best hundreds of instructions, while the
 direct references are evaluated by the compiler and result in only a couple
 of instructions.

+For signal callbacks to work the main loop of the program must call
+VerilatedVpi::callValueCbs().
+
 =head2 VPI Example

 In the below example, we have readme marked read-only, and writeme which if
 written from outside the model will have the same semantics as if it
 changed on the specified clock edge.

-    module t;
-       reg readme   /*verilator public_flat_rd*/;
-       reg writeme  /*verilator public_flat_rw @(posedge clk) */;
-    endmodule
+    cat <<EOF >our.v
+      module our (input clk);
+         reg readme   /*verilator public_flat_rd*/;
+         reg writeme  /*verilator public_flat_rw @(posedge clk) */;
+         initial $finish;
+      endmodule
+    EOF

 There are many online tutorials and books on the VPI, but an example that
-accesses the above would be:
+accesses the above signal "readme" would be:

-    void read_and_check() {
-        vpiHandle vh1 = vpi_handle_by_name((PLI_BYTE8*)"t.readme", NULL);
-        if (!vh1) { error... }
-        const char* name = vpi_get_str(vpiName, vh1);
-        printf("Module name: %s\n");  // Prints "readme"
+    cat <<EOF >sim_main.cpp
+      #include "Vour.h"
+      #include "verilated.h"
+      #include "verilated_vpi.h"  // Required to get definitions

-        s_vpi_value v;
-        v.format = vpiIntVal;
-        vpi_get_value(vh1, &v);
-        printf("Value of v: %d\n", v.value.integer);  // Prints "readme"
-    }
+      vluint64_t main_time = 0;   // See comments in first example
+      double sc_time_stamp () { return main_time; }

-For signal callbacks to work the main loop of the program must call
-VerilatedVpi::callValueCbs().
+      void read_and_check() {
+          vpiHandle vh1 = vpi_handle_by_name((PLI_BYTE8*)"TOP.our.readme", NULL);
+          if (!vh1) { vl_fatal(__FILE__, __LINE__, "sim_main", "No handle found"); }
+          const char* name = vpi_get_str(vpiName, vh1);
+          printf("Module name: %s\n", name);  // Prints "readme"

-    #include "verilated_vpi.h"  // Required to get definitions
-    ...
-    while (time passes) {
-        ...
-        topp->eval();
-        VerilatedVpi::callValueCbs();
-    }
+          s_vpi_value v;
+          v.format = vpiIntVal;
+          vpi_get_value(vh1, &v);
+          printf("Value of v: %d\n", v.value.integer);  // Prints "readme"
+      }
+
+      int main(int argc, char** argv, char** env) {
+          Verilated::commandArgs(argc, argv);
+          Vour* top = new Vour;
+          Verilated::internalsDump();  // See scopes to help debug
+          while (!Verilated::gotFinish()) {
+              top->eval();
+              VerilatedVpi::callValueCbs();  // For signal callbacks
+              read_and_check();
+          }
+          delete top;
+          exit(0);
+      }
+    EOF


 =head1 CROSS COMPILATION
@@ -2260,7 +2349,7 @@ Verilator configuration commands.

 Switch back to processing Verilog code after a `systemc_... mode switch.
 The Verilog code returns to the last language mode specified with
-`begin_keywords, or SystemVerilog if none were specified.
+`begin_keywords, or SystemVerilog if none was specified.

 =item /*verilator clock_enable*/

@@ -2377,6 +2466,13 @@ lint_restore*/.  For example:
 If SOME_WARNING was on before the lint_off, it will now be restored to on,
 and if it was off before the lint_off it will remain off.

+=item /*verilator no_inline_module*/
+
+Specifies the module the comment appears in should not be inlined into any
+modules that use this module.  This is useful especially at the top level
+module to reduce the size of the interface class, to aid compile time at a
+small performance loss.
+
 =item /*verilator no_inline_task*/

 Used in a function or task variable definition section to specify the
@@ -2385,6 +2481,14 @@ reduce the size of the final executable when a task is used a very large
 number of times.  For this flag to work, the task and tasks below it must
 be pure; they cannot reference any variables outside the task itself.

+=item /*verilator public*/ (parameter)
+
+Used after a parameter declaration to indicate the emitted C code should
+have the parameter values visible. Due to C++ language restrictions, this
+may only be used on 64-bit or narrower integral enumerations.
+
+    parameter [2:0] PARAM /*verilator public*/ = 2'b0;
+
 =item /*verilator public*/ (typedef enum)

 Used after an enum typedef declaration to indicate the emitted C code
@@ -2477,6 +2581,12 @@ indicate the function or task should pass all remaining arguments through
 $sformatf.  This allows creation of DPI functions with $display like
 behavior.  See the test_regress/t/t_dpi_display.v file for an example.

+=item /*verilator tag <text...>*/
+
+Attached after a variable or structure member to indicate opaque (to
+Verilator) text that should be passed through to the XML output as a tag,
+for use by downstream applications.
+
 =item /*verilator tracing_off*/

 Disable waveform tracing for all future signals that are declared in this
@@ -2518,6 +2628,14 @@ always @* to reduce missing activity items.  Avoid putting $displays in
 combo blocks, as they may print multiple times when not desired, even on
 compliant simulators as event ordering is not specified.

+=head2 Signal Naming
+
+To avoid conflicts with C symbol naming, any character in a signal name
+that is not alphanumeric nor a single underscore will be replaced by __0hh
+where hh is the hex code of the character. To avoid conflicts with
+Verilator's internal symbols, any double underscore are replaced with
+___05F (5F is the hex code of an underscore.)
+
 =head2 Bind

 Verilator only supports "bind" to a target module name, not an instance
@@ -2581,24 +2699,25 @@ value (see the --x-assign switch.)  Thus if the value is actually used, the
 random value should cause downstream errors.  Integers also randomize, even
 though the Verilog 2001 specification says they initialize to zero.

-All variables are randomly initialized using a function.  By running
-several random simulation runs you can determine that reset is working
-correctly.  On the first run, the function initializes variables to zero.
-On the second, have it initialize variables to one.  On the third and
-following runs have it initialize them randomly.  If the results match,
-reset works.  (Note this is what the hardware will really do.)  In
-practice, just setting all variables to one at startup finds most problems.
+All variables, depending on --x-initial setting, are typically randomly
+initialized using a function.  By running several random simulation runs
+you can determine that reset is working correctly.  On the first run, the
+function initializes variables to zero.  On the second, have it initialize
+variables to one.  On the third and following runs have it initialize them
+randomly.  If the results match, reset works.  (Note this is what the
+hardware will really do.)  In practice, just setting all variables to one
+at startup finds most problems (since typically control signals are
+active-high).

-B<Note.> --x-assign applies to variables explicitly initialized or assigned to
-X. Uninitialized clocks are initialized to zero, while all other state holding
-variables are initialized to a random value.
-
-Event driven simulators will generally trigger an edge on a transition from X
-to 1 (C<posedge>) or X to 0 (C<negedge>). However, by default, since clocks
-are initialized to zero, Verilator will not trigger an initial negedge. Some
-code (particularly for reset) may rely on X->0 triggering an edge. Verilator
-provides a switch (see --x-initial-edge) to enable this behavior. Comparing
-runs with and without this switch will find such problems.
+--x-assign applies to variables explicitly initialized or assigned to
+X. Uninitialized clocks are initialized to zero, while all other state
+holding variables are initialized to a random value.  Event driven
+simulators will generally trigger an edge on a transition from X to 1
+(C<posedge>) or X to 0 (C<negedge>). However, by default, since clocks are
+initialized to zero, Verilator will not trigger an initial negedge. Some
+code (particularly for reset) may rely on X->0 triggering an edge. The
+--x-initial-edge switch enables this behavior. Comparing runs with and
+without this switch will find such problems.


 =head2 Tri/Inout
@@ -2922,13 +3041,12 @@ Simply use a different register for the flop:
      always @* foo[0] = foo_flopped[0];
      always @* foo[1] = ...

-This is good coding practice anyways.
-
 It is also possible to disable this error when one of the assignments is
 inside a public task.

-Ignoring this warning may make Verilator simulations differ from other
-simulators.
+This is not illegal in SystemVerilog, but a violation of good coding
+practice. Verilator reports this as an error, because ignoring this warning
+may make Verilator simulations differ from other simulators.

 =item BLKSEQ

@@ -2963,6 +3081,17 @@ generally unrolls small loops.  You may want to try increasing
 --unroll-count (and occasionally --unroll-stmts) which will raise the small
 loop bar to avoid this error.

+=item BSSPACE
+
+Warns that a backslash is followed by a space then a newline. Likely the
+intent was to have a backslash directly followed by a newline (e.g. when
+making a `define) and there's accidentally whitespace at the end of the
+line.  If the space is not accidental, suggest removing the backslash in
+the code as it serves no function.
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
 =item CASEINCOMPLETE

 Warns that inside a case statement there is a stimulus pattern for which
@@ -3002,6 +3131,15 @@ instead intended is to use a casez with C<?>.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.

+=item COLONPLUS
+
+Warns that a :+ is seen. Likely the intent was to use +: to select a range
+of bits. If the intent was a range that is explicitly positive, suggest
+adding a space, e.g. use ": +".
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
 =item CDCRSTLOGIC

 With --cdc only, warns that asynchronous flop reset terms come from other
@@ -3102,8 +3240,8 @@ correctly.

 Warns that the scheduling of the model is not absolutely perfect, and some
 manual code edits may result in faster performance.  This warning defaults
-to off, and must be turned on explicitly before the top module statement is
-processed.
+to off, is not part of -Wall, and must be turned on explicitly before the
+top module statement is processed.

 =item IMPLICIT

@@ -3153,6 +3291,11 @@ Warns that a packed vector is declared with little endian bit numbering
 and little numbering is now thus often due to simple oversight instead of
 intent.

+Also warns that a cell is declared with little endian range (i.e. [0:7] or
+[7]) and is connected to a N-wide signal. Based on IEEE the bits will
+likely be backwards from what you expect (i.e. cell [0] will connect to
+signal bit [N-1] not bit [0]).
+
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.

@@ -3528,24 +3671,24 @@ program above:

 =item Does it run under Windows?

-Yes, using Cygwin.  Verilated output should also compile under Microsoft
-Visual C++ Version 7 or newer, but this is not tested by the author.
+Yes, using Cygwin.  Verilated output also compiles under Microsoft Visual
+C++ Version 7 or newer, but this is not tested every release.

 =item Can you provide binaries?

-Verilator is available as a RPM for SuSE, Fedora, and perhaps other
-systems; this is done by porters and may slightly lag the primary
-distribution.  If there isn't a binary build for your distribution, how
-about you set one up?  Please contact the authors for assistance.
+Verilator is available as a RPM for Debian/Ubuntu, SuSE, Fedora, and
+perhaps other systems; this is done by porters and may slightly lag the
+primary distribution.  If there isn't a binary build for your distribution,
+how about you set one up?  Please contact the authors for assistance.

 Note people sometimes request binaries when they are having problems with
 their C++ compiler. Alas, binaries won't help this, as in the end a fully
 working C++ compiler is required to compile the output of Verilator.

-=item How can it be faster than (name-the-simulator)?
+=item How can it be faster than (name-the-commercial-simulator)?

-Generally, the implied part of the question is "... with all of their
-manpower they can put into it."
+Generally, the implied part is of the question is "... with all of the
+manpower they can put into developing it."

 Most commercial simulators have to be Verilog compliant, meaning event
 driven.  This prevents them from being able to reorder blocks and make
@@ -3578,17 +3721,18 @@ source code available.
 As is standard with Open Source, contributions back to Verilator will be
 placed under the Verilator copyright and LGPL/Artistic license.  Small test
 cases will be released into the public domain so they can be used anywhere,
-large tests under the LGPL/Artistic, unless requested otherwise.
+and large tests under the LGPL/Artistic, unless requested otherwise.

 =item Why is Verilation so slow?

 Verilator needs more memory than the resulting simulator will require, as
-Verilator creates internally all of the state of the resulting simulator in
-order to optimize it.  If it takes more than a minute or so (and you're not
-using --debug since debug is disk bound), see if your machine is paging;
-most likely you need to run it on a machine with more memory.  Verilator is
-a full 64-bit application and may use more than 4GB, but about 1GB is the
-maximum typically needed.
+Verilator creates internally all of the state of the resulting generated
+simulator in order to optimize it.  If it takes more than a minute or so
+(and you're not using --debug since debug is disk bound), see if your
+machine is paging; most likely you need to run it on a machine with more
+memory.  Verilator is a full 64-bit application and may use more than 4GB,
+but about 1GB is the maximum typically needed, and very large commercial
+designs have topped 16GB.

 =item How do I generate waveforms (traces) in C++?

@@ -3598,7 +3742,7 @@ Add the --trace switch to Verilator, and in your top level C code, call
 Verilated::traceEverOn(true).  Then create a VerilatedVcdC object, and
 in your main loop call "trace_object->dump(time)" every time step, and
 finally call "trace_object->close()".  For an example, see below and the
-test_c/sim_main.cpp file of the distribution.
+examples/tracing_c/sim_main.cpp file of the distribution.

 You also need to compile verilated_vcd_c.cpp and add it to your link,
 preferably by adding the dependencies in $(VK_GLOBAL_OBJS) to your
@@ -3610,7 +3754,7 @@ trace file if you want all data to land in the same output file.

    #include "verilated_vcd_c.h"
    ...
-    int main(int argc, char **argv, char **env) {
+    int main(int argc, char** argv, char** env) {
        ...
        Verilated::traceEverOn(true);
        VerilatedVcdC* tfp = new VerilatedVcdC;
@@ -3630,7 +3774,7 @@ Add the --trace switch to Verilator, and in your top level C sc_main code,
 include verilated_vcd_sc.h.  Then call Verilated::traceEverOn(true).  Then
 create a VerilatedVcdSc object as you would create a normal SystemC trace
 file.  For an example, see the call to VerilatedVcdSc in the
-test_sc/sc_main.cpp file of the distribution, and below.
+examples/tracing_sc/sc_main.cpp file of the distribution, and below.

 Alternatively you may use the C++ trace mechanism described in the previous
 question, however the timescale and timeprecision will not inherited from
@@ -3646,7 +3790,7 @@ trace file if you want all data to land in the same output file.

    #include "verilated_vcd_sc.h"
    ...
-    int main(int argc, char **argv, char **env) {
+    int main(int argc, char** argv, char** env) {
        ...
        Verilated::traceEverOn(true);
        VerilatedVcdSc* tfp = new VerilatedVcdSc;
@@ -3661,8 +3805,8 @@ trace file if you want all data to land in the same output file.
 =item How do I view waveforms (traces)?

 Verilator makes standard VCD (Value Change Dump) files.  They are viewable
-with the public domain Dinotrace or GtkWave programs, or any of the many
-commercial offerings.
+with the public domain GtkWave (recommended) or Dinotrace (legacy)
+programs, or any of the many commercial offerings.

 =item How do I reduce the size of large waveform (trace) files?

@@ -3676,8 +3820,8 @@ want to trace (such as perhaps library cells).  Finally, use the
 --trace-depth option to limit the depth of tracing, for example
 --trace-depth 1 to see only the top level signals.

-Also be sure you write your trace files to a local disk, instead of to a
-network disk.  Network disks are generally far slower.
+Also be sure you write your trace files to a local solid-state disk,
+instead of to a network disk.  Network disks are generally far slower.

 =item How do I do coverage analysis?

@@ -3692,14 +3836,14 @@ At the end of your test, call VerilatedCov::write passing the name of the
 coverage data file (typically "logs/coverage.dat").

 Run each of your tests in different directories.  Each test will create a
-logs/coverage.pl file.
+logs/coverage.dat file.

 After running all of your tests, verilator_coverage is executed.
-Verilator_coverage reads the logs/coverage.pl file(s), and creates an
+Verilator_coverage reads the logs/coverage.dat file(s), and creates an
 annotated source code listing showing code coverage details.

 For an example, after running 'make test' in the Verilator distribution,
-see the test_sc/logs directory.  Grep for lines starting
+see the examples/tracing_c/logs directory.  Grep for lines starting
 with '%' to see what lines Verilator believes need more coverage.

 =item Where is the translate_off command?  (How do I ignore a construct?)
@@ -3713,6 +3857,8 @@ the "VERILATOR" define for you, so just wrap the code in an ifndef region:
      Something_Verilator_Dislikes;
   `endif

+Most synthesis tools similarly define SYNTHESIS for you.
+
 =item Why do I get "unexpected `do'" or "unexpected `bit'" errors?

 Do, bit, ref, return, and other words are now SystemVerilog keywords.  You
@@ -3749,7 +3895,7 @@ simulator knows the current time.  See the "CONNECTING TO C++" examples.
 You need to link your compiled Verilated code against the verilated.cpp
 file found in the include directory of the Verilator kit.  This is one
 target in the $(VK_GLOBAL_OBJS) make variable, which should be part of your
-Makefile's link rule.
+Makefile's link rule.  If you use --exe, this is done for you.

 =item Is the PLI supported?

@@ -3771,13 +3917,20 @@ test_regress/t/t_extend_class files show an example of how to do this.

 =item How do I get faster build times?

-Between GCC 3.0 to 3.3, each compiled progressively slower, thus if you can
-use GCC 2.95, or GCC 3.4 you'll have faster builds.  Two ways to cheat are
-to compile on parallel machines and avoid compilations altogether.  See the
--output-split option, and the web for the ccache, distcc and icecream
-packages. ccache will skip GCC runs between identical source builds, even
-across different users.  You can use the OBJCACHE environment variable to
-use these CC wrappers.
+Use a recent compiler.  Newer compilers tend do be faster, with the
+now relatively old GCC 3.0 to 3.3 being horrible.
+
+Compile in parallel on many machines and use caching; see the web for the
+ccache, distcc and icecream packages. ccache will skip GCC runs between
+identical source builds, even across different users.  You can use the
+OBJCACHE environment variable to use these CC wrappers. Also see the
+--output-split option.
+
+To reduce the compile time of classes that use a Verilated module (e.g. a
+top CPP file) you may wish to add /*verilator no_inline_module*/ to your
+top level module. This will decrease the amount of code in the model's
+Verilated class, improving compile times of any instantiating top level C++
+code, at a relatively small cost of execution performance.

 =item Why do so many files need to recompile when I add a signal?

@@ -3826,7 +3979,7 @@ From the sc_main.cpp file, you'd then:

    #include "Vour.h"
    #include "Vour_our.h"
-    cout << "clock is " << top->v->clk << endl;
+    cout << "clock is " << top->our->clk << endl;

 In this example, clk is a bool you can read or set as any other variable.
 The value of normal signals may be set, though clocks shouldn't be changed
@@ -3917,7 +4070,7 @@ License.)
 In 2001, Wilson Snyder took the kit, and added a SystemC mode, and
 called it Verilator2.  This was the first packaged public release.

-In 2002, Wilson Snyder created Verilator3 by rewriting Verilator from
+In 2002, Wilson Snyder created Verilator 3.000 by rewriting Verilator from
 scratch in C++.  This added many optimizations, yielding about a 2-5x
 performance gain.

@@ -3949,50 +4102,59 @@ Inc., picoChip Designs Ltd., Sun Microsystems Inc., Nauticus Networks Inc.,
 and SiCortex Inc.

 The people who have contributed major functionality are Byron Bradley,
-Jeremy Bennett, Jie Xu, Lane Brooks, Duane Galbi, Paul Wasson, and Wilson
-Snyder.  Major testers include Jeff Dutton, Jonathon Donaldson, Ralf Karge,
-David Hewson, Iztok Jeras, Wim Michiels, Alex Solomatnikov, Sebastien Van
-Cauwenberghe, Gene Weber, and Clifford Wolf.
+Jeremy Bennett, Jie Xu, Lane Brooks, John Coiner, Duane Galbi, Paul Wasson,
+and Wilson Snyder.  Major testers included Jeff Dutton, Jonathon Donaldson,
+Ralf Karge, David Hewson, Iztok Jeras, Wim Michiels, Alex Solomatnikov,
+Sebastien Van Cauwenberghe, Gene Weber, and Clifford Wolf.

 Some of the people who have provided ideas and feedback for Verilator
-include: Yves Mathieu, David Addison, Nikana Anastasiadis, Hans Van
-Antwerpen, Vasu Arasanipalai, Jens Arm, Sharad Bagri, Andrew Bardsley,
-Geoff Barrett, J Baxter, Julius Baxter, Jeremy Bennett, Michael Berman,
-David Binderman, David Black, Daniel Bone, Gregg Bouchard, Christopher
-Boumenot, Nick Bowler, Byron Bradley, Bryan Brady, Charlie Brej, Lane
-Brooks, John Brownlee, Jeff Bush, Lawrence Butcher, Ted Campbell, Chris
-Candler, Lauren Carlson, Donal Casey, Terry Chen, Robert A. Clark, Allan
-Cochrane, Gunter Dannoritzer, Ashutosh Das, Bernard Deadman, Mike Denio,
-John Deroo, Philip Derrick, John Dickol, R. Diez, Ruben Diez, Danny Ding,
-Ivan Djordjevic, Jonathon Donaldson, Alex Duller, Jeff Dutton, Chandan
-Egbert, Joe Eiler, Ahmed El-Mahmoudy, Robert Farrell, Eugen Fekete,
-Fabrizio Ferrandi, Andrea Foletto, Bob Fredieu, Christian Gelinek, Glen
-Gibb, Shankar Giri, Sam Gladstone, Amir Gonnen, Chitlesh Goorah, Neil
-Hamilton, Junji Hashimoto, Thomas Hawkins, David Hewson, Hiroki Honda, Alex
-Hornung, Jae Hossell, Ben Jackson, Krzysztof Jankowski, HyungKi Jeong,
-Iztok Jeras, James Johnson, Christophe Joly, Franck Jullien, Mike Kagen,
-Kaalia Kahn, Guy-Armand Kamendje, Vasu Kandadi, Patricio Kaplan, Ralf
-Karge, Dan Katz, Sol Katzman, Jonathan Kimmitt, Sobhan Klnv, Gernot Koch,
-Soon Koh, Steve Kolecki, Brett Koonce, Wojciech Koszek, Varun Koyyalagunta,
-David Kravitz, Roland Kruse, Ed Lander, Steve Lang, Stephane Laurent,
-Walter Lavino, Christian Leber, Igor Lesik, John Li, Eivind Liland, Charlie
-Lind, Andrew Ling, Paul Liu, Derek Lockhart, Arthur Low, Stefan Ludwig, Dan
-Lussier, Fred Ma, Duraid Madina, Mark Marshall, Jason McMullan, Wim
-Michiels, Wai Sum Mong, Sean Moore, Dennis Muhlestein, John Murphy, Richard
-Myers, Dimitris Nalbantis, Bob Newgard, Cong Van Nguyen, Paul Nitza, Pete
-Nixon, Lisa Noack, Mark Nodine, Andreas Olofsson, Brad Parker, David
-Pierce, Dominic Plunkett, David Poole, Rich Porter, Niranjan Prabhu, Usha
-Priyadharshini, Mark Jackson Pulver, Prateek Puri, Chris Randall, Frederic
-Requin, Alberto Del Rio, Oleg Rodionov, Jan Egil Ruud, John Sanguinetti,
-Salman Sheikh, Mike Shinkarovsky, Rafael Shirakawa, Jeffrey Short, Rodney
-Sinclair, Steven Slatter, Brian Small, Wilson Snyder, Alex Solomatnikov,
-Art Stamness, John Stevenson, Todd Strader, John Stroebel, Emerson
+include: Ahmed El-Mahmoudy, David Addison, Tariq B. Ahmad, Nikana
+Anastasiadis, Hans Van Antwerpen, Vasu Arasanipalai, Jens Arm, Sharad
+Bagri, Andrew Bardsley, Matthew Barr, Geoff Barrett, Julius Baxter, Jeremy
+Bennett, Michael Berman, David Binderman, Johan Bjork, David Black, Daniel
+Bone, Gregg Bouchard, Christopher Boumenot, Nick Bowler, Byron Bradley,
+Bryan Brady, Charlie Brej, J Briquet, Lane Brooks, John Brownlee, Jeff
+Bush, Lawrence Butcher, Ted Campbell, Chris Candler, Lauren Carlson, Donal
+Casey, Terry Chen, Enzo Chi, Robert A. Clark, Allan Cochrane, John Coiner,
+Gunter Dannoritzer, Ashutosh Das, Bernard Deadman, John Demme, Mike Denio,
+John Deroo, Philip Derrick, John Dickol, Ruben Diez, Danny Ding, Ivan
+Djordjevic, Jonathon Donaldson, Sebastian Dressler, Alex Duller, Jeff
+Dutton, Usuario Eda, Chandan Egbert, Joe Eiler, Ahmed El-Mahmoudy, Robert
+Farrell, Eugen Fekete, Fabrizio Ferrandi, Brian Flachs, Andrea Foletto, Bob
+Fredieu, Christian Gelinek, Glen Gibb, Shankar Giri, Dan Gisselquist, Sam
+Gladstone, Amir Gonnen, Chitlesh Goorah, Xuan Guo, Neil Hamilton, Jannis
+Harder, Junji Hashimoto, Thomas Hawkins, Robert Henry, David Hewson, Jamey
+Hicks, Hiroki Honda, Alex Hornung, David Horton, Jae Hossell, Alan Hunter,
+Jamie Iles, Ben Jackson, Shareef Jalloq, Krzysztof Jankowski, HyungKi
+Jeong, Iztok Jeras, James Johnson, Christophe Joly, Franck Jullien, Mike
+Kagen, Arthur Kahlich, Kaalia Kahn, Guy-Armand Kamendje, Vasu Kandadi,
+Patricio Kaplan, Ralf Karge, Dan Katz, Sol Katzman, Jonathan Kimmitt, Olof
+Kindgren, Sobhan Klnv, Gernot Koch, Soon Koh, Steve Kolecki, Brett Koonce,
+Wojciech Koszek, Varun Koyyalagunta, David Kravitz, Roland Kruse, Sergey
+Kvachonok, Ed Lander, Steve Lang, Stephane Laurent, Walter Lavino,
+Christian Leber, Igor Lesik, John Li, Eivind Liland, Charlie Lind, Andrew
+Ling, Paul Liu, Derek Lockhart, Arthur Low, Stefan Ludwig, Dan Lussier,
+Fred Ma, Duraid Madina, Mark Marshall, Alfonso Martinez, Yves Mathieu,
+Patrick Maupin, Jason McMullan, Elliot Mednick, Wim Michiels, Miodrag
+Milanovic, Wai Sum Mong, Sean Moore, Dennis Muhlestein, John Murphy,
+Richard Myers, Dimitris Nalbantis, Bob Newgard, Cong Van Nguyen, Paul
+Nitza, Pete Nixon, Lisa Noack, Mark Nodine, Andreas Olofsson, James
+Pallister, Brad Parker, Maciej Piechotka, David Pierce, Dominic Plunkett,
+David Poole, Mike Popoloski, Rich Porter, Niranjan Prabhu, Usha
+Priyadharshini, Mark Jackson Pulver, Prateek Puri, Chris Randall, Anton
+Rapp, Odd Magne Reitan, Frederic Requin, Alberto Del Rio, Oleg Rodionov,
+Paul Rolfe, Jan Egil Ruud, John Sanguinetti, Galen Seitz, Salman Sheikh,
+Mike Shinkarovsky, Rafael Shirakawa, Jeffrey Short, Rodney Sinclair, Steven
+Slatter, Brian Small, Alex Solomatnikov, Wei Song, Art Stamness, John
+Stevenson, Rob Stoddard, Todd Strader, John Stroebel, Sven Stucki, Emerson
 Suguimoto, Gene Sullivan, Renga Sundararajan, Yutetsu Takatsukasa, Peter
-Tengstrand, Stefan Thiede, Gary Thomas, Kevin Thompson, Mike Thyer, Steve
-Tong, Holger Waechtler, Stefan Wallentowitz, Shawn Wang, Greg Waters,
-Thomas Watts, Eugene Weber, David Welch, Leon Wildman, Gerald Williams,
-Trevor Williams, Jeff Winston, Joshua Wise, Clifford Wolf, Johan Wouters,
-Ding Xiaoliang, Jie Xu, and Amir Yazdanbakhsh.
+Tengstrand, Wesley Terpstra, Stefan Thiede, Gary Thomas, Kevin Thompson,
+Ian Thompson, Mike Thyer, Hans Tichelaar, Steve Tong, Michael Tresidder,
+Holger Waechtler, Stefan Wallentowitz, Shawn Wang, Greg Waters, Thomas
+Watts, Eugene Weber, David Welch, Thomas J Whatson, Leon Wildman, Gerald
+Williams, Trevor Williams, Jeff Winston, Joshua Wise, Clifford Wolf, Johan
+Wouters, Ding Xiaoliang, Jie Xu, Mandy Xu, Luke Yang, and Amir
+Yazdanbakhsh.

 Thanks to them, and all those we've missed including above.

@@ -173,7 +173,7 @@ additional points.
 Additional Verilog-standard arguments specify the search paths necessary to
 find the source code that the coverage analysis was performed on.

-To get correct coverage percentages, you may wish to read logs/coverage.pl
+To get correct coverage percentages, you may wish to read logs/coverage.dat
 into Emacs and do a M-x keep-lines to include only those statistics of
 interest.

@@ -13,8 +13,8 @@ use warnings;
 print "// DESCR"."IPTION: Generated by verilator_includer via makefile\n";
 foreach my $param (@ARGV) {
    if ($param =~ /^-D([^=]+)=(.*)/) {
-	print "#define $1 $2\n"
+        print "#define $1 $2\n"
    } else {
-	print "#include \"$param\"\n"
+        print "#include \"$param\"\n"
    }
 }
@@ -6,8 +6,9 @@

 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[3.900 2017-01-15])
+AC_INIT([Verilator],[3.916 2017-11-25])
 # When releasing, also update header of Changes file
+# and commit using "devel release" or "Version bump" message

 AC_CONFIG_HEADER(src/config_build.h)
 AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
@@ -42,7 +43,7 @@ AC_ARG_ENABLE([ccwarn],
                x)   CFG_WITH_CCWARN=no ;;
                *)   CFG_WITH_CCWARN=yes ;;
               esac]
-	      )
+              )
 AC_SUBST(CFG_WITH_CCWARN)
 AC_MSG_RESULT($CFG_WITH_CCWARN)

@@ -60,7 +61,7 @@ AC_ARG_ENABLE([longtests],
                x)   CFG_WITH_LONGTESTS=no ;;
                *)   CFG_WITH_LONGTESTS=yes ;;
               esac]
-	      )
+              )
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)

@@ -78,10 +79,10 @@ AC_PROG_INSTALL
 AC_LANG_PUSH(C++)
 AC_MSG_CHECKING([that C++ compiler can compile simple program])
 AC_RUN_IFELSE(
-           [AC_LANG_SOURCE([int main() { return 0; }])],
-           AC_MSG_RESULT(yes),
-           AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]),
-	   AC_MSG_RESULT(yes))
+   [AC_LANG_SOURCE([int main() { return 0; }])],
+    AC_MSG_RESULT(yes),
+    AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]),
+    AC_MSG_RESULT(yes))

 AC_PATH_PROG(PERL,perl)
 if test "x$PERL" = "x" ; then
@@ -105,72 +106,148 @@ AC_TYPE_SIZE_T
 # Checks for compiler characteristics.
 AC_C_INLINE

-AC_DEFUN([_MY_CXX_CHECK_OPT],
-   [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
+AC_LINK_IFELSE(
+     [AC_LANG_PROGRAM([#include <new>], [[int* a=new int; delete a; ]])],
+     [], [AC_MSG_ERROR([$CXX does not seem to successfully compile a simple C++ program])])
+
+AC_DEFUN([_MY_CXX_CHECK_FLAG],
+   [# _MY_CXX_CHECK_FLAG(flag) -- Check if compiler supports specific options
+    # Set $_my_result appropriately
    ACO_SAVE_CXXFLAGS="$CXXFLAGS"
    # -Werror needed otherwise unknown -Wno-div-by-zero won't report problems
-    CXXFLAGS="$CXXFLAGS $2 -Werror"
-    AC_MSG_CHECKING([whether $CXX accepts $2])
-    AC_COMPILE_IFELSE(
-         [AC_LANG_PROGRAM([],[])],
-	 [_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])
+    # new/delete is needed to find -faligned-new link problem on Darwin
+    CXXFLAGS="$CXXFLAGS $1 -Werror"
+    AC_MSG_CHECKING([whether $CXX accepts $1])
+    AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM([#include <new>], [[int* a=new int; delete a; ]])],
+         [_my_result=yes
+          if test -s conftest.err; then
+            if grep -e "$1" conftest.err >/dev/null; then
+              _my_result=no
+            fi
+          fi],
+         [_my_result=no])
    # 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
+            if grep -e "$1" conftest.err >/dev/null; then
              _my_result=no
            fi
          fi])
    AC_MSG_RESULT($_my_result)
+    CXXFLAGS="$ACO_SAVE_CXXFLAGS"
+   ])
+
+AC_DEFUN([_MY_CXX_CHECK_SET],
+   [# _MY_CXX_CHECK_SET(variable,flag) -- Check if compiler supports specific options
+    # If it does, set variable to flag, only if not previously set
+    if test "$$1" = ""; then
+       _MY_CXX_CHECK_FLAG($2)
+       if test "$_my_result" = "yes" ; then
+          $1="$2"
+       fi
+    fi
+   ])
+
+AC_DEFUN([_MY_CXX_CHECK_OPT],
+   [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
+    # If it does, append flag to variable
+    _MY_CXX_CHECK_FLAG($2)
    if test "$_my_result" = "yes" ; then
       $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)
+# Flag to select newest language standard supported
+# Macros work such that first option that passes is the one we take
+# gnu++14 is the newest that Verilator supports
+# std++03 is the oldest that Verilator supports
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=gnu++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_NEWEST,-std=c++03)
+AC_SUBST(CFG_CXXFLAGS_STD_NEWEST)
+# And likewise oldest standard (same list above, backwards)
+# This is used for internal testing
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=std++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++03)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++11)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++14)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_STD_OLDEST,-std=gnu++17)
+AC_SUBST(CFG_CXXFLAGS_STD_OLDEST)
+
+# Flags for compiling Verilator internals including parser, and Verilated files
+# These turn on extra warnings and are only used with 'configure --enable-ccwarn'
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wextra)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wfloat-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wlogical-op)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wthread-safety)
+AC_SUBST(CFG_CXXFLAGS_WEXTRA)
+
+# Flags for compiling Verilator internals including parser always
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-delete-null-pointer-checks)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-undefined-bool-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
 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)
+# Flags for compiling Verilator parser always (in addition to above CFG_CXXFLAGS_SRC)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-char-subscripts)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-null-conversion)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
 AC_SUBST(CFG_CXXFLAGS_PARSER)

 # Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
-_MY_CXX_CHECK_OPT(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(CFG_CXXFLAGS_NO_UNUSED,-faligned-new)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-sign-compare)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-uninitialized)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-but-set-variable)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-parameter)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)

+# Set CFG_WITH_THREADED if can support threading
+AC_MSG_CHECKING(whether $CXX supports Verilated threads)
+ACO_SAVE_CXXFLAGS="$CXXFLAGS"
+CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_STD_NEWEST $CFG_CXXFLAGS_NO_UNUSED"
+AC_LINK_IFELSE(
+     [AC_LANG_PROGRAM([#include <thread>], [[ ]])],
+     [_my_result=yes
+      if test -s conftest.err; then
+        if grep -e "$1" conftest.err >/dev/null; then
+          _my_result=no
+        fi
+      fi],
+     [_my_result=no])
+CFG_WITH_THREADED=$_my_result
+AC_SUBST(CFG_WITH_THREADED)
+AC_MSG_RESULT($CFG_WITH_THREADED)
+
 # Checks for library functions.
+AC_CHECK_MEMBER([struct stat.st_mtim.tv_nsec],
+    [AC_DEFINE([HAVE_STAT_NSEC],[1],[Defined if struct stat has st_mtim.tv_nsec])],
+    [], [#include <sys/stat.h>])

 # Checks for system services

@@ -635,8 +635,7 @@ INPUT                  = doxygen-mainpage \
                         test_c \
                         test_regress \
                         test_sc \
-                         test_v \
-                         test_verilated
+                         test_v

 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
@@ -3,4 +3,4 @@
 *.csrc
 *.vcd
 obj_*
-project
+logs
@@ -0,0 +1,52 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+
+# This is intended to be a minimal example.  Before copying this to start a
+# real project, it is better to start with a more complete example,
+# e.g. examples/tracing_c.
+
+# If $VERILATOR_ROOT isn't in the enviornment, we assume it is part of a
+# package inatall, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+endif
+
+default:
+	@echo "-- Verilator hello-world simple example"
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) -cc --exe top.v sim_main.cpp
+	@echo "-- COMPILE -----------------"
+	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- RUN ---------------------"
+	obj_dir/Vtop
+	@echo "-- DONE --------------------"
+	@echo "Note: Once this example is understood, see examples/tracing_c."
+	@echo "Note: Also see the EXAMPLE section in the verilator manpage/document."
+
+######################################################################
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir *.log *.dmp *.vpd core
@@ -0,0 +1,41 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// Include common routines
+#include <verilated.h>
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int main(int argc, char** argv, char** env) {
+    // See a similar example walkthrough in the verilator manpage.
+
+    // This is intended to be a minimal example.  Before copying this to start a
+    // real project, it is better to start with a more complete example,
+    // e.g. examples/c_tracing.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv && env) {}
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop;
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+
+        // Evaluate model
+        top->eval();
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Destroy model
+    delete top;
+
+    // Fin
+    exit(0);
+}
@@ -0,0 +1,12 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+
+// See also the EXAMPLE section in the verilator manpage/document.
+module top;
+   initial begin
+      $display("Hello World!");
+      $finish;
+   end
+endmodule
@@ -1,8 +1,6 @@
-*.old
 *.dmp
 *.log
 *.csrc
 *.vcd
 obj_*
 logs
-project
@@ -0,0 +1,67 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+
+# This is intended to be a minimal example.  Before copying this to start a
+# real project, it is better to start with a more complete example,
+# e.g. examples/tracing_sc.
+
+# If $VERILATOR_ROOT isn't in the enviornment, we assume it is part of a
+# package inatall, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+endif
+
+# Check if SC exists via a verilator call (empty if not)
+SYSTEMC_EXISTS := $(shell $(VERILATOR) --getenv SYSTEMC_INCLUDE)
+
+ifneq ($(SYSTEMC_EXISTS),)
+default: run
+else
+default: nosc
+endif
+
+run:
+	@echo "-- Verilator hello-world simple example"
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) -sc --exe top.v sc_main.cpp
+	@echo "-- COMPILE -----------------"
+	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- RUN ---------------------"
+	obj_dir/Vtop
+	@echo "-- DONE --------------------"
+	@echo "Note: Once this example is understood, see examples/tracing_sc."
+	@echo "Note: Also see the EXAMPLE section in the verilator manpage/document."
+
+######################################################################
+
+nosc:
+	@echo
+	@echo "%Skip: SYSTEMC_INCLUDE not in environment"
+	@echo "(If you have SystemC see the README, and rebuild Verilator)"
+	@echo
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir *.log *.dmp *.vpd core
@@ -0,0 +1,51 @@
+// -*- SystemC -*-
+// DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// SystemC global header
+#include <systemc.h>
+
+// Include common routines
+#include <verilated.h>
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int sc_main(int argc, char* argv[]) {
+    // See a similar example walkthrough in the verilator manpage.
+
+    // This is intended to be a minimal example.  Before copying this to start a
+    // real project, it is better to start with a more complete example,
+    // e.g. examples/c_tracing.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv) {}
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop("top");
+
+    // Initialize SC model
+#if (SYSTEMC_VERSION>=20070314)
+    sc_start(1,SC_NS);
+#else
+    sc_start(1);
+#endif
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+#if (SYSTEMC_VERSION>=20070314)
+        sc_start(1,SC_NS);
+#else
+        sc_start(1);
+#endif
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Fin
+    return 0;
+}
@@ -0,0 +1,12 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+
+// See also the EXAMPLE section in the verilator manpage/document.
+module top;
+   initial begin
+      $display("Hello World!");
+      $finish;
+   end
+endmodule
@@ -0,0 +1,6 @@
+*.dmp
+*.log
+*.csrc
+*.vcd
+obj_*
+logs
@@ -0,0 +1,96 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+# Set up variables
+
+# If $VERILATOR_ROOT isn't in the enviornment, we assume it is part of a
+# package inatall, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+VERILATOR_COVERAGE = verilator_coverage
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+endif
+
+VERILATOR_FLAGS =
+# Generate C++ in executable form
+VERILATOR_FLAGS += -cc --exe
+# Generate makefile dependencies (not shown as complicates the Makefile)
+#VERILATOR_FLAGS += -MMD
+# Optimize
+VERILATOR_FLAGS += -O2 -x-assign 0
+# Warn abount lint issues; may not want this on less solid designs
+VERILATOR_FLAGS += -Wall
+# Make waveforms
+VERILATOR_FLAGS += --trace
+# Check SystemVerilog assertions
+VERILATOR_FLAGS += --assert
+# Generate coverage analysis
+VERILATOR_FLAGS += --coverage
+# Run Verilator in debug mode
+#VERILATOR_FLAGS += --debug
+# Add this trace to get a backtrace in gdb
+#VERILATOR_FLAGS += --gdbbt
+
+######################################################################
+default: run
+
+run:
+	@echo
+	@echo "-- Verilator tracing example"
+
+	@echo
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sim_main.cpp
+
+	@echo
+	@echo "-- COMPILE -----------------"
+# To compile, we can either just do what Verilator asks,
+# or call a submakefile where we can override the rules ourselves
+#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+
+	@echo
+	@echo "-- RUN ---------------------"
+	@mkdir -p logs
+	obj_dir/Vtop +trace
+
+	@echo
+	@echo "-- COVERAGE ----------------"
+	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
+
+	@echo
+	@echo "-- DONE --------------------"
+	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
+	@echo
+
+
+######################################################################
+# Other targets
+
+show-config:
+	$(VERILATOR) -V
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir logs *.log *.dmp *.vpd coverage.dat core
@@ -0,0 +1,55 @@
+# -*- Makefile -*-
+#######################################################################
+#
+# DESCRIPTION: Verilator Example: Makefile for inside object directory
+#
+# This is executed in the object directory, and called by ../Makefile
+#
+# 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.
+#
+#######################################################################
+
+default: Vtop
+
+# Include the rules made by Verilator
+include Vtop.mk
+
+#######################################################################
+# Compile flags
+
+# Override some default compile flags
+CPPFLAGS += -MMD -MP
+CPPFLAGS += -DVL_DEBUG=1
+# Turn on some more flags (when configured appropriately)
+# For testing inside Verilator, "configure --enable-ccwarn" will do this
+# automatically; otherwise you may want this unconditionally enabled
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+USER_CPPFLAGS_WALL += -W -Werror -Wall
+endif
+
+# See the benchmarking section of bin/verilator.
+# Support class optimizations.  This includes the tracing and symbol table.
+# SystemC takes minutes to optimize, thus it is off by default.
+OPT_SLOW =
+# Fast path optimizations.  Most time is spent in these classes.
+OPT_FAST = -O2 -fstrict-aliasing
+#OPT_FAST = -O
+#OPT_FAST =
+
+#######################################################################
+# Linking final exe -- presumes have a sim_main.cpp
+
+# Special compile rule
+sim_main.o: sim_main.cpp $(VM_PREFIX).h
+
+######################################################################
+######################################################################
+# Automatically understand dependencies
+
+DEPS := $(wildcard *.d)
+ifneq ($(DEPS),)
+include $(DEPS)
+endif
@@ -0,0 +1,2 @@
+// This file typically lists flags required by a large project, e.g. include directories
+librescan +libext+.v+.sv+.vh+.svh -y .
@@ -0,0 +1,119 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// Include common routines
+#include <verilated.h>
+
+#include <sys/stat.h>  // mkdir
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+// If "verilator --trace" is used, include the tracing class
+#if VM_TRACE
+# include <verilated_vcd_c.h>
+#endif
+
+// Current simulation time (64-bit unsigned)
+vluint64_t main_time = 0;
+// Called by $time in Verilog
+double sc_time_stamp () {
+    return main_time; // Note does conversion to real, to match SystemC
+}
+
+int main(int argc, char** argv, char** env) {
+    // This is a more complicated example, please also see the simpler examples/hello_world_c.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv && env) {}
+    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+    Verilated::commandArgs(argc, argv);
+
+    // Set debug level, 0 is off, 9 is highest presently used
+    Verilated::debug(0);
+
+    // Randomization reset policy
+    Verilated::randReset(2);
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
+    Vtop* top = new Vtop; // Or use a const unique_ptr, or the VL_UNIQUE_PTR wrapper
+
+#if VM_TRACE
+    // If verilator was invoked with --trace argument,
+    // and if at run time passed the +trace argument, turn on tracing
+    VerilatedVcdC* tfp = NULL;
+    const char* flag = Verilated::commandArgsPlusMatch("trace");
+    if (flag && 0==strcmp(flag, "+trace")) {
+        Verilated::traceEverOn(true);  // Verilator must compute traced signals
+        VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
+        tfp = new VerilatedVcdC;
+        top->trace(tfp, 99);  // Trace 99 levels of hierarchy
+        mkdir("logs", 0777);
+        tfp->open("logs/vlt_dump.vcd");  // Open the dump file
+    }
+#endif
+
+    // Set some inputs
+    top->reset_l = !0;
+    top->fastclk = 0;
+    top->clk = 0;
+    top->in_small = 1;
+    top->in_quad = 0x1234;
+    top->in_wide[0] = 0x11111111;
+    top->in_wide[1] = 0x22222222;
+    top->in_wide[2] = 0x3;
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+        main_time++;  // Time passes...
+
+        // Toggle clocks and such
+        top->fastclk = !top->fastclk;
+        if ((main_time % 10) == 3) {
+            top->clk = 1;
+        }
+        if ((main_time % 10) == 8) {
+            top->clk = 0;
+        }
+        if (main_time > 1 && main_time < 10) {
+            top->reset_l = !1;  // Assert reset
+        } else {
+            top->reset_l = !0;  // Deassert reset
+        }
+
+        // Assign some other inputs
+        top->in_quad += 0x12;
+
+        // Evaluate model
+        top->eval();
+
+        // Read outputs
+        VL_PRINTF ("[%" VL_PRI64 "d] clk=%x rstl=%x iquad=%" VL_PRI64 "x"
+                   " -> oquad=%" VL_PRI64"x owide=%x_%08x_%08x\n",
+                   main_time, top->clk, top->reset_l, top->in_quad,
+                   top->out_quad, top->out_wide[2], top->out_wide[1], top->out_wide[0]);
+    }
+
+    // Final model cleanup
+    top->final();
+
+    // Close trace if opened
+#if VM_TRACE
+    if (tfp) { tfp->close(); }
+#endif
+
+    //  Coverage analysis (since test passed)
+#if VM_COVERAGE
+    mkdir("logs", 0777);
+    VerilatedCov::write("logs/coverage.dat");
+#endif
+
+    // Destroy model
+    delete top; top = NULL;
+
+    // Fin
+    exit(0);
+}
@@ -0,0 +1,58 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+module sub
+  (
+   input clk,
+   input fastclk,
+   input reset_l
+   );
+
+   // Example counter/flop
+   reg [31:0] count_f;
+   always_ff @ (posedge fastclk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_f <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_f <= count_f + 1;
+      end
+   end
+
+   // Another example flop
+   reg [31:0] count_c;
+   always_ff @ (posedge clk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_c <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_c <= count_c + 1;
+         if (count_c >= 3) begin
+            $display("[%0t] fastclk is %0d times faster than clk\n",
+                     $time, count_f/count_c);
+            // This write is a magic value the Makefile uses to make sure the
+            // test completes successfully.
+            $write("*-* All Finished *-*\n");
+            $finish;
+         end
+      end
+   end
+
+   // An example assertion
+   always_ff @ (posedge clk) begin
+      AssertionExample: assert (!reset_l || count_c<100);
+   end
+
+   // And example coverage analysis
+   cover property (@(posedge clk) count_c==3);
+
+endmodule
@@ -0,0 +1,42 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+// This is intended to be a complex example of several features, please also
+// see the simpler examples/hello_world_c.
+
+module top
+  (
+   // Declare some signals so we can see how I/O works
+   input         clk,
+   input         fastclk,
+   input         reset_l,
+
+   output [1:0]  out_small,
+   output [39:0] out_quad,
+   output [69:0] out_wide,
+   input [1:0]   in_small,
+   input [39:0]  in_quad,
+   input [69:0]  in_wide
+   );
+
+   // Connect up the outputs, using some trivial logic
+   wire [1:0]    out_small = ~reset_l ? '0 : (in_small + 2'b1);
+   wire [39:0]   out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+   wire [69:0]   out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+
+   // And an example sub module. The submodule will print stuff.
+   sub sub (/*AUTOINST*/
+            // Inputs
+            .clk                        (clk),
+            .fastclk                    (fastclk),
+            .reset_l                    (reset_l));
+
+   // Print some stuff as an example
+   initial begin
+      $display("[%0t] Model running...\n", $time);
+   end
+
+endmodule
@@ -0,0 +1,6 @@
+*.dmp
+*.log
+*.csrc
+*.vcd
+obj_*
+logs
@@ -0,0 +1,109 @@
+######################################################################
+#
+# DESCRIPTION: Verilator Example: Small Makefile
+#
+# This calls the object directory makefile.  That allows the objects to
+# be placed in the "current directory" which simplifies the Makefile.
+#
+# 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.
+#
+######################################################################
+# Check for sanity to avoid later confusion
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
+
+######################################################################
+# Set up variables
+
+# If $VERILATOR_ROOT isn't in the enviornment, we assume it is part of a
+# package inatall, and verilator is in your path. Otherwise find the
+# binary relative to $VERILATOR_ROOT (such as when inside the git sources).
+ifeq ($(VERILATOR_ROOT),)
+VERILATOR = verilator
+VERILATOR_COVERAGE = verilator_coverage
+else
+export VERILATOR_ROOT
+VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+endif
+
+VERILATOR_FLAGS =
+# Generate SystemC in executable form
+VERILATOR_FLAGS += -sc --exe
+# Generate makefile dependencies (not shown as complicates the Makefile)
+#VERILATOR_FLAGS += -MMD
+# Optimize
+VERILATOR_FLAGS += -O2 -x-assign 0
+# Warn abount lint issues; may not want this on less solid designs
+VERILATOR_FLAGS += -Wall
+# Make waveforms
+VERILATOR_FLAGS += --trace
+# Check SystemVerilog assertions
+VERILATOR_FLAGS += --assert
+# Generate coverage analysis
+VERILATOR_FLAGS += --coverage
+# Run Verilator in debug mode
+#VERILATOR_FLAGS += --debug
+# Add this trace to get a backtrace in gdb
+#VERILATOR_FLAGS += --gdbbt
+
+# Check if SC exists via a verilator call (empty if not)
+SYSTEMC_EXISTS := $(shell $(VERILATOR) --getenv SYSTEMC_INCLUDE)
+
+######################################################################
+
+ifneq ($(SYSTEMC_EXISTS),)
+default: run
+else
+default: nosc
+endif
+
+run:
+	@echo
+	@echo "-- Verilator tracing example"
+
+	@echo
+	@echo "-- VERILATE ----------------"
+	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sc_main.cpp
+
+	@echo
+	@echo "-- COMPILE ----------------="
+# To compile, we can either just do what Verilator asks,
+# or call a submakefile where we can override the rules ourselves
+#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+
+	@echo
+	@echo "-- RUN ---------------------"
+	@mkdir -p logs
+	obj_dir/Vtop +trace
+
+	@echo
+	@echo "-- COVERAGE ----------------"
+	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
+
+	@echo
+	@echo "-- DONE --------------------"
+	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
+	@echo
+
+######################################################################
+# Other targets
+
+nosc:
+	@echo
+	@echo "%Skip: SYSTEMC_INCLUDE not in environment"
+	@echo "(If you have SystemC see the README, and rebuild Verilator)"
+	@echo
+
+show-config:
+	$(VERILATOR) -V
+
+maintainer-copy::
+clean mostlyclean distclean maintainer-clean::
+	-rm -rf obj_dir logs *.log *.dmp *.vpd coverage.dat core
@@ -0,0 +1,63 @@
+# -*- Makefile -*-
+#######################################################################
+#
+# DESCRIPTION: Verilator Example: Makefile for inside object directory
+#
+# This is executed in the object directory, and called by ../Makefile
+#
+# 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.
+#
+#######################################################################
+
+default: Vtop
+
+# Include the rules made by Verilator
+include Vtop.mk
+
+#######################################################################
+# Compile flags
+
+# Override some default compile flags
+CPPFLAGS += -MMD -MP
+CPPFLAGS += -DVL_DEBUG=1
+# SystemC isn't too clean
+CPPFLAGS += -Wno-deprecated
+# Turn on some more flags (when configured appropriately)
+# For testing inside Verilator, "configure --enable-ccwarn" will do this
+# automatically; otherwise you may want this unconditionally enabled
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+USER_CPPFLAGS_WALL += -W -Werror -Wall
+endif
+
+# If you build your own rules from scratch, note you need to include
+# SystemC as follows (Vtop.mk file includes verilated.mk with these
+# already).
+# CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
+# LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
+
+# See the benchmarking section of bin/verilator.
+# Support class optimizations.  This includes the tracing and symbol table.
+# SystemC takes minutes to optimize, thus it is off by default.
+OPT_SLOW =
+# Fast path optimizations.  Most time is spent in these classes.
+OPT_FAST = -O2 -fstrict-aliasing
+#OPT_FAST = -O
+#OPT_FAST =
+
+#######################################################################
+# Linking final exe -- presumes have a sim_main.cpp
+
+# Special compile rule
+sim_main.o: sim_main.cpp $(VM_PREFIX).h
+
+######################################################################
+######################################################################
+# Automatically understand dependencies
+
+DEPS := $(wildcard *.d)
+ifneq ($(DEPS),)
+include $(DEPS)
+endif
@@ -0,0 +1,2 @@
+// This file typically lists flags required by a large project, e.g. include directories
+librescan +libext+.v+.sv+.vh+.svh -y .
@@ -0,0 +1,141 @@
+// -*- SystemC -*-
+// DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2017 by Wilson Snyder.
+//======================================================================
+
+// SystemC global header
+#include <systemc.h>
+
+// Include common routines
+#include <verilated.h>
+#if VM_TRACE
+#include <verilated_vcd_sc.h>
+#endif
+
+#include <sys/stat.h>  // mkdir
+
+// Include model header, generated from Verilating "top.v"
+#include "Vtop.h"
+
+int sc_main(int argc, char* argv[]) {
+    // This is a more complicated example, please also see the simpler examples/hello_world_c.
+
+    // Prevent unused variable warnings
+    if (0 && argc && argv) {}
+    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+    Verilated::commandArgs(argc, argv);
+
+    // Set debug level, 0 is off, 9 is highest presently used
+    Verilated::debug(0);
+
+    // Randomization reset policy
+    Verilated::randReset(2);
+
+    // General logfile
+    ios::sync_with_stdio();
+
+    // Defaults time
+#if (SYSTEMC_VERSION>20011000)
+#else
+    sc_time dut(1.0, sc_ns);
+    sc_set_default_time_unit(dut);
+#endif
+
+    // Define clocks
+#if (SYSTEMC_VERSION>=20070314)
+    sc_clock clk     ("clk",    10,SC_NS, 0.5, 3,SC_NS, true);
+    sc_clock fastclk ("fastclk", 2,SC_NS, 0.5, 2,SC_NS, true);
+#else
+    sc_clock clk     ("clk",    10, 0.5, 3, true);
+    sc_clock fastclk ("fastclk", 2, 0.5, 2, true);
+#endif
+
+    // Define interconnect
+    sc_signal<bool> reset_l;
+    sc_signal<vluint32_t> in_small;
+    sc_signal<vluint64_t> in_quad;
+    sc_signal<sc_bv<70> > in_wide;
+    sc_signal<vluint32_t> out_small;
+    sc_signal<vluint64_t> out_quad;
+    sc_signal<sc_bv<70> > out_wide;
+
+    // Construct the Verilated model, from inside Vtop.h
+    Vtop* top = new Vtop("top");
+    // Attach signals to the model
+    top->clk       (clk);
+    top->fastclk   (fastclk);
+    top->reset_l   (reset_l);
+    top->in_small  (in_small);
+    top->in_quad   (in_quad);
+    top->in_wide   (in_wide);
+    top->out_small (out_small);
+    top->out_quad  (out_quad);
+    top->out_wide  (out_wide);
+
+#if VM_TRACE
+    // Before any evaluation, need to know to calculate those signals only used for tracing
+    Verilated::traceEverOn(true);
+#endif
+
+    // You must do one evaluation before enabling waves, in order to allow
+    // SystemC to interconnect everything for testing.
+#if (SYSTEMC_VERSION>=20070314)
+    sc_start(1,SC_NS);
+#else
+    sc_start(1);
+#endif
+
+#if VM_TRACE
+    // If verilator was invoked with --trace argument,
+    // and if at run time passed the +trace argument, turn on tracing
+    VerilatedVcdSc* tfp = NULL;
+    const char* flag = Verilated::commandArgsPlusMatch("trace");
+    if (flag && 0==strcmp(flag, "+trace")) {
+        cout << "Enabling waves into logs/vlt_dump.vcd...\n";
+        VerilatedVcdSc* tfp = new VerilatedVcdSc;
+        top->trace (tfp, 99);
+        mkdir("logs", 0777);
+        tfp->open ("logs/vlt_dump.vcd");
+    }
+#endif
+
+    // Simulate until $finish
+    while (!Verilated::gotFinish()) {
+#if VM_TRACE
+        // Flush the wave files each cycle so we can immediately see the output
+        // Don't do this in "real" programs, do it in an abort() handler instead
+        if (tfp) tfp->flush();
+        // Apply inputs
+        if (VL_TIME_Q() > 1 && VL_TIME_Q() < 10) {
+            reset_l = !1;       // Assert reset
+        } else if (VL_TIME_Q() > 1) {
+            reset_l = !0;       // Deassert reset
+        }
+#endif
+        // Simulate 1ns
+#if (SYSTEMC_VERSION>=20070314)
+        sc_start(1,SC_NS);
+#else
+        sc_start(1);
+#endif
+    }
+
+    //  Close Waves
+#if VM_TRACE
+    if (tfp) tfp->close();
+#endif
+
+    // Final model cleanup
+    top->final();
+
+    //  Coverage analysis (since test passed)
+#if VM_COVERAGE
+    mkdir("logs", 0777);
+    VerilatedCov::write("logs/coverage.dat");
+#endif
+
+    // Fin
+    return 0;
+}
@@ -0,0 +1,58 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+module sub
+  (
+   input clk,
+   input fastclk,
+   input reset_l
+   );
+
+   // Example counter/flop
+   reg [31:0] count_f;
+   always_ff @ (posedge fastclk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_f <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_f <= count_f + 1;
+      end
+   end
+
+   // Another example flop
+   reg [31:0] count_c;
+   always_ff @ (posedge clk) begin
+      if (!reset_l) begin
+         /*AUTORESET*/
+         // Beginning of autoreset for uninitialized flops
+         count_c <= 32'h0;
+         // End of automatics
+      end
+      else begin
+         count_c <= count_c + 1;
+         if (count_c >= 3) begin
+            $display("[%0t] fastclk is %0d times faster than clk\n",
+                     $time, count_f/count_c);
+            // This write is a magic value the Makefile uses to make sure the
+            // test completes successfully.
+            $write("*-* All Finished *-*\n");
+            $finish;
+         end
+      end
+   end
+
+   // An example assertion
+   always_ff @ (posedge clk) begin
+      AssertionExample: assert (!reset_l || count_c<100);
+   end
+
+   // And example coverage analysis
+   cover property (@(posedge clk) count_c==3);
+
+endmodule
@@ -0,0 +1,42 @@
+// DESCRIPTION: Verilator: Verilog example module
+//
+// This file ONLY is placed into the Public Domain, for any use,
+// without warranty, 2003 by Wilson Snyder.
+// ======================================================================
+
+// This is intended to be a complex example of several features, please also
+// see the simpler examples/hello_world_c.
+
+module top
+  (
+   // Declare some signals so we can see how I/O works
+   input         clk,
+   input         fastclk,
+   input         reset_l,
+
+   output [1:0]  out_small,
+   output [39:0] out_quad,
+   output [69:0] out_wide,
+   input [1:0]   in_small,
+   input [39:0]  in_quad,
+   input [69:0]  in_wide
+   );
+
+   // Connect up the outputs, using some trivial logic
+   wire [1:0]    out_small = ~reset_l ? '0 : (in_small + 2'b1);
+   wire [39:0]   out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+   wire [69:0]   out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+
+   // And an example sub module. The submodule will print stuff.
+   sub sub (/*AUTOINST*/
+            // Inputs
+            .clk                        (clk),
+            .fastclk                    (fastclk),
+            .reset_l                    (reset_l));
+
+   // Print some stuff as an example
+   initial begin
+      $display("[%0t] Model running...\n", $time);
+   end
+
+endmodule
@@ -16,13 +16,18 @@ RANLIB = ranlib
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@

+# Select newest language
+CFG_CXXFLAGS_STD_NEWEST = @CFG_CXXFLAGS_STD_NEWEST@
+# Select oldest language (for Verilator internal testing only)
+CFG_CXXFLAGS_STD_OLDEST = @CFG_CXXFLAGS_STD_OLDEST@
 # Compiler flags to use to turn off unused and generated code warnings, such as -Wno-div-by-zero
 CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
+# Compiler flags that turn on extra warnings
+CFG_CXXFLAGS_WEXTRA = @CFG_CXXFLAGS_WEXTRA@

 ######################################################################
 # Programs

-SP_PREPROC	= sp_preproc
 SP_INCLUDER	= $(VERILATOR_INCLUDER)
 VERILATOR_COVERAGE = $(PERL) $(VERILATOR_ROOT)/bin/verilator_coverage
 VERILATOR_INCLUDER = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
@@ -49,8 +54,7 @@ VK_CPPFLAGS_ALWAYS += \
 		$(CFG_CXXFLAGS_NO_UNUSED) \

 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
-VK_CPPFLAGS_WALL += -Wall \
-		-Werror
+VK_CPPFLAGS_WALL += -Wall $(CFG_CXXFLAGS_WEXTRA) -Werror
 endif

 CPPFLAGS += -I. $(VK_CPPFLAGS_WALL) $(VK_CPPFLAGS_ALWAYS)
@@ -93,9 +97,9 @@ VM_CLASSES += $(VM_CLASSES_FAST) $(VM_CLASSES_SLOW)
 VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)

 #######################################################################
-##### SystemC or SystemPerl builds
+##### SystemC builds

-ifeq ($(VM_SP_OR_SC),1)
+ifeq ($(VM_SC),1)
  CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
  SC_LIBS   = -lsystemc
@@ -106,24 +110,20 @@ ifeq ($(VM_SP_OR_SC),1)
 endif

 #######################################################################
-##### SystemPerl builds
+##### Threaded builds

-ifeq ($(VM_SP),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE) -DSYSTEMPERL
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
-  LIBS   += -lm -lstdc++
-
-  VK_CLASSES_SP = $(addsuffix .sp, $(VM_CLASSES))
-
-  # This rule is called manually by the upper level makefile
-  preproc:
-	 @echo "      SP Preprocess" $(basename $(VM_CLASSES)) ...
-	 $(SP_PREPROC) -M sp_preproc.d --tree $(VM_PREFIX).sp_tree \
-		--preproc $(VK_CLASSES_SP)
-else
-  preproc:
+ifneq ($(VM_THREADS),0)
+ ifneq ($(VM_THREADS),)
+  # Need C++11 at least, so always default to newest
+  CPPFLAGS += -DVL_THREADED $(CFG_CXXFLAGS_STD_NEWEST)
+ endif
 endif

+#######################################################################
+##### Stub
+
+preproc:
+
 #######################################################################
 ##### C/H builds

@@ -50,7 +50,7 @@ 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++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    m_keys[i]=KEY_UNDEF;
 	    m_vals[i]=0;
 	}
@@ -72,6 +72,7 @@ private:
    T*	m_countp;	///< Count value
 public:
    // METHODS
+    // cppcheck-suppress truncLongCastReturn
    virtual vluint64_t count() const { return *m_countp; }
    virtual void zero() const { *m_countp = 0; }
    // CONSTRUCTORS
@@ -89,19 +90,20 @@ public:
 class VerilatedCovImp : VerilatedCovImpBase {
 private:
    // TYPES
-    typedef map<string,int> ValueIndexMap;
-    typedef map<int,string> IndexValueMap;
-    typedef deque<VerilatedCovImpItem*> ItemList;
+    typedef std::map<std::string,int> ValueIndexMap;
+    typedef std::map<int,std::string> IndexValueMap;
+    typedef std::deque<VerilatedCovImpItem*> ItemList;

 private:
    // MEMBERS
-    ValueIndexMap	m_valueIndexes;		///< For each key/value a unique arbitrary index value
-    IndexValueMap	m_indexValues;		///< For each key/value a unique arbitrary index value
-    ItemList		m_items;		///< List of all items
+    VerilatedMutex	m_mutex;  ///< Protects all members, when VL_THREADED. Wrapper deals with setting it.
+    ValueIndexMap       m_valueIndexes VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
+    IndexValueMap       m_indexValues VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
+    ItemList            m_items VL_GUARDED_BY(m_mutex);  ///< List of all items

-    VerilatedCovImpItem*	m_insertp;	///< Item about to insert
-    const char*		m_insertFilenamep;	///< Filename about to insert
-    int			m_insertLineno;		///< Line number about to insert
+    VerilatedCovImpItem* m_insertp VL_GUARDED_BY(m_mutex);  ///< Item about to insert
+    const char*         m_insertFilenamep VL_GUARDED_BY(m_mutex);  ///< Filename about to insert
+    int                 m_insertLineno VL_GUARDED_BY(m_mutex);  ///< Line number about to insert

    // CONSTRUCTORS
    VerilatedCovImp() {
@@ -109,28 +111,29 @@ private:
 	m_insertFilenamep = NULL;
 	m_insertLineno = 0;
    }
+    VL_UNCOPYABLE(VerilatedCovImp);
 public:
-    ~VerilatedCovImp() { clear(); }
-    static VerilatedCovImp& imp() {
+    ~VerilatedCovImp() { clearGuts(); }
+    static VerilatedCovImp& imp() VL_MT_SAFE {
 	static VerilatedCovImp s_singleton;
 	return s_singleton;
    }

 private:
    // PRIVATE METHODS
-    int valueIndex(const string& value) {
+    int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
 	static int nextIndex = KEY_UNDEF+1;
 	ValueIndexMap::iterator iter = m_valueIndexes.find(value);
 	if (iter != m_valueIndexes.end()) return iter->second;
 	nextIndex++;  assert(nextIndex>0);
-	m_valueIndexes.insert(make_pair(value, nextIndex));
-	m_indexValues.insert(make_pair(nextIndex, value));
+	m_valueIndexes.insert(std::make_pair(value, nextIndex));
+	m_indexValues.insert(std::make_pair(nextIndex, value));
 	return nextIndex;
    }
-    string dequote(const string& text) {
+    static std::string dequote(const std::string& text) VL_PURE {
 	// Quote any special characters
-	string rtn;
-	for (const char* pos = text.c_str(); *pos; pos++) {
+	std::string rtn;
+	for (const char* pos = text.c_str(); *pos; ++pos) {
 	    if (!isprint(*pos) || *pos=='%' || *pos=='"') {
 		char hex[10]; sprintf(hex,"%%%02X",pos[0]);
 		rtn += hex;
@@ -140,7 +143,7 @@ private:
 	}
 	return rtn;
    }
-    bool legalKey(const string& key) {
+    static bool legalKey(const std::string& key) VL_PURE {
 	// Because we compress long keys to a single letter, and
 	// don't want applications to either get confused if they use
 	// a letter differently, nor want them to rely on our compression...
@@ -149,17 +152,17 @@ private:
 	if (key.length()==2 && isdigit(key[1])) return false;
 	return true;
    }
-    string keyValueFormatter (const string& key, const string& value) {
-	string name;
+    static std::string keyValueFormatter(const std::string& key, const std::string& value) VL_PURE {
+	std::string name;
 	if (key.length()==1 && isalpha(key[0])) {
-	    name += string("\001")+key;
+	    name += std::string("\001")+key;
 	} else {
-	    name += string("\001")+dequote(key);
+	    name += std::string("\001")+dequote(key);
 	}
-	name += string("\002")+dequote(value);
+	name += std::string("\002")+dequote(value);
 	return name;
    }
-    string combineHier (const string& old, const string& add) {
+    static std::string combineHier(const std::string& old, const std::string& add) VL_PURE {
 	// (foo.a.x, foo.b.x) => foo.*.x
 	// (foo.a.x, foo.b.y) => foo.*
 	// (foo.a.x, foo.b)   => foo.*
@@ -177,7 +180,7 @@ private:

 	// We used to backup and split on only .'s but it seems better to be verbose
 	// and not assume . is the separator
-	string prefix = string(a,apre-a);
+	std::string prefix = std::string(a,apre-a);

 	// Scan backward to last mismatch
 	const char* apost = a+strlen(a)-1;
@@ -186,41 +189,38 @@ private:
 	       && apost>apre && bpost>bpre) { apost--; bpost--; }

 	// Forward to . so we have a whole word
-	string suffix = *bpost ? string(bpost+1) : "";
+	std::string suffix = *bpost ? std::string(bpost+1) : "";

-	string out = prefix+"*"+suffix;
+	std::string out = prefix+"*"+suffix;

 	//cout << "\nch pre="<<prefix<<"  s="<<suffix<<"\nch a="<<old<<"\nch b="<<add<<"\nch o="<<out<<endl;
 	return out;
    }
-    bool itemMatchesString(VerilatedCovImpItem* itemp, const string& match) {
-	for (int i=0; i<MAX_KEYS; i++) {
+    bool itemMatchesString(VerilatedCovImpItem* itemp, const std::string& match) VL_REQUIRES(m_mutex) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (itemp->m_keys[i] != KEY_UNDEF) {
 		// We don't compare keys, only values
-		string val = m_indexValues[itemp->m_vals[i]];
-		if (string::npos != val.find(match)) {  // Found
+		std::string val = m_indexValues[itemp->m_vals[i]];
+		if (std::string::npos != val.find(match)) {  // Found
 		    return true;
 		}
 	    }
 	}
 	return false;
    }
-    void selftest() {
+    static void selftest() VL_MT_SAFE {
 	// Little selftest
-	if (combineHier ("a.b.c","a.b.c")	!="a.b.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.b.c","a.b")		!="a.b*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.x.c","a.y.c")	!="a.*.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("a.z.z.z.c","a.b.c")	!="a.*.c") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("z","a")		!="*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("q.a","q.b")		!="q.*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("q.za","q.zb")		!="q.z*") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
-	if (combineHier ("1.2.3.a","9.8.7.a")	!="*.a") vl_fatal(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("a.b.c","a.b.c")	!="a.b.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("a.b.c","a.b")		!="a.b*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("a.x.c","a.y.c")	!="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("a.z.z.z.c","a.b.c")	!="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("z","a")		!="*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("q.a","q.b")		!="q.*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("q.za","q.zb")		!="q.z*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+	if (combineHier ("1.2.3.a","9.8.7.a")	!="*.a") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
    }
-
-public:
-    // PUBLIC METHODS
-    void clear() {
-	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+    void clearGuts() VL_REQUIRES(m_mutex) {
+	for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
 	    VerilatedCovImpItem* itemp = *(it);
 	    delete itemp;
 	}
@@ -228,7 +228,17 @@ public:
 	m_indexValues.clear();
 	m_valueIndexes.clear();
    }
-    void clearNonMatch (const char* matchp) {
+
+public:
+    // PUBLIC METHODS
+    void clear() VL_EXCLUDES(m_mutex) {
+	Verilated::quiesce();
+	VerilatedLockGuard guard(m_mutex);
+	clearGuts();
+    }
+    void clearNonMatch(const char* matchp) VL_EXCLUDES(m_mutex) {
+	Verilated::quiesce();
+	VerilatedLockGuard guard(m_mutex);
 	if (matchp && matchp[0]) {
 	    ItemList newlist;
 	    for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
@@ -242,47 +252,52 @@ public:
 	    m_items = newlist;
 	}
    }
-    void zero() {
-	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+    void zero() VL_EXCLUDES(m_mutex) {
+	Verilated::quiesce();
+	VerilatedLockGuard guard(m_mutex);
+	for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
 	    (*it)->zero();
 	}
    }

    // We assume there's always call to i/f/p in that order
-    void inserti (VerilatedCovImpItem* itemp) {
+    void inserti (VerilatedCovImpItem* itemp) VL_EXCLUDES(m_mutex) {
+	VerilatedLockGuard guard(m_mutex);
 	assert(!m_insertp);
 	m_insertp = itemp;
    }
-    void insertf (const char* filenamep, int lineno) {
+    void insertf (const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
+	VerilatedLockGuard guard(m_mutex);
 	m_insertFilenamep = filenamep;
 	m_insertLineno = lineno;
    }
    void insertp (const char* ckeyps[MAX_KEYS],
-		  const char* valps[MAX_KEYS]) {
+		  const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
+	VerilatedLockGuard guard(m_mutex);
 	assert(m_insertp);
 	// First two key/vals are filename
 	ckeyps[0]="filename";	valps[0]=m_insertFilenamep;
-	string linestr = vlCovCvtToStr(m_insertLineno);
+	std::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;
 	const char* fnendp = fnstartp;
 	while (*fnendp && *fnendp!='.') fnendp++;
-	string page_default = "sp_user/"+string(fnstartp,fnendp-fnstartp);
+	std::string page_default = "sp_user/"+std::string(fnstartp,fnendp-fnstartp);
 	ckeyps[2]="page";	valps[2]=page_default.c_str();

 	// Keys -> strings
-	string keys[MAX_KEYS];
-	for (int i=0; i<MAX_KEYS; i++) {
+	std::string keys[MAX_KEYS];
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (ckeyps[i] && ckeyps[i][0]) {
 		keys[i] = ckeyps[i];
 	    }
 	}
 	// Ignore empty keys
-	for (int i=0; i<MAX_KEYS; i++) {
+	for (int i=0; i<MAX_KEYS; ++i) {
 	    if (keys[i]!="") {
-		for (int j=i+1; j<MAX_KEYS; j++) {
+		for (int j=i+1; j<MAX_KEYS; ++j) {
 		    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
 			keys[i] = "";
 			break;
@@ -292,17 +307,17 @@ public:
 	}
 	// Insert the values
 	int addKeynum=0;
-	for (int i=0; i<MAX_KEYS; i++) {
-	    const string key = keys[i];
+	for (int i=0; i<MAX_KEYS; ++i) {
+	    const std::string key = keys[i];
 	    if (keys[i]!="") {
-		const string val = valps[i];
+		const std::string val = valps[i];
 		//cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
 		m_insertp->m_keys[addKeynum] = valueIndex(key);
 		m_insertp->m_vals[addKeynum] = valueIndex(val);
 		addKeynum++;
 		if (!legalKey(key)) {
-		    string msg = "%Error: Coverage keys of one character, or letter+digit are illegal: "+key;
-		    vl_fatal("",0,"",msg.c_str());
+		    std::string msg = "%Error: Coverage keys of one character, or letter+digit are illegal: "+key;
+		    VL_FATAL_MT("",0,"",msg.c_str());
 		}
 	    }
 	}
@@ -311,33 +326,35 @@ public:
 	m_insertp = NULL;
    }

-    void write (const char* filename) {
+    void write(const char* filename) VL_EXCLUDES(m_mutex) {
+	Verilated::quiesce();
+	VerilatedLockGuard guard(m_mutex);
 #ifndef VM_COVERAGE
-	vl_fatal("",0,"","%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
+	VL_FATAL_MT("",0,"","%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
 #endif
 	selftest();

-	ofstream os (filename);
+	std::ofstream os (filename);
 	if (os.fail()) {
-	    string msg = (string)"%Error: Can't write '"+filename+"'";
-	    vl_fatal("",0,"",msg.c_str());
+	    std::string msg = std::string("%Error: Can't write '")+filename+"'";
+	    VL_FATAL_MT("",0,"",msg.c_str());
 	    return;
 	}
 	os << "# SystemC::Coverage-3\n";

 	// Build list of events; totalize if collapsing hierarchy
-	typedef map<string,pair<string,vluint64_t> >	EventMap;
-	EventMap	eventCounts;
+	typedef std::map<std::string,std::pair<std::string,vluint64_t> > EventMap;
+	EventMap eventCounts;
 	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
 	    VerilatedCovImpItem* itemp = *(it);
-	    string name;
-	    string hier;
+	    std::string name;
+	    std::string hier;
 	    bool per_instance = false;

-	    for (int i=0; i<MAX_KEYS; i++) {
+	    for (int i=0; i<MAX_KEYS; ++i) {
 		if (itemp->m_keys[i] != KEY_UNDEF) {
-		    string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
-		    string val = m_indexValues[itemp->m_vals[i]];
+		    std::string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
+		    std::string val = m_indexValues[itemp->m_vals[i]];
 		    if (key == VL_CIK_PER_INSTANCE) {
 			if (val != "0") per_instance = true;
 		    }
@@ -362,21 +379,21 @@ public:
 	    // Find or insert the named event
 	    EventMap::iterator cit = eventCounts.find(name);
 	    if (cit != eventCounts.end()) {
-		const string& oldhier = cit->second.first;
+		const std::string& oldhier = cit->second.first;
 		cit->second.second += itemp->count();
 		cit->second.first  = combineHier(oldhier, hier);
 	    } else {
-		eventCounts.insert(make_pair(name, make_pair(hier,itemp->count())));
+		eventCounts.insert(std::make_pair(name, make_pair(hier,itemp->count())));
 	    }
 	}

 	// Output body
-	for (EventMap::iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
-	    os<<"C '"<<dec;
+	for (EventMap::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
+	    os<<"C '"<<std::dec;
 	    os<<it->first;
 	    if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
 	    os<<"' "<<it->second.second;
-	    os<<endl;
+	    os<<std::endl;
 	}
    }
 };
@@ -384,25 +401,25 @@ public:
 //=============================================================================
 // VerilatedCov

-void VerilatedCov::clear() {
+void VerilatedCov::clear() VL_MT_SAFE {
    VerilatedCovImp::imp().clear();
 }
-void VerilatedCov::clearNonMatch (const char* matchp) {
+void VerilatedCov::clearNonMatch(const char* matchp) VL_MT_SAFE {
    VerilatedCovImp::imp().clearNonMatch(matchp);
 }
-void VerilatedCov::zero() {
+void VerilatedCov::zero() VL_MT_SAFE {
    VerilatedCovImp::imp().zero();
 }
-void VerilatedCov::write (const char* filenamep) {
+void VerilatedCov::write(const char* filenamep) VL_MT_SAFE {
    VerilatedCovImp::imp().write(filenamep);
 }
-void VerilatedCov::_inserti (vluint32_t* itemp) {
+void VerilatedCov::_inserti(vluint32_t* itemp) VL_MT_SAFE {
    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp));
 }
-void VerilatedCov::_inserti (vluint64_t* itemp) {
+void VerilatedCov::_inserti(vluint64_t* itemp) VL_MT_SAFE {
    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp));
 }
-void VerilatedCov::_insertf (const char* filename, int lineno) {
+void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
    VerilatedCovImp::imp().insertf(filename,lineno);
 }

@@ -412,7 +429,7 @@ void VerilatedCov::_insertf (const char* filename, int lineno) {
 #define N(n) "",""	// Null argument list
 void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
 			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
-			     A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) {
+			     A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) VL_MT_SAFE {
    const char* keyps[VerilatedCovImpBase::MAX_KEYS]
 	= {NULL,NULL,NULL,	// filename,lineno,page
 	   key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
@@ -427,22 +444,22 @@ void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
 }

 // And versions with fewer arguments  (oh for a language with named parameters!)
-void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) {
+void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)) VL_MT_SAFE {
    _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
 	     N(10),N(11),N(12),N(13),N(14),N(15),N(16),N(17),N(18),N(19),
 	     N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
 }
 void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
-			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) {
+			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) VL_MT_SAFE {
    _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
 	     C(10),C(11),C(12),C(13),C(14),C(15),C(16),C(17),C(18),C(19),
 	     N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
 }
 // Backward compatibility for Verilator
 void VerilatedCov::_insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
-			     K(4),const string& val4,  A(5),A(6)) {
-    string val2str = vlCovCvtToStr(val2);
-    string val3str = vlCovCvtToStr(val3);
+			     K(4),const std::string& val4,  A(5),A(6)) VL_MT_SAFE {
+    std::string val2str = vlCovCvtToStr(val2);
+    std::string val3str = vlCovCvtToStr(val3);
    _insertp(C(0),C(1),
 	     key2,val2str.c_str(),  key3,val3str.c_str(),  key4, val4.c_str(),
 	     C(5),C(6),N(7),N(8),N(9),
@@ -27,7 +27,6 @@
 #include <iostream>
 #include <sstream>
 #include <string>
-using namespace std;

 //=============================================================================
 /// Conditionally compile coverage code
@@ -60,9 +59,9 @@ using namespace std;
 ///
 ///	vluint32_t m_cases[10];
 ///	constructor {
-///	    for (int i=0; i<10; i++) { m_cases[i]=0; }
+///	    for (int i=0; i<10; ++i) { m_cases[i]=0; }
 ///     }
-///	for (int i=0; i<10; i++) {
+///	for (int i=0; i<10; ++i) {
 ///		VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i));
 ///	}

@@ -74,8 +73,8 @@ using namespace std;
 //=============================================================================
 /// Convert VL_COVER_INSERT value arguments to strings

-template< class T> std::string vlCovCvtToStr (const T& t) {
-    ostringstream os; os<<t; return os.str();
+template< class T> std::string vlCovCvtToStr (const T& t) VL_PURE {
+    std::ostringstream os; os<<t; return os.str();
 }

 //=============================================================================
@@ -83,23 +82,25 @@ template< class T> std::string vlCovCvtToStr (const T& t) {
 ///  Verilator coverage global class
 ////
 /// Global class with methods affecting all coverage data.
+/// All public methods in this class are thread safe.

 class VerilatedCov {
+    VL_UNCOPYABLE(VerilatedCov);
 public:
    // GLOBAL METHODS
    /// Return default filename
-    static const char* defaultFilename() { return "coverage.dat"; }
+    static const char* defaultFilename() VL_PURE { return "coverage.dat"; }
    /// Write all coverage data to a file
-    static void write (const char* filenamep = defaultFilename());
+    static void write (const char* filenamep = defaultFilename()) VL_MT_SAFE;
    /// Insert a coverage item
    /// We accept from 1-30 key/value pairs, all as strings.
    /// Call _insert1, followed by _insert2 and _insert3
    /// Do not call directly; use VL_COVER_INSERT or higher level macros instead
    // _insert1: Remember item pointer with count.  (Not const, as may add zeroing function)
-    static void _inserti (vluint32_t* itemp);
-    static void _inserti (vluint64_t* itemp);
+    static void _inserti (vluint32_t* itemp) VL_MT_SAFE;
+    static void _inserti (vluint64_t* itemp) VL_MT_SAFE;
    // _insert2: Set default filename and line number
-    static void _insertf (const char* filename, int lineno);
+    static void _insertf (const char* filename, int lineno) VL_MT_SAFE;
    // _insert3: Set parameters
    // We could have just the maximum argument version, but this compiles
    // much slower (nearly 2x) than having smaller versions also.  However
@@ -115,17 +116,17 @@ public:
 			  ,A(20),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
    // Backward compatibility for Verilator
    static void _insertp (A(0), A(1),  K(2),int val2,  K(3),int val3,
-			  K(4),const string& val4,  A(5),A(6));
+			  K(4),const std::string& val4,  A(5),A(6));

 #undef K
 #undef A
 #undef D
    /// Clear coverage points (and call delete on all items)
-    static void clear();
+    static void clear() VL_MT_SAFE;
    /// Clear items not matching the provided string
-    static void clearNonMatch (const char* matchp);
+    static void clearNonMatch (const char* matchp) VL_MT_SAFE;
    /// Zero coverage points
-    static void zero();
+    static void zero() VL_MT_SAFE;
 };

 #endif // guard
@@ -25,7 +25,6 @@
 #include "verilatedos.h"

 #include <string>
-using namespace std;

 //=============================================================================
 // Data used to edit below file, using vlcovgen
@@ -64,12 +63,6 @@ VLCOVGEN_ITEM("name=>'row2',        short=>'r2', group=>0, default=>undef, ")
 VLCOVGEN_ITEM("name=>'row3',        short=>'r3', group=>0, default=>undef, ")
 VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr=>'For totaling items, weight of this item'")

-//=============================================================================
-//  VerilatedCovKey
-///  Verilator coverage global class
-////
-/// Global class with methods affecting all coverage data.
-
 // VLCOVGEN_CIK_AUTO_EDIT_BEGIN
 #define VL_CIK_COL0 "c0"
 #define VL_CIK_COL0_NAME "C0"
@@ -103,9 +96,14 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 #define VL_CIK_WEIGHT "w"
 // VLCOVGEN_CIK_AUTO_EDIT_END

+//=============================================================================
+// VerilatedCovKey
+/// Verilator coverage global class.
+/// This class is thread safe.
+
 class VerilatedCovKey {
 public:
-    static string shortKey(const string& key) {
+    static std::string shortKey(const std::string& key) VL_PURE {
 	// VLCOVGEN_SHORT_AUTO_EDIT_BEGIN
 	if (key == "col0") return VL_CIK_COL0;
 	if (key == "col0_name") return VL_CIK_COL0_NAME;
@@ -30,7 +30,9 @@

 // On MSVC++ we need svdpi.h to declare exports, not imports
 #define DPI_PROTOTYPES
+#undef XXTERN
 #define XXTERN DPI_EXTERN DPI_DLLESPEC
+#undef EETERN
 #define EETERN DPI_EXTERN DPI_DLLESPEC

 #include "vltstd/svdpi.h"
@@ -40,11 +42,11 @@

 // Not supported yet
 #define _VL_SVDPI_UNIMP() \
-    vl_fatal(__FILE__,__LINE__,"",(string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())
+    VL_FATAL_MT(__FILE__,__LINE__,"",(std::string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())

 // Function requires a "context" in the import declaration
 #define _VL_SVDPI_CONTEXT_WARN() \
-    VL_PRINTF("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");
+    VL_PRINTF_MT("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");

 //======================================================================
 //======================================================================
@@ -58,31 +60,31 @@ const char* svDpiVersion() {
 //======================================================================
 // Bit-select utility functions.

-svBit svGetBitselBit(const svBitVecVal* s, int i) {
-    _VL_SVDPI_UNIMP(); return 0;
+svBit svGetBitselBit(const svBitVecVal* sp, int bit) {
+    return VL_BITISSET_W(sp,bit);
 }
-svLogic svGetBitselLogic(const svLogicVecVal* s, int i) {
+svLogic svGetBitselLogic(const svLogicVecVal* sp, int bit) {
    _VL_SVDPI_UNIMP(); return 0;
 }

-void svPutBitselBit(svBitVecVal* d, int i, svBit s) {
-    _VL_SVDPI_UNIMP();
+void svPutBitselBit(svBitVecVal* dp, int bit, svBit s) {
+    VL_ASSIGNBIT_WI(32, bit, dp, s);
 }
-void svPutBitselLogic(svLogicVecVal* d, int i, svLogic s) {
+void svPutBitselLogic(svLogicVecVal* dp, int bit, svLogic s) {
    _VL_SVDPI_UNIMP();
 }

-void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w) {
+void svGetPartselBit(svBitVecVal* dp, const svBitVecVal* sp, int i, int w) {
    _VL_SVDPI_UNIMP();
 }
-void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
+void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int i, int w) {
    _VL_SVDPI_UNIMP();
 }

-void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w) {
+void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int i, int w) {
    _VL_SVDPI_UNIMP();
 }
-void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
+void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int i, int w) {
    _VL_SVDPI_UNIMP();
 }

@@ -261,13 +263,13 @@ svScope svGetScope() {

 svScope svSetScope(const svScope scope) {
    const VerilatedScope* prevScopep = Verilated::dpiScope();
-    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
    Verilated::dpiScope(vscopep);
    return (svScope)prevScopep;
 }

 const char* svGetNameFromScope(const svScope scope) {
-    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    const VerilatedScope* vscopep = reinterpret_cast<const VerilatedScope*>(scope);
    return vscopep->name();
 }

@@ -16,9 +16,9 @@
 /// \file
 /// \brief Verilator: Common include for all Verilated C files that use DPI
 ///
-///	This file is included automatically by Verilator at the top of
-///	all C++ files it generates where DPI is used.  It contains
-///	DPI interface functions required by the Verilated code.
+///     This file is included automatically by Verilator at the top of
+///     all C++ files it generates where DPI is used.  It contains
+///     DPI interface functions required by the Verilated code.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -35,27 +35,27 @@
 // SETTING OPERATORS

 /// Return svBitVecVal from WData
-static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) {
+static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) VL_MT_SAFE {
    int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
 }
-static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) {
+static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) VL_MT_SAFE {
    int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
 }
-static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) {
+static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) VL_MT_SAFE {
    // Note we ignore X/Z in svLogicVecVal
    int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; i++) owp[i]=lwp[i].aval;
+    for (int i=0; i<words-1; ++i) owp[i]=lwp[i].aval;
    owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits);
 }
-static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) {
+static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) VL_MT_SAFE {
    // Note we don't create X/Z in svLogicVecVal
    int words = VL_WORDS_I(obits);
-    for (int i=0; i<words; i++) owp[i].bval=0;
-    for (int i=0; i<words-1; i++) owp[i].aval=lwp[i];
+    for (int i=0; i<words; ++i) owp[i].bval=0;
+    for (int i=0; i<words-1; ++i) owp[i].aval=lwp[i];
    owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits);
 }

@@ -16,10 +16,10 @@
 /// \file
 /// \brief Verilator: String include for all Verilated C files
 ///
-///	This file is included automatically by Verilator at the top of
-///	all C++ files it generates.  It is used when strings or other
-///	heavyweight types are required; these contents are not part of
-///	verilated.h to save compile time when such types aren't used.
+///     This file is included automatically by Verilator at the top of
+///     all C++ files it generates.  It is used when strings or other
+///     heavyweight types are required; these contents are not part of
+///     verilated.h to save compile time when such types aren't used.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -36,36 +36,49 @@
 //======================================================================
 // Conversion functions

-extern string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp);
-inline string VL_CVT_PACK_STR_NQ(QData lhs) {
-    IData lw[2];  VL_SET_WQ(lw, lhs);
+extern std::string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) VL_MT_SAFE;
+inline std::string VL_CVT_PACK_STR_NQ(QData lhs) VL_PURE {
+    WData lw[2];  VL_SET_WQ(lw, lhs);
    return VL_CVT_PACK_STR_NW(2, lw);
 }
-inline string VL_CVT_PACK_STR_NN(const string& lhs) {
+inline std::string VL_CVT_PACK_STR_NN(const std::string& lhs) VL_PURE {
    return lhs;
 }
-inline string VL_CVT_PACK_STR_NI(IData lhs) {
-    IData lw[1];  lw[0] = lhs;
+inline std::string VL_CVT_PACK_STR_NI(IData lhs) VL_PURE {
+    WData lw[1];  lw[0] = lhs;
    return VL_CVT_PACK_STR_NW(1, lw);
 }
-inline string VL_CONCATN_NNN(const string& lhs, const string& rhs) {
+inline std::string VL_CONCATN_NNN(const std::string& lhs, const std::string& rhs) VL_PURE {
    return lhs+rhs;
 }
-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;
+inline std::string VL_REPLICATEN_NNQ(int,int,int, const std::string& lhs, IData rep) VL_PURE {
+    std::string out; out.reserve(lhs.length() * rep);
+    for (unsigned times=0; times<rep; ++times) out += lhs;
    return out;
 }
-inline string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const string& lhs, IData rep) {
+inline std::string VL_REPLICATEN_NNI(int obits,int lbits,int rbits, const std::string& lhs, IData rep) VL_PURE {
    return VL_REPLICATEN_NNQ(obits,lbits,rbits,lhs,rep);
 }

-extern IData VL_FOPEN_NI(const string& filename, IData mode);
+extern IData VL_FOPEN_NI(const std::string& filename, IData mode) VL_MT_SAFE;
 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);
+                         const std::string& ofilename, void* memp, IData start, IData end) VL_MT_SAFE;
+extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp, ...) VL_MT_SAFE;
+extern void VL_SFORMAT_X(int obits_ignored, std::string &output, const char* formatp, ...) VL_MT_SAFE;
+extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
+extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rdp) VL_MT_SAFE;
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
+    WData rwp[2];  // WData must always be at least 2
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = rwp[0];
+    return got;
+}
+inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, QData& rdr) VL_MT_SAFE {
+    WData rwp[2];
+    IData got = VL_VALUEPLUSARGS_INW(rbits,ld,rwp);
+    if (got) rdr = VL_SET_QW(rwp);
+    return got;
+}
+extern IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_SAFE;

 #endif // Guard
@@ -34,108 +34,254 @@
 #include "verilated_syms.h"

 #include <map>
+#include <set>
 #include <vector>
 #include <deque>
 #include <string>
+#ifdef VL_THREADED
+# include <functional>
+# include <queue>
+#endif

 class VerilatedScope;

 //======================================================================
-// Types
+// Threaded message passing
+
+#ifdef VL_THREADED
+/// Message, enqueued on a train, and consumed on the main eval thread
+class VerilatedMsg {
+public:
+    // TYPES
+    struct Cmp {
+	bool operator() (const VerilatedMsg& a, const VerilatedMsg& b) {
+	    return a.trainId() < b.trainId(); }
+    };
+private:
+    // MEMBERS
+    vluint32_t 		m_trainId;  	///< Train that did enqueue
+    std::function<void()> m_cb; 	///< Lambda to execute when message received
+public:
+    // CONSTRUCTORS
+    VerilatedMsg(const std::function<void()>& cb)
+	: m_trainId(Verilated::trainId()), m_cb(cb) {}
+    ~VerilatedMsg() {}
+    // METHODS
+    vluint32_t trainId() const { return m_trainId; }
+    /// Execute the lambda function
+    void run() const { m_cb(); }
+};
+
+/// Each thread has a queue it pushes to
+/// This assumes no thread starts pushing the next tick until the previous has drained.
+/// If more aggressiveness is needed, a double-buffered scheme might work well.
+class VerilatedEvalMsgQueue  {
+    typedef std::multiset<VerilatedMsg, VerilatedMsg::Cmp> VerilatedThreadQueue;
+
+    std::atomic<vluint64_t> m_depth;  ///< Current depth of queue (see comments below)
+
+    VerilatedMutex m_mutex;  ///< Mutex protecting queue
+    VerilatedThreadQueue m_queue VL_GUARDED_BY(m_mutex);  ///< Message queue
+public:
+    // CONSTRUCTORS
+    VerilatedEvalMsgQueue() : m_depth(0) { }
+    ~VerilatedEvalMsgQueue() { }
+private:
+    VL_UNCOPYABLE(VerilatedEvalMsgQueue);
+public:
+    // METHODS
+    //// Add message to queue (called by producer)
+    void post(const VerilatedMsg& msg) VL_EXCLUDES(m_mutex) {
+	Verilated::endOfEvalReqdInc(); // No mutex, threadsafe
+	VerilatedLockGuard guard(m_mutex);
+	m_queue.insert(msg);  // Pass by value to copy the message into queue
+	++m_depth;
+    }
+    /// Service queue until completion (called by consumer)
+    void process() VL_EXCLUDES(m_mutex) {
+	// Tracking m_depth is redundant to e.g. getting the mutex and looking at queue size,
+	// but on the reader side it's 4x faster to test an atomic then getting a mutex
+	while (m_depth) {
+	    // Wait for a message to be added to the queue
+	    // We don't use unique_lock as want to unlock with the message copy still in scope
+	    m_mutex.lock();
+	    assert(!m_queue.empty()); // Otherwise m_depth is wrong
+	    // Unfortunately to release the lock we need to copy the message
+	    // (Or have the message be a pointer, but then new/delete cost on each message)
+	    // We assume messages are small, so copy
+	    auto it = m_queue.begin();
+	    const VerilatedMsg msg = *(it);
+	    m_queue.erase(it);
+	    m_mutex.unlock();
+	    m_depth--;  // Ok if outside critical section as only this code checks the value
+	    Verilated::endOfEvalReqdDec(); // No mutex, threadsafe
+	    {
+		VL_DEBUG_IF(VL_DBG_MSGF("Executing callback from trainId=%d\n", msg.trainId()););
+		msg.run();
+	    }
+	}
+    }
+};
+
+/// Each thread has a local queue to build up messages until the end of the eval() call
+class VerilatedThreadMsgQueue  {
+    std::queue<VerilatedMsg> m_queue;
+public:
+    // CONSTRUCTORS
+    VerilatedThreadMsgQueue() { }
+    ~VerilatedThreadMsgQueue() {
+	// The only call of this with a non-empty queue is a fatal error.
+	// So this does not flush the queue, as the destination queue is not known to this class.
+    }
+private:
+    VL_UNCOPYABLE(VerilatedThreadMsgQueue);
+    // METHODS
+    static VerilatedThreadMsgQueue& threadton() {
+	static VL_THREAD_LOCAL VerilatedThreadMsgQueue t_s;
+	return t_s;
+    }
+public:
+    /// Add message to queue, called by producer
+    static void post(const VerilatedMsg& msg) VL_MT_SAFE {
+	Verilated::endOfEvalReqdInc();
+	threadton().m_queue.push(msg);  // Pass by value to copy the message into queue
+    }
+    /// Push all messages to the eval's queue
+    static void flush(VerilatedEvalMsgQueue* evalMsgQp) VL_MT_SAFE {
+	while (!threadton().m_queue.empty()) {
+	    evalMsgQp->post(threadton().m_queue.front());
+	    threadton().m_queue.pop();
+	    Verilated::endOfEvalReqdDec();
+	}
+    }
+};
+#endif // VL_THREADED
+
+//======================================================================
+// VerilatedImp

 class VerilatedImp {
    // Whole class is internal use only - Global information shared between verilated*.cpp files.

    // TYPES
-    typedef vector<string> ArgVec;
-    typedef map<pair<const void*,void*>,void*> UserMap;
-    typedef map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
+    typedef std::vector<std::string> ArgVec;
+    typedef std::map<std::pair<const void*,void*>,void*> UserMap;
+    typedef std::map<const char*, int, VerilatedCStrCmp>  ExportNameMap;

    // MEMBERS
    static VerilatedImp	s_s;		///< Static Singleton; One and only static this

    // Nothing here is save-restored; users expected to re-register appropriately

-    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>
-    VerilatedScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
+    VerilatedMutex      m_argMutex;  ///< Protect m_argVec, m_argVecLoaded
+    ArgVec              m_argVec VL_GUARDED_BY(m_argMutex);  ///< Argument list (NOT save-restored, may want different results)
+    bool                m_argVecLoaded VL_GUARDED_BY(m_argMutex);  ///< Ever loaded argument list
+
+    VerilatedMutex      m_userMapMutex;  ///< Protect m_userMap
+    UserMap             m_userMap VL_GUARDED_BY(m_userMapMutex);  ///< Map of <(scope,userkey), userData>
+
+    VerilatedMutex      m_nameMutex;  ///< Protect m_nameMap
+    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);  ///< 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
+    VerilatedMutex      m_exportMutex;  ///< Protect m_nameMap
+    ExportNameMap       m_exportMap VL_GUARDED_BY(m_exportMutex);  ///< Map of <export_func_proto, func number>
+    int                 m_exportNext VL_GUARDED_BY(m_exportMutex);  ///< Next export funcnum

    // File I/O
-    vector<FILE*>	m_fdps;		///< File descriptors
-    deque<IData>	m_fdFree;	///< List of free descriptors (SLOW - FOPEN/CLOSE only)
+    VerilatedMutex      m_fdMutex;  ///< Protect m_fdps, m_fdFree
+    std::vector<FILE*>  m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
+    std::deque<IData>   m_fdFree VL_GUARDED_BY(m_fdMutex);  ///< List of free descriptors (SLOW - FOPEN/CLOSE only)
+
+    // Threads
+    VerilatedMutex      m_threadMutex;  ///< Protect m_numThreads, etc
+    bool                m_spawned VL_GUARDED_BY(m_threadMutex);  ///< Already called spawnThreads()
+    unsigned            m_numThreads VL_GUARDED_BY(m_threadMutex);  ///< Number of threads user requested, 0x0=all cpus

 public: // But only for verilated*.cpp
    // CONSTRUCTORS
-    VerilatedImp() : m_argVecLoaded(false), m_exportNext(0) {
+    VerilatedImp()
+	: m_argVecLoaded(false), m_exportNext(0), m_spawned(false), m_numThreads(0) {
 	m_fdps.resize(3);
 	m_fdps[0] = stdin;
 	m_fdps[1] = stdout;
 	m_fdps[2] = stderr;
    }
    ~VerilatedImp() {}
-    static void internalsDump() {
-	VL_PRINTF("internalsDump:\n");
-	VL_PRINTF("  Argv:");
-	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
-	    VL_PRINTF(" %s",it->c_str());
+private:
+    VL_UNCOPYABLE(VerilatedImp);
+public:
+    static void internalsDump() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_argMutex);
+	VL_PRINTF_MT("internalsDump:\n");
+	VL_PRINTF_MT("  Argv:");
+	for (ArgVec::const_iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
+	    VL_PRINTF_MT(" %s",it->c_str());
 	}
-	VL_PRINTF("\n");
-	VL_PRINTF("  Version: %s %s\n", Verilated::productName(), Verilated::productVersion());
+	VL_PRINTF_MT("\n");
+	VL_PRINTF_MT("  Version: %s %s\n", Verilated::productName(), Verilated::productVersion());
 	scopesDump();
 	exportsDump();
 	userDump();
    }

    // METHODS - arguments
-    static void commandArgs(int argc, const char** argv) {
+public:
+    static void commandArgs(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex) {
+	VerilatedLockGuard guard(s_s.m_argMutex);
 	s_s.m_argVec.clear();  // Always clear
-	commandArgsAdd(argc, argv);
+	commandArgsAddGuts(argc, argv);
    }
-    static void commandArgsAdd(int argc, const char** argv) {
-	if (!s_s.m_argVecLoaded) s_s.m_argVec.clear();
-	for (int i=0; i<argc; i++) s_s.m_argVec.push_back(argv[i]);
-	s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
+    static void commandArgsAdd(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex) {
+	VerilatedLockGuard guard(s_s.m_argMutex);
+	commandArgsAddGuts(argc, argv);
    }
-    static string argPlusMatch(const char* prefixp) {
+    static std::string argPlusMatch(const char* prefixp) VL_EXCLUDES(s_s.m_argMutex) {
+	VerilatedLockGuard guard(s_s.m_argMutex);
 	// Note prefixp does not include the leading "+"
 	size_t len = strlen(prefixp);
 	if (VL_UNLIKELY(!s_s.m_argVecLoaded)) {
 	    s_s.m_argVecLoaded = true;  // Complain only once
-	    vl_fatal("unknown",0,"",
-		     "%Error: Verilog called $test$plusargs or $value$plusargs without"
-		     " testbench C first calling Verilated::commandArgs(argc,argv).");
+	    VL_FATAL_MT("unknown",0,"",
+			"%Error: Verilog called $test$plusargs or $value$plusargs without"
+			" testbench C first calling Verilated::commandArgs(argc,argv).");
 	}
-	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
+	for (ArgVec::const_iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
 	    if ((*it)[0]=='+') {
 		if (0==strncmp(prefixp, it->c_str()+1, len)) return *it;
 	    }
 	}
 	return "";
    }
+private:
+    static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex) {
+	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
+    }

+public:
    // METHODS - user scope tracking
    // We implement this as a single large map instead of one map per scope
    // There's often many more scopes than userdata's and thus having a ~48byte
    // per map overhead * N scopes would take much more space and cache thrashing.
-    static inline void userInsert(const void* scopep, void* userKey, void* userData) {
-	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
+    static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_userMapMutex);
+	UserMap::iterator it=s_s.m_userMap.find(std::make_pair(scopep,userKey));
 	if (it != s_s.m_userMap.end()) it->second = userData;
 	// When we support VL_THREADs, we need a lock around this insert, as it's runtime
-	else s_s.m_userMap.insert(it, make_pair(make_pair(scopep,userKey),userData));
+	else s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep,userKey),userData));
    }
-    static inline void* userFind(const void* scopep, void* userKey) {
-	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
+    static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_userMapMutex);
+	UserMap::const_iterator it=s_s.m_userMap.find(std::make_pair(scopep,userKey));
 	if (VL_LIKELY(it != s_s.m_userMap.end())) return it->second;
 	else return NULL;
    }
 private:
    /// Symbol table destruction cleans up the entries for each scope.
-    static void userEraseScope(const VerilatedScope* scopep) {
+    static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
 	// Slow ok - called once/scope on destruction, so we simply iterate.
+	VerilatedLockGuard guard(s_s.m_userMapMutex);
 	for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ) {
 	    if (it->first.first == scopep) {
 		s_s.m_userMap.erase(it++);
@@ -144,44 +290,50 @@ private:
 	    }
 	}
    }
-    static void userDump() {
+    static void userDump() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_userMapMutex);  // Avoid it changing in middle of dump
 	bool first = true;
-	for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ++it) {
-	    if (first) { VL_PRINTF("  userDump:\n"); first=false; }
-	    VL_PRINTF("    DPI_USER_DATA scope %p key %p: %p\n",
+	for (UserMap::const_iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ++it) {
+	    if (first) { VL_PRINTF_MT("  userDump:\n"); first=false; }
+	    VL_PRINTF_MT("    DPI_USER_DATA scope %p key %p: %p\n",
 		      it->first.first, it->first.second, it->second);
 	}
    }

 public: // But only for verilated*.cpp
    // METHODS - scope name
-    static void scopeInsert(const VerilatedScope* scopep) {
+    static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
 	// Slow ok - called once/scope at construction
+	VerilatedLockGuard guard(s_s.m_nameMutex);
 	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));
+	    s_s.m_nameMap.insert(it, std::make_pair(scopep->name(),scopep));
 	}
    }
-    static inline const VerilatedScope* scopeFind(const char* namep) {
-	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
+    static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_nameMutex);  // If too slow, can assume this is only VL_MT_SAFE_POSINIT
+	VerilatedScopeNameMap::const_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) {
+    static void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
 	// Slow ok - called once/scope at destruction
+	VerilatedLockGuard guard(s_s.m_nameMutex);
 	userEraseScope(scopep);
 	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 (VerilatedScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
+    static void scopesDump() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_nameMutex);
+	VL_PRINTF_MT("  scopesDump:\n");
+	for (VerilatedScopeNameMap::const_iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
 	    const VerilatedScope* scopep = it->second;
 	    scopep->scopeDump();
 	}
-	VL_PRINTF("\n");
+	VL_PRINTF_MT("\n");
    }
-    static const VerilatedScopeNameMap* scopeNameMap() {
+    static const VerilatedScopeNameMap* scopeNameMap() VL_MT_SAFE_POSTINIT {
+	// Thread save only assuming this is called only after model construction completed
        return &s_s.m_nameMap;
    }

@@ -194,36 +346,40 @@ public: // But only for verilated*.cpp
    // in the design that also happen to have our same callback function.
    // Rather than a 2D map, the integer scheme saves 500ish ns on a likely
    // miss at the cost of a multiply, and all lookups move to slowpath.
-    static int exportInsert(const char* namep) {
+    static int exportInsert(const char* namep) VL_MT_SAFE {
 	// Slow ok - called once/function at creation
+	VerilatedLockGuard guard(s_s.m_exportMutex);
 	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
 	if (it == s_s.m_exportMap.end()) {
-	    s_s.m_exportMap.insert(it, make_pair(namep, s_s.m_exportNext++));
+	    s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++));
 	    return s_s.m_exportNext++;
 	} else {
 	    return it->second;
 	}
    }
-    static int exportFind(const char* namep) {
-	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
+    static int exportFind(const char* namep) VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_exportMutex);
+	ExportNameMap::const_iterator it=s_s.m_exportMap.find(namep);
 	if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
-	string msg = (string("%Error: Testbench C called ")+namep
-		      +" but no such DPI export function name exists in ANY model");
-	vl_fatal("unknown",0,"", msg.c_str());
+	std::string msg = (std::string("%Error: Testbench C called ")+namep
+			   +" but no such DPI export function name exists in ANY model");
+	VL_FATAL_MT("unknown",0,"", msg.c_str());
 	return -1;
    }
-    static const char* exportName(int funcnum) {
+    static const char* exportName(int funcnum) VL_MT_SAFE {
 	// Slowpath; find name for given export; errors only so no map to reverse-map it
-	for (ExportNameMap::iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
+	VerilatedLockGuard guard(s_s.m_exportMutex);
+	for (ExportNameMap::const_iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
 	    if (it->second == funcnum) return it->first;
 	}
 	return "*UNKNOWN*";
    }
-    static void exportsDump() {
+    static void exportsDump() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_exportMutex);
 	bool first = true;
-	for (ExportNameMap::iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
-	    if (first) { VL_PRINTF("  exportDump:\n"); first=false; }
-	    VL_PRINTF("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
+	for (ExportNameMap::const_iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
+	    if (first) { VL_PRINTF_MT("  exportDump:\n"); first=false; }
+	    VL_PRINTF_MT("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
 	}
    }
    // We don't free up m_exportMap until the end, because we can't be sure
@@ -231,31 +387,67 @@ public: // But only for verilated*.cpp

 public: // But only for verilated*.cpp
    // METHODS - file IO
-    static IData fdNew(FILE* fp) {
+    static IData fdNew(FILE* fp) VL_MT_SAFE {
 	if (VL_UNLIKELY(!fp)) return 0;
 	// Bit 31 indicates it's a descriptor not a MCD
+	VerilatedLockGuard guard(s_s.m_fdMutex);
 	if (s_s.m_fdFree.empty()) {
 	    // Need to create more space in m_fdps and m_fdFree
 	    size_t start = s_s.m_fdps.size();
 	    s_s.m_fdps.resize(start*2);
-	    for (size_t i=start; i<start*2; i++) s_s.m_fdFree.push_back((IData)i);
+	    for (size_t i=start; i<start*2; ++i) s_s.m_fdFree.push_back(static_cast<IData>(i));
 	}
 	IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
 	s_s.m_fdps[idx] = fp;
 	return (idx | (1UL<<31));  // bit 31 indicates not MCD
    }
-    static void fdDelete(IData fdi) {
+    static void fdDelete(IData fdi) VL_MT_SAFE {
 	IData idx = VL_MASK_I(31) & fdi;
+	VerilatedLockGuard guard(s_s.m_fdMutex);
 	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return;
 	if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
 	s_s.m_fdps[idx] = NULL;
 	s_s.m_fdFree.push_back(idx);
    }
-    static inline FILE* fdToFp(IData fdi) {
+    static inline FILE* fdToFp(IData fdi) VL_MT_SAFE {
 	IData idx = VL_MASK_I(31) & fdi;
+	VerilatedLockGuard guard(s_s.m_fdMutex);  // This might get slow, if it does we can cache it
 	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return NULL;
 	return s_s.m_fdps[idx];
    }
+
+public: // But only for verilated*.cpp
+    // METHODS - Threading
+    static void numThreads(unsigned threads) VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_threadMutex);
+	if (!s_s.m_spawned) s_s.m_numThreads = threads;
+    }
+    static unsigned numThreads() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_threadMutex);
+#ifdef VL_THREADED
+	unsigned threads = s_s.m_numThreads;
+	if (threads == 0x0) {
+	    threads = std::thread::hardware_concurrency(); // Or 0=unknown, C++11
+	}
+	if (threads<1) threads = 1;
+	return threads;
+#else
+	return 0;
+#endif
+    }
+    static void spawnThreads() VL_MT_SAFE {
+	VerilatedLockGuard guard(s_s.m_threadMutex);
+	if (!s_s.m_spawned) {
+	    // Convert numThreads from 0 to the spawned number
+	    numThreads(numThreads());
+	    s_s.m_spawned = true;
+#ifdef VL_THREADED
+	    // THREADED-TODO startup threads
+#endif
+	}
+    }
 };

+//======================================================================
+
 #endif  // Guard
@@ -40,15 +40,15 @@
 #endif

 // CONSTANTS
-static const char* VLTSAVE_HEADER_STR = "verilatorsave01\n";	///< Value of first bytes of each file
-static const char* VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last bytes of each file
+static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";	///< Value of first bytes of each file
+static const char* const VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last bytes of each file

 //=============================================================================
 //=============================================================================
 //=============================================================================
 // Searalization

-bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t size) {
+bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
    bufferCheck();
    const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
    vluint8_t miss = 0;
@@ -58,17 +58,17 @@ bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t siz
    return (miss!=0);
 }

-VerilatedDeserialize& VerilatedDeserialize::readAssert (const void* __restrict datap, size_t size) {
+VerilatedDeserialize& VerilatedDeserialize::readAssert (const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
    if (VL_UNLIKELY(readDiffers(datap,size))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize save-restore file as was made from different model";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
+	std::string fn = filename();
+	std::string msg = std::string("Can't deserialize save-restore file as was made from different model");
+	VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
 	close();
    }
    return *this;  // For function chaining
 }

-void VerilatedSerialize::header() {
+void VerilatedSerialize::header() VL_MT_UNSAFE_ONE {
    VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
    assert((strlen(VLTSAVE_HEADER_STR) & 7) == 0);  // Keep aligned
    os.write(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR));
@@ -78,29 +78,29 @@ void VerilatedSerialize::header() {
    os.write(Verilated::serializedPtr(), Verilated::serializedSize());
 }

-void VerilatedDeserialize::header() {
+void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
    VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
    if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR)))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize; file has wrong header signature";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
+	std::string fn = filename();
+	std::string msg = std::string("Can't deserialize; file has wrong header signature");
+	VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
 	close();
    }
    os.read(Verilated::serializedPtr(), Verilated::serializedSize());
 }

-void VerilatedSerialize::trailer() {
+void VerilatedSerialize::trailer() VL_MT_UNSAFE_ONE {
    VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
    assert((strlen(VLTSAVE_TRAILER_STR) & 7) == 0);  // Keep aligned
    os.write(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR));
 }

-void VerilatedDeserialize::trailer() {
+void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
    VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
    if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR)))) {
-	string fn = filename();
-	string msg = (string)"Can't deserialize; file has wrong end-of-file signature";
-	vl_fatal(fn.c_str(), 0, "", msg.c_str());
+	std::string fn = filename();
+	std::string msg = std::string("Can't deserialize; file has wrong end-of-file signature");
+	VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
 	close();
    }
 }
@@ -110,9 +110,10 @@ void VerilatedDeserialize::trailer() {
 //=============================================================================
 // Opening/Closing

-void VerilatedSave::open (const char* filenamep) {
+void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
    if (isOpen()) return;
-    VL_DEBUG_IF(VL_PRINTF("-vltSave: opening save file %s\n",filenamep););
+    VL_DEBUG_IF(VL_DBG_MSGF("- save: opening save file %s\n",filenamep););

    if (filenamep[0]=='|') {
 	assert(0);	// Not supported yet.
@@ -132,9 +133,10 @@ void VerilatedSave::open (const char* filenamep) {
    header();
 }

-void VerilatedRestore::open (const char* filenamep) {
+void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
    if (isOpen()) return;
-    VL_DEBUG_IF(VL_PRINTF("-vltRestore: opening restore file %s\n",filenamep););
+    VL_DEBUG_IF(VL_DBG_MSGF("- restore: opening restore file %s\n",filenamep););

    if (filenamep[0]=='|') {
 	assert(0);	// Not supported yet.
@@ -155,7 +157,7 @@ void VerilatedRestore::open (const char* filenamep) {
    header();
 }

-void VerilatedSave::close () {
+void VerilatedSave::close() VL_MT_UNSAFE_ONE {
    if (!isOpen()) return;
    trailer();
    flush();
@@ -163,7 +165,7 @@ void VerilatedSave::close () {
    ::close(m_fd);  // May get error, just ignore it
 }

-void VerilatedRestore::close () {
+void VerilatedRestore::close() VL_MT_UNSAFE_ONE {
    if (!isOpen()) return;
    trailer();
    flush();
@@ -174,7 +176,8 @@ void VerilatedRestore::close () {
 //=============================================================================
 // Buffer management

-void VerilatedSave::flush() {
+void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
    if (VL_UNLIKELY(!isOpen())) return;
    vluint8_t* wp = m_bufp;
    while (1) {
@@ -187,8 +190,8 @@ void VerilatedSave::flush() {
 	} else if (got < 0) {
 	    if (errno != EAGAIN && errno != EINTR) {
 		// write failed, presume error (perhaps out of disk space)
-		string msg = string(__FUNCTION__)+": "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
+		std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+		VL_FATAL_MT("",0,"",msg.c_str());
 		close();
 		break;
 	    }
@@ -197,14 +200,15 @@ void VerilatedSave::flush() {
    m_cp = m_bufp; // Reset buffer
 }

-void VerilatedRestore::fill() {
+void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
    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; 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 
+    // Read into buffer starting at m_endp
    while (1) {
 	ssize_t remaining = (m_bufp+bufferSize() - m_endp);
 	if (remaining==0) break;
@@ -215,8 +219,8 @@ void VerilatedRestore::fill() {
 	} else if (got < 0) {
 	    if (errno != EAGAIN && errno != EINTR) {
 		// write failed, presume error (perhaps out of disk space)
-		string msg = string(__FUNCTION__)+": "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
+		std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+		VL_FATAL_MT("",0,"",msg.c_str());
 		close();
 		break;
 	    }
@@ -25,67 +25,45 @@
 #include "verilatedos.h"

 #include <string>
-using namespace std;

 //=============================================================================
-// VerilatedSerialBase - internal base class for common code between VerilatedSerialize and VerilatedDeserialize
+// VerilatedSerialize - convert structures to a stream representation
+// This class is not thread safe, it must be called by a single thread

-class VerilatedSerialBase {
+class VerilatedSerialize {
 protected:
    // MEMBERS
    // For speed, keep m_cp as the first member of this structure
    vluint8_t*		m_cp;		///< Current pointer into m_bufp buffer
    vluint8_t*		m_bufp;		///< Output buffer
    bool 		m_isOpen;	///< True indicates open file/stream
-    string		m_filename;
+    std::string		m_filename;	///< Filename, for error messages
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread

    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
    inline static size_t bufferInsertSize() { return 16*1024; }

-    // CREATORS
-    VerilatedSerialBase() {
+    void header() VL_MT_UNSAFE_ONE;
+    void trailer() VL_MT_UNSAFE_ONE;
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedSerialize);
+public:
+    VerilatedSerialize() {
 	m_isOpen = false;
 	m_bufp = new vluint8_t [bufferSize()];
 	m_cp = m_bufp;
    }
-private:
-    VerilatedSerialBase(const VerilatedSerialBase& );	///< N/A, no copy constructor
-public:
-    // CREATORS
-    virtual ~VerilatedSerialBase() {
+    virtual ~VerilatedSerialize() {
 	close();
 	if (m_bufp) { delete m_bufp; m_bufp=NULL; }
    }
    // METHODS
    bool isOpen() const { return m_isOpen; }
-    string filename() const { return m_filename; }
-    virtual void close() { flush(); }
-    virtual void flush() {}
-};
-
-//=============================================================================
-// VerilatedSerialize - convert structures to a stream representation
-
-class VerilatedSerialize : public VerilatedSerialBase {
-protected:
-    virtual void close() { flush(); }
-    virtual void flush() {}
-    void header();
-    void trailer();
-public:
-    // CREATORS
-    VerilatedSerialize() {}
-    virtual ~VerilatedSerialize() { close(); }
-    // METHODS
-    VerilatedSerialize& bufferCheck() {
-	// Flush the write buffer if there's not enough space left for new information
-	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
-	    flush();
-	}
-	return *this;  // For function chaining
-    }
-    inline VerilatedSerialize& write (const void* __restrict datap, size_t size) {
+    std::string filename() const { return m_filename; }
+    virtual void close() VL_MT_UNSAFE_ONE { flush(); }
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    inline VerilatedSerialize& write(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
 	const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
 	while (size) {
 	    bufferCheck();
@@ -96,23 +74,58 @@ public:
 	}
 	return *this;  // For function chaining
    }
+private:
+    VerilatedSerialize& bufferCheck() VL_MT_UNSAFE_ONE {
+	// Flush the write buffer if there's not enough space left for new information
+	// We only call this once per vector, so we need enough slop for a very wide "b###" line
+	if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
+	    flush();
+	}
+	return *this;  // For function chaining
+    }
 };

 //=============================================================================
 // VerilatedDeserial - load structures from a stream representation
+// This class is not thread safe, it must be called by a single thread

-class VerilatedDeserialize : public VerilatedSerialBase {
+class VerilatedDeserialize {
 protected:
+    // MEMBERS
+    // For speed, keep m_cp as the first member of this structure
+    vluint8_t*		m_cp;		///< Current pointer into m_bufp buffer
+    vluint8_t*		m_bufp;		///< Output buffer
    vluint8_t*		m_endp;		///< Last valid byte in m_bufp buffer
+    bool 		m_isOpen;	///< True indicates open file/stream
+    std::string		m_filename;	///< Filename, for error messages
+    VerilatedAssertOneThread m_assertOne;	///< Assert only called from single thread
+
+    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
+    inline static size_t bufferInsertSize() { return 16*1024; }
+
    virtual void fill() = 0;
-    void header();
-    void trailer();
+    void header() VL_MT_UNSAFE_ONE;
+    void trailer() VL_MT_UNSAFE_ONE;
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedDeserialize);
 public:
-    // CREATORS
-    VerilatedDeserialize() { m_endp = NULL; }
-    virtual ~VerilatedDeserialize() { close(); }
+    VerilatedDeserialize() {
+	m_isOpen = false;
+	m_bufp = new vluint8_t [bufferSize()];
+	m_cp = m_bufp;
+	m_endp = NULL;
+    }
+    virtual ~VerilatedDeserialize() {
+	close();
+	if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+    }
    // METHODS
-    inline VerilatedDeserialize& read (void* __restrict datap, size_t size) {
+    bool isOpen() const { return m_isOpen; }
+    std::string filename() const { return m_filename; }
+    virtual void close() VL_MT_UNSAFE_ONE { flush(); }
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    inline VerilatedDeserialize& read(void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
 	vluint8_t* __restrict dp = (vluint8_t* __restrict)datap;
 	while (size) {
 	    bufferCheck();
@@ -124,10 +137,11 @@ public:
 	return *this;  // For function chaining
    }
    // Read a datum and compare with expected value
-    bool readDiffers (const void* __restrict datap, size_t size);
-    VerilatedDeserialize& readAssert (const void* __restrict datap, size_t size);
-    VerilatedDeserialize& readAssert (vluint64_t data) { return readAssert(&data, sizeof(data)); }
-    VerilatedDeserialize& bufferCheck() {
+    VerilatedDeserialize& readAssert(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
+    VerilatedDeserialize& readAssert(vluint64_t data) VL_MT_UNSAFE_ONE { return readAssert(&data, sizeof(data)); }
+private:
+    bool readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
+    VerilatedDeserialize& bufferCheck() VL_MT_UNSAFE_ONE {
 	// Flush the write buffer if there's not enough space left for new information
 	// We only call this once per vector, so we need enough slop for a very wide "b###" line
 	if (VL_UNLIKELY((m_cp+bufferInsertSize()) > m_endp)) {
@@ -139,40 +153,42 @@ public:

 //=============================================================================
 // VerilatedSave - serialize to a file
+// This class is not thread safe, it must be called by a single thread

 class VerilatedSave : public VerilatedSerialize {
 private:
    int			m_fd;		///< File descriptor we're writing to

 public:
-    // CREATORS
+    // CONSTRUCTORS
    VerilatedSave() { m_fd=-1; }
    virtual ~VerilatedSave() { close(); }
    // METHODS
-    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
-    void open(const string& filename) { open(filename.c_str()); }
-    virtual void close();
-    virtual void flush();
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
+    virtual void close() VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_MT_UNSAFE_ONE;
 };

 //=============================================================================
 // VerilatedRestore - deserialize from a file
+// This class is not thread safe, it must be called by a single thread

 class VerilatedRestore : public VerilatedDeserialize {
 private:
    int			m_fd;		///< File descriptor we're writing to

 public:
-    // CREATORS
+    // CONSTRUCTORS
    VerilatedRestore() { m_fd=-1; }
    virtual ~VerilatedRestore() { close(); }

    // METHODS
-    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
-    void open(const string& filename) { open(filename.c_str()); }
-    virtual void close();
-    virtual void flush() {}
-    virtual void fill();
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
+    virtual void close() VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_MT_UNSAFE_ONE {}
+    virtual void fill() VL_MT_UNSAFE_ONE;
 };

 //=============================================================================
@@ -219,12 +235,12 @@ inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   float& rhs) {
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, float& rhs) {
    return os.read(&rhs, sizeof(rhs));
 }
-inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   string& rhs) {
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   std::string& rhs) {
    vluint32_t len=rhs.length();
    os<<len;
    return os.write(rhs.data(), len);
 }
-inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, string& rhs) {
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& rhs) {
    vluint32_t len=0;
    os>>len;
    rhs.resize(len);
@@ -16,8 +16,8 @@
 /// \file
 /// \brief Verilator: Common include for all Verilated SystemC files
 ///
-///	This file is included automatically by Verilator at the top of
-///	all SystemC files it generates.
+///     This file is included automatically by Verilator at the top of
+///     all SystemC files it generates.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -35,13 +35,14 @@
 // We want to get a pointer to m_data in the sc_bv_base class,
 // but it is protected.  So make an exposing class, then use
 // cast magic to get at it.  Saves patching get_datap in SystemC.
+// This class is thread safe (though most of SystemC is not).

 #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
 class VlScBvExposer : public sc_bv_base {
 public:
-    static vluint32_t* sp_datap(const sc_bv_base& base) {
-	return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
-    vluint32_t* sp_datatp() const { return (vluint32_t*)(m_data); }
+    static const vluint32_t* sp_datap(const sc_bv_base& base) VL_MT_SAFE {
+        return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
+    const vluint32_t* sp_datatp() const { return reinterpret_cast<vluint32_t*>(m_data); }
    // Above reads this protected element in sc_bv_base:
    //   sc_digit* m_data; // data array
 };
@@ -20,6 +20,9 @@
 ///	the symbol table.  It is not included in verilated.h
 ///	as it requires some heavyweight C++ classes.
 ///
+///     These classes are thread safe on read only. It is constructed
+///     only when a model is built (from the main thread).
+///
 /// Code available from: http://www.veripool.org/verilator
 ///
 //*************************************************************************
@@ -34,9 +37,10 @@

 //===========================================================================
 /// Verilator range
+/// Thread safety: Assume is constructed only with model, then any number of readers

 // See also V3Ast::VNumRange
-class VerilatedRange { 
+class VerilatedRange {
    int		m_left;
    int		m_right;
 protected:
@@ -53,6 +57,7 @@ public:

 //===========================================================================
 /// Verilator variable
+/// Thread safety: Assume is constructed only with model, then any number of readers

 class VerilatedVar {
    void*		m_datap;	// Location of data
@@ -71,7 +76,7 @@ public:
    ~VerilatedVar() {}
    void* datap() const { return m_datap; }
    VerilatedVarType vltype() const { return m_vltype; }
-    VerilatedVarFlags vldir() const { return (VerilatedVarFlags)((int)m_vlflags & VLVF_MASK_DIR); }
+    VerilatedVarFlags vldir() const { return static_cast<VerilatedVarFlags>(static_cast<int>(m_vlflags) & VLVF_MASK_DIR); }
    vluint32_t entSize() const;
    bool isPublicRW() const { return ((m_vlflags & VLVF_PUB_RW) != 0); }
    const VerilatedRange& range() const { return m_range; }
@@ -91,13 +96,14 @@ struct VerilatedCStrCmp {
 };

 class VerilatedScopeNameMap
-    : public map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
+    : public std::map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
 public:
    VerilatedScopeNameMap() {}
    ~VerilatedScopeNameMap() {}
 };

-class VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
+class VerilatedVarNameMap
+    : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
 public:
    VerilatedVarNameMap() {}
    ~VerilatedVarNameMap() {}
@@ -47,9 +47,38 @@
 #endif

 //=============================================================================
-// Global
+// VerilatedVcdImp
+/// Base class to hold some static state
+/// This is an internally used class

-vector<VerilatedVcd*>	VerilatedVcd::s_vcdVecp;	///< List of all created traces
+class VerilatedVcdSingleton {
+private:
+    typedef std::vector<VerilatedVcd*> VcdVec;
+    struct Singleton {
+        VerilatedMutex  s_vcdMutex;  ///< Protect the singleton
+        VcdVec          s_vcdVecp VL_GUARDED_BY(s_vcdMutex);  ///< List of all created traces
+    };
+    static Singleton& singleton() { static Singleton s;	return s; }
+public:
+    static void pushVcd(VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
+	VerilatedLockGuard guard(singleton().s_vcdMutex);
+	singleton().s_vcdVecp.push_back(vcdp);
+    }
+    static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
+	VerilatedLockGuard guard(singleton().s_vcdMutex);
+	VcdVec::iterator pos = find(singleton().s_vcdVecp.begin(), singleton().s_vcdVecp.end(), vcdp);
+	if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); }
+    }
+    static void flush_all() VL_EXCLUDES(singleton().s_vcdMutex) VL_MT_UNSAFE_ONE {
+	// Thread safety: Although this function is protected by a mutex so perhaps
+	// in the future we can allow tracing in separate threads, vcdp->flush() assumes call from single thread
+	VerilatedLockGuard guard(singleton().s_vcdMutex);
+	for (VcdVec::const_iterator it=singleton().s_vcdVecp.begin(); it!=singleton().s_vcdVecp.end(); ++it) {
+	    VerilatedVcd* vcdp = *it;
+	    vcdp->flush();
+	}
+    }
+};

 //=============================================================================
 // VerilatedVcdCallInfo
@@ -67,11 +96,12 @@ protected:
    VerilatedVcdCallback_t	m_changecb;	///< Incremental Dumping Callback function
    void*		m_userthis;	///< Fake "this" for caller
    vluint32_t		m_code;		///< Starting code number
-    // CREATORS
+    // CONSTRUCTORS
    VerilatedVcdCallInfo (VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
 			  VerilatedVcdCallback_t changecb,
 			  void* ut, vluint32_t code)
 	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+    ~VerilatedVcdCallInfo() {}
 };

 //=============================================================================
@@ -79,16 +109,16 @@ protected:
 //=============================================================================
 // VerilatedVcdFile

-bool VerilatedVcdFile::open(const string& name) {
+bool VerilatedVcdFile::open(const std::string& name) VL_MT_UNSAFE {
    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
    return (m_fd>=0);
 }

-void VerilatedVcdFile::close() {
+void VerilatedVcdFile::close() VL_MT_UNSAFE {
    ::close(m_fd);
 }

-ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) {
+ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) VL_MT_UNSAFE {
    return ::write(m_fd, bufp, len);
 }

@@ -117,11 +147,12 @@ VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
 }

 void VerilatedVcd::open (const char* filename) {
+    m_assertOne.check();
    if (isOpen()) return;

    // Set member variables
    m_filename = filename;
-    s_vcdVecp.push_back(this);
+    VerilatedVcdSingleton::pushVcd(this);

    // SPDIFF_OFF
    // Set callback so an early exit will flush us
@@ -147,10 +178,11 @@ void VerilatedVcd::open (const char* filename) {
 void VerilatedVcd::openNext (bool incFilename) {
    // Open next filename in concat sequence, mangle filename if
    // incFilename is true.
+    m_assertOne.check();
    closePrev(); // Close existing
    if (incFilename) {
 	// Find _0000.{ext} in filename
-	string name = m_filename;
+	std::string name = m_filename;
 	size_t pos=name.rfind(".");
 	if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
 	    && isdigit(name.c_str()[pos-4])
@@ -195,7 +227,7 @@ void VerilatedVcd::makeNameMap() {
    m_namemapp = new NameMap;
    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
 	VerilatedVcdCallInfo *cip = m_callbacks[ent];
-	cip->m_code = nextCode();
+	cip->m_code = m_nextCode;
 	(cip->m_initcb) (this, cip->m_userthis, cip->m_code);
    }

@@ -204,19 +236,19 @@ void VerilatedVcd::makeNameMap() {
    // If no scope was specified, prefix everything with a "top"
    // This comes from user instantiations with no name - IE Vtop("").
    bool nullScope = false;
-    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const string& hiername = it->first;
+    for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	const std::string& hiername = it->first;
 	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
    }
    if (nullScope) {
 	NameMap* newmapp = new NameMap;
-	for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	    const string& hiername = it->first;
-	    const string& decl     = it->second;
-	    string newname = string("top");
+	for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	    const std::string& hiername = it->first;
+	    const std::string& decl     = it->second;
+	    std::string newname = std::string("top");
 	    if (hiername[0] != '\t') newname += ' ';
 	    newname += hiername;
-	    newmapp->insert(make_pair(newname,decl));
+	    newmapp->insert(std::make_pair(newname,decl));
 	}
 	deleteNameMap();
 	m_namemapp = newmapp;
@@ -233,12 +265,15 @@ VerilatedVcd::~VerilatedVcd() {
    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); }
+    for (CallbackVec::const_iterator it=m_callbacks.begin(); it!=m_callbacks.end(); ++it) {
+	delete (*it);
+    }
+    m_callbacks.clear();
+    VerilatedVcdSingleton::removeVcd(this);
 }

 void VerilatedVcd::closePrev () {
+    // This function is on the flush() call path
    if (!isOpen()) return;

    bufferFlush();
@@ -247,6 +282,7 @@ void VerilatedVcd::closePrev () {
 }

 void VerilatedVcd::closeErr () {
+    // This function is on the flush() call path
    // Close due to an error.  We might abort before even getting here,
    // depending on the definition of vl_fatal.
    if (!isOpen()) return;
@@ -257,6 +293,8 @@ void VerilatedVcd::closeErr () {
 }

 void VerilatedVcd::close() {
+    // This function is on the flush() call path
+    m_assertOne.check();
    if (!isOpen()) return;
    if (m_evcd) {
 	printStr("$vcdclose ");
@@ -285,10 +323,10 @@ void VerilatedVcd::printTime (vluint64_t timeui) {
    // Dinotrace doesn't mind, but Cadence vvision seems to choke
    if (VL_UNLIKELY(timeui < m_timeLastDump)) {
 	timeui = m_timeLastDump;
-	static bool backTime = false;
+	static VL_THREAD_LOCAL bool backTime = false;
 	if (!backTime) {
 	    backTime = true;
-	    VL_PRINTF("VCD time is moving backwards, wave file may be incorrect.\n");
+	    VL_PRINTF_MT("%%Warning: VCD time is moving backwards, wave file may be incorrect.\n");
 	}
    }
    m_timeLastDump = timeui;
@@ -309,10 +347,12 @@ void VerilatedVcd::bufferResize(vluint64_t minsize) {
    }
 }

-void VerilatedVcd::bufferFlush () {
+void VerilatedVcd::bufferFlush () VL_MT_UNSAFE_ONE {
+    // This function is on the flush() call path
    // We add output data to m_writep.
    // When it gets nearly full we dump it using this routine which calls write()
    // This is much faster than using buffered I/O
+    m_assertOne.check();
    if (VL_UNLIKELY(!isOpen())) return;
    char* wp = m_wrBufp;
    while (1) {
@@ -326,8 +366,8 @@ void VerilatedVcd::bufferFlush () {
 	} else if (got < 0) {
 	    if (errno != EAGAIN && errno != EINTR) {
 		// write failed, presume error (perhaps out of disk space)
-		string msg = (string)"VerilatedVcd::bufferFlush: "+strerror(errno);
-		vl_fatal("",0,"",msg.c_str());
+		std::string msg = std::string("VerilatedVcd::bufferFlush: ")+strerror(errno);
+		VL_FATAL_MT("",0,"",msg.c_str());
 		closeErr();
 		break;
 	    }
@@ -354,7 +394,7 @@ void VerilatedVcd::set_time_resolution (const char* unitp) {
 double VerilatedVcd::timescaleToDouble (const char* unitp) {
    char* endp;
    double value = strtod(unitp, &endp);
-    if (!value) value=1;  // On error so we allow just "ns" to return 1e-9.
+    if (value==0.0 && endp==unitp) value=1;  // On error so we allow just "ns" to return 1e-9.
    unitp=endp;
    while (*unitp && isspace(*unitp)) unitp++;
    switch (*unitp) {
@@ -369,7 +409,7 @@ double VerilatedVcd::timescaleToDouble (const char* unitp) {
    return value;
 }

-string VerilatedVcd::doubleToTimescale (double value) {
+std::string VerilatedVcd::doubleToTimescale (double value) {
    const char* suffixp = "s";
    if	    (value>=1e0)   { suffixp="s"; value *= 1e0; }
    else if (value>=1e-3 ) { suffixp="ms"; value *= 1e3; }
@@ -398,7 +438,7 @@ void VerilatedVcd::dumpHeader () {
    printStr("$date "); printStr(ctime(&time_str)); printStr(" $end\n");

    printStr("$timescale ");
-    const string& timeResStr = doubleToTimescale(m_timeRes);
+    const std::string& timeResStr = doubleToTimescale(m_timeRes);
    printStr(timeResStr.c_str());
    printStr(" $end\n");

@@ -412,13 +452,13 @@ void VerilatedVcd::dumpHeader () {
    // We detect the spaces in module names to determine hierarchy.  This
    // allows signals to be declared without fixed ordering, which is
    // required as Verilog signals might be separately declared from
-    // "SP_TRACE" signals.
+    // SC module signals.

    // Print the signal names
    const char* lastName = "";
-    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const string& hiernamestr = it->first;
-	const string& decl = it->second;
+    for (NameMap::const_iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	const std::string& hiernamestr = it->first;
+	const std::string& decl = it->second;

 	// Determine difference between the old and new names
 	const char* hiername = hiernamestr.c_str();
@@ -472,20 +512,21 @@ void VerilatedVcd::dumpHeader () {
    deleteNameMap();
 }

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

 void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep,
 			    int arraynum, bool tri, bool bussed, int msb, int lsb) {
-    if (!code) { vl_fatal(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); }
+    if (!code) { VL_FATAL_MT(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); }

    int bits = ((msb>lsb)?(msb-lsb):(lsb-msb))+1;
    int codesNeeded = 1+int(bits/32);
    if (tri) codesNeeded *= 2;   // Space in change array for __en signals

    // Make sure array is large enough
-    m_nextCode = max(nextCode(), code+codesNeeded);
+    m_nextCode = std::max(m_nextCode, code+codesNeeded);
    if (m_sigs.capacity() <= m_nextCode) {
 	m_sigs.reserve(m_nextCode*2);	// Power-of-2 allocation speeds things up
    }
@@ -503,10 +544,10 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
    // Tab separates final scope from signal name
    // Tab sorts before spaces, so signals nicely will print before scopes
    // Note the hiername may be nothing, if so we'll add "\t{name}"
-    string nameasstr = name;
+    std::string nameasstr = name;
    if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; }  // Optional ->module prefix
-    string hiername;
-    string basename;
+    std::string hiername;
+    std::string basename;
    for (const char* cp=nameasstr.c_str(); *cp; cp++) {
 	if (isScopeEscape(*cp)) {
 	    // Ahh, we've just read a scope, not a basename
@@ -520,7 +561,7 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
    hiername += "\t"+basename;

    // Print reference
-    string decl = "$var ";
+    std::string decl = "$var ";
    if (m_evcd) decl += "port"; else decl += wirep;  // usually "wire"
    char buf [1000];
    sprintf(buf, " %2d ", bits);
@@ -543,7 +584,7 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
 	decl += buf;
    }
    decl += " $end\n";
-    m_namemapp->insert(make_pair(hiername,decl));
+    m_namemapp->insert(std::make_pair(hiername,decl));
 }

 void VerilatedVcd::declBit      (vluint32_t code, const char* name, int arraynum)
@@ -570,7 +611,8 @@ void VerilatedVcd::declDouble   (vluint32_t code, const char* name, int arraynum
 //=============================================================================

 void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
-    (*((double*)&m_sigs_oldvalp[code])) = newval;
+    // cppcheck-suppress invalidPointerCast
+    (*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) = newval;
    // Buffer can't overflow before sprintf; we sized during declaration
    sprintf(m_writep, "r%.16g", newval);
    m_writep += strlen(m_writep);
@@ -578,9 +620,10 @@ void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
    bufferCheck();
 }
 void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
-    (*((float*)&m_sigs_oldvalp[code])) = newval;
+    // cppcheck-suppress invalidPointerCast
+    (*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) = newval;
    // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(m_writep, "r%.16g", (double)newval);
+    sprintf(m_writep, "r%.16g", static_cast<double>(newval));
    m_writep += strlen(m_writep);
    *m_writep++=' '; printCode(code); *m_writep++='\n';
    bufferCheck();
@@ -589,15 +632,16 @@ void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
 //=============================================================================
 // Callbacks

-void VerilatedVcd::addCallback (
+void VerilatedVcd::addCallback VL_MT_UNSAFE_ONE (
    VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb, VerilatedVcdCallback_t changecb,
    void* userthis)
 {
+    m_assertOne.check();
    if (VL_UNLIKELY(isOpen())) {
-	string msg = (string)"Internal: "+__FILE__+"::"+__FUNCTION__+" called with already open file";
-	vl_fatal(__FILE__,__LINE__,"",msg.c_str());
+	std::string msg = std::string("Internal: ")+__FILE__+"::"+__FUNCTION__+" called with already open file";
+	VL_FATAL_MT(__FILE__,__LINE__,"",msg.c_str());
    }
-    VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, nextCode());
+    VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, m_nextCode);
    m_callbacks.push_back(vci);
 }

@@ -605,15 +649,17 @@ void VerilatedVcd::addCallback (
 // Dumping

 void VerilatedVcd::dumpFull (vluint64_t timeui) {
+    m_assertOne.check();
    dumpPrep (timeui);
+    Verilated::quiesce();
    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
 	VerilatedVcdCallInfo *cip = m_callbacks[ent];
 	(cip->m_fullcb) (this, cip->m_userthis, cip->m_code);
    }
-    dumpDone ();
 }

 void VerilatedVcd::dump (vluint64_t timeui) {
+    m_assertOne.check();
    if (!isOpen()) return;
    if (VL_UNLIKELY(m_fullDump)) {
 	m_fullDump = false;	// No need for more full dumps
@@ -625,11 +671,11 @@ void VerilatedVcd::dump (vluint64_t timeui) {
 	if (!isOpen()) return;
    }
    dumpPrep (timeui);
+    Verilated::quiesce();
    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
 	VerilatedVcdCallInfo *cip = m_callbacks[ent];
 	(cip->m_changecb) (this, cip->m_userthis, cip->m_code);
    }
-    dumpDone();
 }

 void VerilatedVcd::dumpPrep (vluint64_t timeui) {
@@ -638,17 +684,11 @@ void VerilatedVcd::dumpPrep (vluint64_t timeui) {
    printStr("\n");
 }

-void VerilatedVcd::dumpDone () {
-}
-
 //======================================================================
 // Static members

-void VerilatedVcd::flush_all() {
-    for (vluint32_t ent = 0; ent< s_vcdVecp.size(); ent++) {
-	VerilatedVcd* vcdp = s_vcdVecp[ent];
-	vcdp->flush();
-    }
+void VerilatedVcd::flush_all() VL_MT_UNSAFE_ONE {
+    VerilatedVcdSingleton::flush_all();
 }

 //======================================================================
@@ -24,11 +24,11 @@
 #define _VERILATED_VCD_C_H_ 1

 #include "verilatedos.h"
+#include "verilated.h"

 #include <string>
 #include <vector>
 #include <map>
-using namespace std;

 class VerilatedVcd;
 class VerilatedVcdCallInfo;
@@ -45,9 +45,9 @@ 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);
+    virtual bool open(const std::string& name) VL_MT_UNSAFE;
+    virtual void close() VL_MT_UNSAFE;
+    virtual ssize_t write(const char* bufp, ssize_t len) VL_MT_UNSAFE;
 };

 //=============================================================================
@@ -80,13 +80,13 @@ private:
    bool		m_fileNewed;	///< m_filep needs destruction
    bool 		m_isOpen;	///< True indicates open file
    bool		m_evcd;		///< True for evcd format
-    string		m_filename;	///< Filename we're writing to (if open)
+    std::string		m_filename;	///< Filename we're writing to (if open)
    vluint64_t		m_rolloverMB;	///< MB of file size to rollover at
    char		m_scopeEscape;	///< Character to separate scope components
    int			m_modDepth;	///< Depth of module hierarchy
    bool		m_fullDump;	///< True indicates dump ignoring if changed
    vluint32_t		m_nextCode;	///< Next code number to assign
-    string		m_modName;	///< Module name being traced now
+    std::string		m_modName;	///< Module name being traced now
    double		m_timeRes;	///< Time resolution (ns/ms etc)
    double		m_timeUnit;	///< Time units (ns/ms etc)
    vluint64_t		m_timeLastDump;	///< Last time we did a dump
@@ -97,15 +97,18 @@ private:
    vluint64_t		m_wrChunkSize;	///< Output buffer size
    vluint64_t		m_wroteBytes;	///< Number of bytes written to this file

-    vluint32_t*			m_sigs_oldvalp;	///< Pointer to old signal values
-    vector<VerilatedVcdSig>	m_sigs;		///< Pointer to signal information
-    vector<VerilatedVcdCallInfo*>	m_callbacks;	///< Routines to perform dumping
-    typedef map<string,string>	NameMap;
-    NameMap*			m_namemapp;	///< List of names for the header
-    static vector<VerilatedVcd*>	s_vcdVecp;	///< List of all created traces
+    vluint32_t*		m_sigs_oldvalp;	///< Pointer to old signal values
+    typedef std::vector<VerilatedVcdSig>  SigVec;
+    SigVec		m_sigs;		///< Pointer to signal information
+    typedef std::vector<VerilatedVcdCallInfo*>  CallbackVec;
+    CallbackVec		m_callbacks;	///< Routines to perform dumping
+    typedef std::map<std::string,std::string>  NameMap;
+    NameMap*		m_namemapp;	///< List of names for the header
+
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread

    void bufferResize(vluint64_t minsize);
-    void bufferFlush();
+    void bufferFlush() VL_MT_UNSAFE_ONE;
    inline void bufferCheck() {
 	// Flush the write buffer if there's not enough space left for new information
 	// We only call this once per vector, so we need enough slop for a very wide "b###" line
@@ -131,33 +134,26 @@ private:
    // cppcheck-suppress functionConst
    void dumpDone ();
    inline void printCode (vluint32_t code) {
-	if (code>=(94*94*94)) *m_writep++ = ((char)((code/94/94/94)%94+33));
-	if (code>=(94*94))    *m_writep++ = ((char)((code/94/94)%94+33));
-	if (code>=(94))       *m_writep++ = ((char)((code/94)%94+33));
-	*m_writep++ = ((char)((code)%94+33));
+	if (code>=(94*94*94)) *m_writep++ = static_cast<char>((code/94/94/94)%94+33);
+	if (code>=(94*94))    *m_writep++ = static_cast<char>((code/94/94)%94+33);
+	if (code>=(94))       *m_writep++ = static_cast<char>((code/94)%94+33);
+	*m_writep++ = static_cast<char>((code)%94+33);
    }
-    static string stringCode (vluint32_t code) {
-	string out;
-	if (code>=(94*94*94)) out += ((char)((code/94/94/94)%94+33));
-	if (code>=(94*94))    out += ((char)((code/94/94)%94+33));
-	if (code>=(94))       out += ((char)((code/94)%94+33));
-	return out + ((char)((code)%94+33));
+    static std::string stringCode (vluint32_t code) VL_PURE {
+	std::string out;
+	if (code>=(94*94*94)) out += static_cast<char>((code/94/94/94)%94+33);
+	if (code>=(94*94))    out += static_cast<char>((code/94/94)%94+33);
+	if (code>=(94))       out += static_cast<char>((code/94)%94+33);
+	return out + static_cast<char>((code)%94+33);
    }

-    VerilatedVcd(const VerilatedVcd& );	///< N/A, no copy constructor
-
-protected:
-    // METHODS
-    void evcd(bool flag) { m_evcd = flag; }
-
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedVcd);
 public:
-    // CREATORS
    explicit VerilatedVcd(VerilatedVcdFile* filep=NULL);
    ~VerilatedVcd();

    // ACCESSORS
-    /// Inside dumping routines, return next VCD signal code
-    vluint32_t nextCode() const {return m_nextCode;}
    /// Set size in megabytes after which new file should be created
    void rolloverMB(vluint64_t rolloverMB) { m_rolloverMB=rolloverMB; };
    /// Is file open?
@@ -168,33 +164,35 @@ public:
    inline bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }

    // METHODS
-    void open (const char* filename);	///< Open the file; call isOpen() to see if errors
+    void open(const char* filename) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
    void openNext (bool incFilename);	///< Open next data-only file
-    void flush() { bufferFlush(); }	///< Flush any remaining data
-    static void flush_all();		///< Flush any remaining data from all files
-    void close ();			///< Close the file
+    void close() VL_MT_UNSAFE_ONE;  ///< Close the file
+    /// Flush any remaining data to this file
+    void flush() VL_MT_UNSAFE_ONE { bufferFlush(); }
+    /// Flush any remaining data from all files
+    static void flush_all() VL_MT_UNSAFE_ONE;

    void set_time_unit (const char* unit); ///< Set time units (s/ms, defaults to ns)
-    void set_time_unit (const string& unit) { set_time_unit(unit.c_str()); }
+    void set_time_unit (const std::string& unit) { set_time_unit(unit.c_str()); }

    void set_time_resolution (const char* unit); ///< Set time resolution (s/ms, defaults to ns)
-    void set_time_resolution (const string& unit) { set_time_resolution(unit.c_str()); }
+    void set_time_resolution (const std::string& unit) { set_time_resolution(unit.c_str()); }

    double timescaleToDouble (const char* unitp);
-    string doubleToTimescale (double value);
+    std::string doubleToTimescale (double value);

    /// Inside dumping routines, called each cycle to make the dump
    void dump     (vluint64_t timeui);
    /// Call dump with a absolute unscaled time in seconds
-    void dumpSeconds (double secs) { dump((vluint64_t)(secs * m_timeRes)); }
+    void dumpSeconds (double secs) { dump(static_cast<vluint64_t>(secs * m_timeRes)); }

    /// Inside dumping routines, declare callbacks for tracings
    void addCallback (VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
 		      VerilatedVcdCallback_t change,
-		      void* userthis);
+		      void* userthis) VL_MT_UNSAFE_ONE;

    /// Inside dumping routines, declare a module
-    void module (const string& name);
+    void module (const std::string& name);
    /// Inside dumping routines, declare a signal
    void declBit      (vluint32_t code, const char* name, int arraynum);
    void declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
@@ -212,7 +210,7 @@ public:
    void fullBit (vluint32_t code, const vluint32_t newval) {
 	// Note the &1, so we don't require clean input -- makes more common no change case faster
 	m_sigs_oldvalp[code] = newval;
-	*m_writep++=('0'+(char)(newval&1)); printCode(code); *m_writep++='\n';
+	*m_writep++=('0'+static_cast<char>(newval&1)); printCode(code); *m_writep++='\n';
 	bufferCheck();
    }
    void fullBus (vluint32_t code, const vluint32_t newval, int bits) {
@@ -225,7 +223,7 @@ public:
 	bufferCheck();
    }
    void fullQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
+	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
 	*m_writep++='b';
 	for (int bit=bits-1; bit>=0; --bit) {
 	    *m_writep++=((newval&(1ULL<<bit))?'1':'0');
@@ -264,8 +262,8 @@ public:
 	bufferCheck();
    }
    void fullTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
-	(*((vluint64_t*)&m_sigs_oldvalp[code+1])) = newtri;
+	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) = newval;
+	(*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) = newtri;
 	*m_writep++='b';
 	for (int bit=bits-1; bit>=0; --bit) {
 	    *m_writep++ = "01zz"[((newval >> bit)&1ULL)
@@ -329,7 +327,7 @@ public:
 	}
    }
    inline void chgQuad (vluint32_t code, const vluint64_t newval, int bits) {
-	vluint64_t diff = (*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval;
+	vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval;
 	if (VL_UNLIKELY(diff)) {
 	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
 		fullQuad(code, newval, bits);
@@ -364,8 +362,8 @@ public:
 	}
    }
    inline void chgTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
-	vluint64_t diff = ( ((*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval)
-			  | ((*((vluint64_t*)&m_sigs_oldvalp[code+1])) ^ newtri));
+	vluint64_t diff = ( ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code]))) ^ newval)
+			    | ((*(reinterpret_cast<vluint64_t*>(&m_sigs_oldvalp[code+1]))) ^ newtri));
 	if (VL_UNLIKELY(diff)) {
 	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
 		fullTriQuad(code, newval, newtri, bits);
@@ -382,27 +380,38 @@ public:
 	}
    }
    inline void chgDouble (vluint32_t code, const double newval) {
-	if (VL_UNLIKELY((*((double*)&m_sigs_oldvalp[code])) != newval)) {
+	// cppcheck-suppress invalidPointerCast
+	if (VL_UNLIKELY((*(reinterpret_cast<double*>(&m_sigs_oldvalp[code]))) != newval)) {
 	    fullDouble (code, newval);
 	}
    }
    inline void chgFloat (vluint32_t code, const float newval) {
-	if (VL_UNLIKELY((*((float*)&m_sigs_oldvalp[code])) != newval)) {
+	// cppcheck-suppress invalidPointerCast
+	if (VL_UNLIKELY((*(reinterpret_cast<float*>(&m_sigs_oldvalp[code]))) != newval)) {
 	    fullFloat (code, newval);
 	}
    }
+
+protected:
+    // METHODS
+    void evcd(bool flag) { m_evcd = flag; }
 };

 //=============================================================================
 // VerilatedVcdC
 /// Create a VCD dump file in C standalone (no SystemC) simulations.
+/// Also derived for use in SystemC simulations.
+/// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE

 class VerilatedVcdC {
    VerilatedVcd		m_sptrace;	///< Trace file being created
-public:
+
    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedVcdC);
+public:
    explicit VerilatedVcdC(VerilatedVcdFile* filep=NULL) : m_sptrace(filep) {}
    ~VerilatedVcdC() {}
+public:
    // ACCESSORS
    /// Is file open?
    bool isOpen() const { return m_sptrace.isOpen(); }
@@ -410,24 +419,33 @@ public:
    /// Open a new VCD file
    /// This includes a complete header dump each time it is called,
    /// just as if this object was deleted and reconstructed.
-    void open (const char* filename) { m_sptrace.open(filename); }
+    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
    /// Continue a VCD dump by rotating to a new file name
    /// The header is only in the first file created, this allows
    /// "cat" to be used to combine the header plus any number of data files.
-    void openNext (bool incFilename=true) { m_sptrace.openNext(incFilename); }
+    void openNext(bool incFilename=true) VL_MT_UNSAFE_ONE { m_sptrace.openNext(incFilename); }
    /// Set size in megabytes after which new file should be created
    void rolloverMB(size_t rolloverMB) { m_sptrace.rolloverMB(rolloverMB); };
    /// Close dump
-    void close() { m_sptrace.close(); }
+    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
    /// Flush dump
-    void flush() { m_sptrace.flush(); }
+    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
    /// Write one cycle of dump data
    void dump (vluint64_t timeui) { m_sptrace.dump(timeui); }
    /// Write one cycle of dump data - backward compatible and to reduce
    /// conversion warnings.  It's better to use a vluint64_t time instead.
-    void dump (double timestamp) { dump((vluint64_t)timestamp); }
-    void dump (vluint32_t timestamp) { dump((vluint64_t)timestamp); }
-    void dump (int timestamp) { dump((vluint64_t)timestamp); }
+    void dump (double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump (vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    void dump (int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
+    /// Set time units (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_unit (const char* unit) { m_sptrace.set_time_unit(unit); }
+    void set_time_unit (const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Set time resolution (s/ms, defaults to ns)
+    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    void set_time_resolution (const char* unit) { m_sptrace.set_time_resolution(unit); }
+    void set_time_resolution (const std::string& unit) { set_time_resolution(unit.c_str()); }
+
    /// Internal class access
    inline VerilatedVcd* spTrace () { return &m_sptrace; };
 };
@@ -17,6 +17,8 @@
 /// \file
 /// \brief Verilator tracing in VCD format
 ///
+/// This class is not threadsafe, as the SystemC kernel is not threadsafe.
+///
 //=============================================================================
 // SPDIFF_OFF

@@ -37,6 +39,8 @@ class VerilatedVcdSc
    : sc_trace_file
    , public VerilatedVcdC
 {
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedVcdSc);
 public:
    VerilatedVcdSc() {
 	sc_get_curr_simcontext()->add_trace_file(this);
@@ -56,8 +60,9 @@ public:
 	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
 # endif
    }
-
    virtual ~VerilatedVcdSc() {}
+
+    // METHODS
    /// Called by SystemC simulate()
    virtual void cycle (bool delta_cycle) {
 # if (SYSTEMC_VERSION>20011000)
@@ -16,8 +16,8 @@
 /// \file
 /// \brief Verilator: VPI implementation code
 ///
-///	This file must be compiled and linked against all objects
-///	created from Verilator or called by Verilator that use the VPI.
+///     This file must be compiled and linked against all objects
+///     created from Verilator or called by Verilator that use the VPI.
 ///
 /// Code available from: http://www.veripool.org/verilator
 ///
@@ -29,469 +29,24 @@
 #include "verilated.h"
 #include "verilated_syms.h"

-#include <list>
-#include <set>
-#include <map>
-
 //======================================================================
 // From IEEE 1800-2009 annex K

 #include "vltstd/vpi_user.h"

 //======================================================================
-// Internal constants
-
-#define VL_DEBUG_IF_PLI VL_DEBUG_IF
-#define VL_VPI_LINE_SIZE 8192
-
-//======================================================================
-// Internal macros
-
-#define _VL_VPI_INTERNAL    VerilatedVpi::error_info()->setMessage(vpiInternal)->setMessage
-#define _VL_VPI_SYSTEM      VerilatedVpi::error_info()->setMessage(vpiSystem  )->setMessage
-#define _VL_VPI_ERROR       VerilatedVpi::error_info()->setMessage(vpiError   )->setMessage
-#define _VL_VPI_WARNING     VerilatedVpi::error_info()->setMessage(vpiWarning )->setMessage
-#define _VL_VPI_NOTICE      VerilatedVpi::error_info()->setMessage(vpiNotice  )->setMessage
-#define _VL_VPI_ERROR_RESET VerilatedVpi::error_info()->resetError
-
-// Not supported yet
-#define _VL_VPI_UNIMP() \
-    _VL_VPI_ERROR(__FILE__,__LINE__,Verilated::catName("Unsupported VPI function: ",VL_FUNC));
-
-//======================================================================
-// Implementation
-
-// Base VPI handled object
-class VerilatedVpio {
-    // MEM MANGLEMENT
-    static vluint8_t* s_freeHead;
-
-public:
-    // CONSTRUCTORS
-    VerilatedVpio() {}
-    virtual ~VerilatedVpio() {}
-    inline static void* operator new(size_t size) {
-	// We new and delete tons of vpi structures, so keep them around
-	// To simplify our free list, we use a size large enough for all derived types
-	// We reserve word zero for the next pointer, as that's safer in case a
-	// dangling reference to the original remains around.
-	static size_t chunk = 96;
-	if (VL_UNLIKELY(size>chunk)) vl_fatal(__FILE__,__LINE__,"", "increase chunk");
-	if (VL_LIKELY(s_freeHead)) {
-	    vluint8_t* newp = s_freeHead;
-	    s_freeHead = *((vluint8_t**)newp);
-	    return newp+8;
-	} else {
-	    // +8: 8 bytes for next
-	    vluint8_t* newp = (vluint8_t*)(::operator new(chunk+8));
-	    return newp+8;
-	}
-    }
-    inline static void operator delete(void* obj, size_t size) {
-	vluint8_t* oldp = ((vluint8_t*)obj)-8;
-	*((void**)oldp) = s_freeHead;
-	s_freeHead = oldp;
-    }
-    // MEMBERS
-    static inline VerilatedVpio* castp(vpiHandle h) { return dynamic_cast<VerilatedVpio*>((VerilatedVpio*)h); }
-    inline vpiHandle castVpiHandle() { return (vpiHandle)(this); }
-    // ACCESSORS
-    virtual const char* name() { return "<null>"; }
-    virtual const char* fullname() { return "<null>"; }
-    virtual const char* defname() { return "<null>"; }
-    virtual const vluint32_t type() { return 0; }
-    virtual const vluint32_t size() const { return 0; }
-    virtual const VerilatedRange* rangep() const { return NULL; }
-    virtual vpiHandle dovpi_scan() { return 0; }
-};
-
-typedef PLI_INT32 (*VerilatedPliCb)(struct t_cb_data *);
-
-class VerilatedVpioCb : public VerilatedVpio {
-    t_cb_data		m_cbData;
-    s_vpi_value		m_value;
-    QData		m_time;
-public:
-    // cppcheck-suppress uninitVar  // m_value
-    VerilatedVpioCb(const t_cb_data* cbDatap, QData time)
-	: m_cbData(*cbDatap), m_time(time) {
-        m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal;
-	m_cbData.value = &m_value;
-    }
-    virtual ~VerilatedVpioCb() {}
-    static inline VerilatedVpioCb* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioCb*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiCallback; }
-    vluint32_t reason() const { return m_cbData.reason; }
-    VerilatedPliCb cb_rtnp() const { return m_cbData.cb_rtn; }
-    t_cb_data* cb_datap() { return &(m_cbData); }
-    QData time() const { return m_time; }
-};
-
-class VerilatedVpioConst : public VerilatedVpio {
-    vlsint32_t	m_num;
-public:
-    explicit VerilatedVpioConst(vlsint32_t num) : m_num(num) {}
-    virtual ~VerilatedVpioConst() {}
-    static inline VerilatedVpioConst* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioConst*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiUndefined; }
-    vlsint32_t num() const { return m_num; }
-};
-
-class VerilatedVpioRange : public VerilatedVpio {
-    const VerilatedRange* m_range;
-    vlsint32_t                  m_iteration;
-public:
-    explicit VerilatedVpioRange(const VerilatedRange* range) : m_range(range), m_iteration(0) {}
-    virtual ~VerilatedVpioRange() {}
-    static inline VerilatedVpioRange* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioRange*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiRange; }
-    virtual const vluint32_t size() const { return m_range->elements(); }
-    virtual const VerilatedRange* rangep() const { return m_range; }
-    int iteration() const { return m_iteration; }
-    void iterationInc() { ++m_iteration; }
-    virtual vpiHandle dovpi_scan() {
-	if (!iteration()) {
-	    VerilatedVpioRange* nextp = new VerilatedVpioRange(*this);
-	    nextp->iterationInc();
-	    return ((nextp)->castVpiHandle());
-	} else {
-	    return 0;  // End of list - only one deep
-	}
-    }
-};
-
-class VerilatedVpioScope : public VerilatedVpio {
-    const VerilatedScope*	m_scopep;
-public:
-    explicit VerilatedVpioScope(const VerilatedScope* scopep)
-	: m_scopep(scopep) {}
-    virtual ~VerilatedVpioScope() {}
-    static inline VerilatedVpioScope* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioScope*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiScope; }
-    const VerilatedScope* scopep() const { return m_scopep; }
-    virtual const char* name() { return m_scopep->name(); }
-    virtual const char* fullname() { return m_scopep->name(); }
-};
-
-class VerilatedVpioVar : public VerilatedVpio {
-    const VerilatedVar*		m_varp;
-    const VerilatedScope*	m_scopep;
-    vluint8_t*			m_prevDatap;	// Previous value of data, for cbValueChange
-    union {
-	vluint8_t u8[4];
-	vluint32_t u32;
-    } m_mask;                                   // memoized variable mask
-    vluint32_t			m_entSize;	// memoized variable size
-protected:
-    void*			m_varDatap;	// varp()->datap() adjusted for array entries
-    vlsint32_t			m_index;
-    const VerilatedRange&	get_range() const {
-	// Determine number of dimensions and return outermost
-	return (m_varp->dims()>1) ? m_varp->array() : m_varp->range();
-    }
-public:
-    VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep)
-	: m_varp(varp), m_scopep(scopep), m_index(0) {
-	m_prevDatap = NULL;
-	m_mask.u32 = VL_MASK_I(varp->range().elements());
-	m_entSize = varp->entSize();
-	m_varDatap = varp->datap();
-    }
-    virtual ~VerilatedVpioVar() {
-	if (m_prevDatap) { delete [] m_prevDatap; m_prevDatap = NULL; }
-    }
-    static inline VerilatedVpioVar* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioVar*>((VerilatedVpio*)h); }
-    const VerilatedVar* varp() const { return m_varp; }
-    const VerilatedScope* scopep() const { return m_scopep; }
-    vluint32_t mask() const { return m_mask.u32; }
-    vluint8_t mask_byte(int idx) { return m_mask.u8[idx & 3]; }
-    vluint32_t entSize() const { return m_entSize; }
-    const vluint32_t index() { return m_index; }
-    virtual const vluint32_t type() {
-      if (varp()->vldir() != vpiNoDirection) return vpiPort;
-      return (varp()->dims()>1) ? vpiMemory : vpiReg; /* but might be wire, logic */
-    }
-    virtual const vluint32_t size() const { return get_range().elements(); }
-    virtual const VerilatedRange* rangep() const { return &get_range(); }
-    virtual const char* name() { return m_varp->name(); }
-    virtual const char* fullname() {
-	VL_STATIC_OR_THREAD string out;
-	out = string(m_scopep->name())+"."+name();
-	return out.c_str();
-    }
-    void* prevDatap() const { return m_prevDatap; }
-    void* varDatap() const { return m_varDatap; }
-    void createPrevDatap() {
-	if (VL_UNLIKELY(!m_prevDatap)) {
-	    m_prevDatap = new vluint8_t [entSize()];
-	    memcpy(prevDatap(), varp()->datap(), entSize());
-	}
-    }
-};
-
-class VerilatedVpioMemoryWord : public VerilatedVpioVar {
-public:
-    VerilatedVpioMemoryWord(const VerilatedVar* varp, const VerilatedScope* scopep,
-			  vlsint32_t index, int offset)
-	: VerilatedVpioVar(varp, scopep) {
-	m_index = index;
-	m_varDatap = ((vluint8_t*)varp->datap()) + entSize()*offset;
-    }
-    virtual ~VerilatedVpioMemoryWord() {}
-    static inline VerilatedVpioMemoryWord* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioMemoryWord*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiMemoryWord; }
-    virtual const vluint32_t size() const { return varp()->range().elements(); }
-    virtual const VerilatedRange* rangep() const { return &(varp()->range()); }
-    virtual const char* fullname() {
-	VL_STATIC_OR_THREAD string out;
-	char num[20]; sprintf(num,"%d",m_index);
-	out = string(scopep()->name())+"."+name()+"["+num+"]";
-	return out.c_str();
-    }
-};
-
-class VerilatedVpioVarIter : public VerilatedVpio {
-    const VerilatedScope*	m_scopep;
-    VerilatedVarNameMap::iterator m_it;
-    bool m_started;
-public:
-    explicit VerilatedVpioVarIter(const VerilatedScope* scopep)
-	: m_scopep(scopep), m_started(false) {  }
-    virtual ~VerilatedVpioVarIter() {}
-    static inline VerilatedVpioVarIter* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioVarIter*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiIterator; }
-    virtual vpiHandle dovpi_scan() {
-	if (VL_LIKELY(m_scopep->varsp())) {
-	    VerilatedVarNameMap* varsp = m_scopep->varsp();
-	    if (VL_UNLIKELY(!m_started)) { m_it = varsp->begin(); m_started=true; }
-	    else if (VL_UNLIKELY(m_it == varsp->end())) return 0;
-	    else ++m_it;
-	    if (m_it == varsp->end()) return 0;
-	    return ((new VerilatedVpioVar(&(m_it->second), m_scopep))
-		    ->castVpiHandle());
-	} else {
-	    return 0;  // End of list - only one deep
-	}
-    }
-};
-
-class VerilatedVpioMemoryWordIter : public VerilatedVpio {
-    const vpiHandle		m_handle;
-    const VerilatedVar*		m_varp;
-    vlsint32_t                  m_iteration;
-    vlsint32_t                  m_direction;
-    bool                        m_done;
-public:
-    VerilatedVpioMemoryWordIter(const vpiHandle handle, const VerilatedVar* varp)
-	: m_handle(handle), m_varp(varp), m_iteration(varp->array().right()), m_direction(VL_LIKELY(varp->array().left()>varp->array().right())?1:-1), m_done(false) {  }
-    virtual ~VerilatedVpioMemoryWordIter() {}
-    static inline VerilatedVpioMemoryWordIter* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioMemoryWordIter*>((VerilatedVpio*)h); }
-    virtual const vluint32_t type() { return vpiIterator; }
-    void iterationInc() { if (!(m_done = (m_iteration == m_varp->array().left()))) m_iteration+=m_direction; }
-    virtual vpiHandle dovpi_scan() {
-	vpiHandle result;
-	if (m_done) return 0;
-	result = vpi_handle_by_index(m_handle, m_iteration);
-	iterationInc();
-	return result;
-    }
-};
-
-//======================================================================
-
-struct VerilatedVpiTimedCbsCmp {
-    /// Ordering sets keyed by time, then callback descriptor
-    bool operator() (const pair<QData,VerilatedVpioCb*>& a,
-		     const pair<QData,VerilatedVpioCb*>& b) const {
-	if (a.first < b.first) return 1;
-	if (a.first > b.first) return 0;
-	return a.second < b.second;
-    }
-};
-
-class VerilatedVpiError;

 class VerilatedVpi {
-    enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime+1 };	// Maxium callback reason
-    typedef list<VerilatedVpioCb*> VpioCbList;
-    typedef set<pair<QData,VerilatedVpioCb*>,VerilatedVpiTimedCbsCmp > VpioTimedCbs;
-
-    struct product_info {
-	PLI_BYTE8* product;
-    };
-
-    VpioCbList		m_cbObjLists[CB_ENUM_MAX_VALUE];	// Callbacks for each supported reason
-    VpioTimedCbs	m_timedCbs;	// Time based callbacks
-    VerilatedVpiError*  m_errorInfop;	// Container for vpi error info
-
-    static VerilatedVpi s_s;		// Singleton
-
 public:
-    VerilatedVpi() { m_errorInfop=NULL; }
-    ~VerilatedVpi() {}
-    static void cbReasonAdd(VerilatedVpioCb* vop) {
-	if (vop->reason() == cbValueChange) {
-	    if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(vop->cb_datap()->obj)) {
-		varop->createPrevDatap();
-	    }
-	}
-	if (VL_UNLIKELY(vop->reason() >= CB_ENUM_MAX_VALUE)) vl_fatal(__FILE__,__LINE__,"", "vpi bb reason too large");
-	s_s.m_cbObjLists[vop->reason()].push_back(vop);
-    }
-    static void cbTimedAdd(VerilatedVpioCb* vop) {
-	s_s.m_timedCbs.insert(make_pair(vop->time(), vop));
-    }
-    static void cbReasonRemove(VerilatedVpioCb* cbp) {
-	VpioCbList& cbObjList = s_s.m_cbObjLists[cbp->reason()];
-	// We do not remove it now as we may be iterating the list,
-	// instead set to NULL and will cleanup later
-	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end(); ++it) {
-            if (*it == cbp) *it = NULL;
-	}
-    }
-    static void cbTimedRemove(VerilatedVpioCb* cbp) {
-	VpioTimedCbs::iterator it=s_s.m_timedCbs.find(make_pair(cbp->time(),cbp));
-	if (VL_LIKELY(it != s_s.m_timedCbs.end())) {
-	    s_s.m_timedCbs.erase(it);
-	}
-    }
-    static void callTimedCbs() {
-	QData time = VL_TIME_Q();
-	for (VpioTimedCbs::iterator it=s_s.m_timedCbs.begin(); it!=s_s.m_timedCbs.end(); ) {
-	    if (VL_UNLIKELY(it->first <= time)) {
-		VerilatedVpioCb* vop = it->second;
-		++it;  // iterator may be deleted by callback
-		VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  timed_callback %p\n",vop););
-		(vop->cb_rtnp()) (vop->cb_datap());
-	    }
-	    else { ++it; }
-	}
-    }
-    static QData cbNextDeadline() {
-	VpioTimedCbs::iterator it=s_s.m_timedCbs.begin();
-	if (VL_LIKELY(it!=s_s.m_timedCbs.end())) {
-	    return it->first;
-	} else {
-	    return ~VL_ULL(0);  // maxquad
-	}
-    }
-    static void callCbs(vluint32_t reason) {
-	VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
-	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end();) {
-	    if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
-		it = cbObjList.erase(it);
-		continue;
-	    }
-	    VerilatedVpioCb* vop = *it++;
-	    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  reason_callback %d %p\n",reason,vop););
-	    (vop->cb_rtnp()) (vop->cb_datap());
-	}
-    }
-    static void callValueCbs() {
-	VpioCbList& cbObjList = s_s.m_cbObjLists[cbValueChange];
-        set<VerilatedVpioVar*> update; // set of objects to update after callbacks
-	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end();) {
-	    if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
-		it = cbObjList.erase(it);
-		continue;
-	    }
-	    VerilatedVpioCb* vop = *it++;
-	    if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(vop->cb_datap()->obj)) {
-		void* newDatap = varop->varDatap();
-		void* prevDatap = varop->prevDatap();  // Was malloced when we added the callback
-		VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  value_test %s v[0]=%d/%d %p %p\n",
-					  varop->fullname(), *((CData*)newDatap), *((CData*)prevDatap),
-					  newDatap, prevDatap););
-		if (memcmp(prevDatap, newDatap, varop->entSize())) {
-		    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  value_callback %p %s v[0]=%d\n",
-					      vop,varop->fullname(), *((CData*)newDatap)););
-                    update.insert(varop);
-		    vpi_get_value(vop->cb_datap()->obj, vop->cb_datap()->value);
-		    (vop->cb_rtnp()) (vop->cb_datap());
-		}
-	    }
-	}
-	for (set<VerilatedVpioVar*>::iterator it=update.begin(); it!=update.end(); ++it) {
-	    memcpy((*it)->prevDatap(), (*it)->varDatap(), (*it)->entSize());
-	}
-    }
-
-    static VerilatedVpiError* error_info(); // getter for vpi error info
+    /// Call timed callbacks
+    /// Users should call this from their main loops
+    static void callTimedCbs() VL_MT_UNSAFE_ONE;
+    /// Call value based callbacks
+    /// Users should call this from their main loops
+    static void callValueCbs() VL_MT_UNSAFE_ONE;
+    /// Self test, for internal use only
+    static void selfTest() VL_MT_UNSAFE_ONE;
 };

-#define _VL_VPI_ERROR_SET \
-    do { \
-        va_list args; \
-        va_start(args, message); \
-        VL_VSNPRINTF(m_buff, sizeof(m_buff), message.c_str(), args); \
-        va_end(args); \
-    } while (0)
-
-class VerilatedVpiError {
-    //// Container for vpi error info
-
-    t_vpi_error_info m_errorInfo;
-    bool             m_flag;
-    char             m_buff[VL_VPI_LINE_SIZE];
-    void setError(PLI_BYTE8 *message, PLI_BYTE8 *code, PLI_BYTE8 *file, PLI_INT32 line) {
-	m_errorInfo.message = message;
-	m_errorInfo.file = file;
-	m_errorInfo.line = line;
-	m_errorInfo.code = code;
-	do_callbacks();
-    }
-    void do_callbacks() {
-        if (getError()->level >= vpiError && Verilated::fatalOnVpiError()) {
-          // Stop on vpi error/unsupported
-          vpi_unsupported();
-	}
-        // We need to run above code first because in the case that the callback executes further vpi
-        // functions we will loose the error as it will be overwritten.
-	VerilatedVpi::callCbs(cbPLIError);
-    }
-public:
-
-    VerilatedVpiError() : m_flag(false) {
-	m_buff[0] = '\0';
-	m_errorInfo.product = (PLI_BYTE8*)Verilated::productName();
-    }
-    ~VerilatedVpiError() {}
-    static void selfTest();
-    VerilatedVpiError* setMessage(PLI_INT32 level) {
-	m_flag=true;
-	m_errorInfo.level = level;
-        return this;
-    }
-    void setMessage(string file, PLI_INT32 line, string message, ...) {
-	static VL_THREAD string filehold;
-        _VL_VPI_ERROR_SET;
-        m_errorInfo.state = vpiPLI;
-	filehold = file;
-        setError((PLI_BYTE8*)m_buff, NULL, (PLI_BYTE8*)filehold.c_str(), line);
-    }
-    p_vpi_error_info getError() {
-	if (m_flag) return &m_errorInfo;
-	return NULL;
-    }
-    void resetError() {
-	m_flag=false;
-    }
-    static void vpi_unsupported() {
-	// Not supported yet
-	p_vpi_error_info error_info_p = VerilatedVpi::error_info()->getError();
-	if (error_info_p) {
-	    vl_fatal(error_info_p->file, error_info_p->line, "", error_info_p->message);
-	    return;
-	}
-        vl_fatal(__FILE__, __LINE__, "", "vpi_unsupported called without error info set");
-    }
-    static const char* strFromVpiVal(PLI_INT32 vpiVal);
-    static const char* strFromVpiObjType(PLI_INT32 vpiVal);
-    static const char* strFromVpiMethod(PLI_INT32 vpiVal);
-    static const char* strFromVpiCallbackReason(PLI_INT32 vpiVal);
-    static const char* strFromVpiProp(PLI_INT32 vpiVal);
-};
-
-//======================================================================

 #endif // Guard
@@ -42,49 +42,100 @@
 # else
 #  define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
 # endif
+# define VL_ATTR_PURE __attribute__ ((pure))
 # define VL_ATTR_UNUSED __attribute__ ((unused))
 # define VL_FUNC  __func__
+# if defined(__clang__) && defined(VL_THREADED)
+#  define VL_ACQUIRE(...) __attribute__ ((acquire_capability(__VA_ARGS__)))
+#  define VL_ACQUIRE_SHARED(...) __attribute__ ((acquire_shared_capability(__VA_ARGS__)))
+#  define VL_RELEASE(...) __attribute__ ((release_capability(__VA_ARGS__)))
+#  define VL_RELEASE_SHARED(...) __attribute__ ((release_shared_capability(__VA_ARGS__)))
+#  define VL_TRY_ACQUIRE(...) __attribute__ ((try_acquire_capability(__VA_ARGS__)))
+#  define VL_TRY_ACQUIRE_SHARED(...) __attribute__ ((try_acquire_shared_capability(__VA_ARGS__)))
+#  define VL_CAPABILITY(x) __attribute__ ((capability(x)))
+#  define VL_REQUIRES(x) __attribute__ ((requires_capability(x)))
+#  define VL_GUARDED_BY(x) __attribute__ ((guarded_by(x)))
+#  define VL_EXCLUDES(x) __attribute__ ((locks_excluded(x)))
+#  define VL_SCOPED_CAPABILITY __attribute__ ((scoped_lockable))
+# endif
 # define VL_LIKELY(x)	__builtin_expect(!!(x), 1)
 # define VL_UNLIKELY(x)	__builtin_expect(!!(x), 0)
+# define VL_UNREACHABLE __builtin_unreachable();
 # define VL_PREFETCH_RD(p) __builtin_prefetch((p),0)
 # define VL_PREFETCH_RW(p) __builtin_prefetch((p),1)
 #elif defined(_MSC_VER)
-# define VL_ATTR_ALIGNED(alignment)
-# define VL_ATTR_ALWINLINE
-# define VL_ATTR_NORETURN
-# define VL_ATTR_PRINTF(fmtArgNum)
-# define VL_ATTR_UNUSED
 # define VL_FUNC  __FUNCTION__
-# define VL_LIKELY(x)	(!!(x))
-# define VL_UNLIKELY(x)	(!!(x))
-# define VL_PREFETCH_RD(p)
-# define VL_PREFETCH_RW(p)
-#else
+#endif
+
+// Defaults for unsupported compiler features
+#ifndef VL_ATTR_ALIGNED
 # define VL_ATTR_ALIGNED(alignment)	///< Align structure to specified byte alignment
+#endif
+#ifndef VL_ATTR_ALWINLINE
 # define VL_ATTR_ALWINLINE		///< Inline, even when not optimizing
+#endif
+#ifndef VL_ATTR_NORETURN
 # define VL_ATTR_NORETURN		///< Function does not ever return
+#endif
+#ifndef VL_ATTR_PRINTF
 # define VL_ATTR_PRINTF(fmtArgNum)	///< Function with printf format checking
+#endif
+#ifndef VL_ATTR_PURE
+# define VL_ATTR_PURE			///< Function is pure (and thus also VL_MT_SAFE)
+#endif
+#ifndef VL_ATTR_UNUSED
 # define VL_ATTR_UNUSED			///< Function that may be never used
+#endif
+#ifndef VL_FUNC
 # define VL_FUNC "__func__"		///< Name of current function for error macros
+#endif
+#ifndef VL_CAPABILITY
+# define VL_ACQUIRE(...)		///< Function requires a capability/lock (-fthread-safety)
+# define VL_ACQUIRE_SHARED(...)		///< Function aquires a shared capability/lock (-fthread-safety)
+# define VL_RELEASE(...)		///< Function releases a capability/lock (-fthread-safety)
+# define VL_RELEASE_SHARED(...)		///< Function releases a shared capability/lock (-fthread-safety)
+# define VL_TRY_ACQUIRE(...)		///< Function returns bool if aquired a capability (-fthread-safety)
+# define VL_TRY_ACQUIRE_SHARED(...)	///< Function returns bool if aquired a shared capability (-fthread-safety)
+# define VL_REQUIRES(x)			///< Function requires a capability inbound (-fthread-safety)
+# define VL_EXCLUDES(x)			///< Function requires not having a capability inbound (-fthread-safety)
+# define VL_CAPABILITY(x)		///< Name of capability/lock (-fthread-safety)
+# define VL_GUARDED_BY(x)		///< Name of mutex protecting this variable (-fthread-safety)
+# define VL_SCOPED_CAPABILITY		///< Scoped threaded capability/lock (-fthread-safety)
+#endif
+#ifndef VL_LIKELY
 # define VL_LIKELY(x)	(!!(x))		///< Boolean expression more often true than false
 # define VL_UNLIKELY(x)	(!!(x))		///< Boolean expression more often false than true
+#endif
+#ifndef VL_UNREACHABLE
+# define VL_UNREACHABLE			///< Point that may never be reached
+#endif
+#ifndef VL_PREFETCH_RD
 # define VL_PREFETCH_RD(p)		///< Prefetch data with read intent
+#endif
+#ifndef VL_PREFETCH_RW
 # define VL_PREFETCH_RW(p)		///< Prefetch data with read/write intent
 #endif

 #ifdef VL_THREADED
 # ifdef __GNUC__
-#  define VL_THREAD	__thread	///< Storage class for thread-local storage
+#  if (__cplusplus < 201103L) && !defined(VL_THREADED_NO_C11_WARNING)
+#    error "VL_THREADED/--threads support requires C++-11 or newer only; use newer compiler"
+#  endif
 # else
 #  error "Unsupported compiler for VL_THREADED: No thread-local declarator"
 # endif
-# define VL_STATIC_OR_THREAD		///< Static if unthreaded, as some strings can be faster
-//					///< if non-dynamic and can't do "static VL_THREAD string"
+# define VL_THREAD_LOCAL thread_local	///< Use new C++ static local thread
 #else
-# define VL_THREAD			///< Storage class for thread-local storage
-# define VL_STATIC_OR_THREAD static	///< Static if unthreaded, as some strings can be faster
-//					///< if non-dynamic and can't do "static VL_THREAD string"
+# define VL_THREAD_LOCAL		///< Use new C++ static local thread
 #endif
+#define VL_THREAD			///< Deprecated
+#define VL_STATIC_OR_THREAD static	///< Deprecated
+
+#define VL_PURE  ///< Comment tag that Function is pure (and thus also VL_MT_SAFE)
+#define VL_MT_SAFE  ///< Comment tag that function is threadsafe when VL_THREADED
+#define VL_MT_SAFE_POSTINIT  ///< Comment tag that function is threadsafe when VL_THREADED, only during normal operation (post-init)
+#define VL_MT_UNSAFE  ///< Comment tag that function is not threadsafe when VL_THREADED
+#define VL_MT_UNSAFE_ONE  ///< Comment tag that function is not threadsafe when VL_THREADED, protected to make sure single-caller

 #ifdef _MSC_VER
 # define VL_ULL(c) (c##ui64)	///< Add appropriate suffix to 64-bit constant
@@ -93,9 +144,9 @@
 #endif

 // 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
+#define VL_UL(c) (static_cast<IData>(c##UL))	///< Add appropriate suffix to 32-bit constant

-#ifdef VL_CPPCHECK
+#if defined(VL_CPPCHECK) || defined(__clang_analyzer__)
 # define VL_DANGLING(v)
 #else
 # define VL_DANGLING(v) do { (v) = NULL; } while(0)	///< After e.g. delete, set variable to NULL to indicate must not use later
@@ -105,10 +156,22 @@
 // C++-2011

 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+# define VL_EQ_DELETE = delete
 # define VL_HAS_UNIQUE_PTR
-# define VL_UNIQUE_PTR unique_ptr
+# define VL_HAS_UNORDERED_MAP
+# define VL_HAS_UNORDERED_SET
+# define vl_unique_ptr std::unique_ptr
+# define vl_unordered_map std::unordered_map
+# define vl_unordered_set std::unordered_set
+# define VL_INCLUDE_UNORDERED_MAP <unordered_map>
+# define VL_INCLUDE_UNORDERED_SET <unordered_set>
 #else
-# define VL_UNIQUE_PTR auto_ptr
+# define VL_EQ_DELETE
+# define vl_unique_ptr std::auto_ptr
+# define vl_unordered_map std::map
+# define vl_unordered_set std::set
+# define VL_INCLUDE_UNORDERED_MAP <map>
+# define VL_INCLUDE_UNORDERED_SET <set>
 #endif

 //=========================================================================
@@ -248,6 +311,14 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 /// Words this number of bits needs (1 bit=1 word)
 #define VL_WORDS_I(nbits) (((nbits)+(VL_WORDSIZE-1))/VL_WORDSIZE)

+//=========================================================================
+// Class definition helpers
+
+// Used to declare a class as uncopyable; put after a private:
+#define VL_UNCOPYABLE(Type)  \
+    Type(const Type& other) VL_EQ_DELETE;  \
+    Type& operator= (const Type&) VL_EQ_DELETE
+
 //=========================================================================
 // Verilated function size macros

@@ -105,10 +105,12 @@ typedef unsigned char    PLI_UBYTE8;

 /* object is defined imported by the application */

+#undef XXTERN
 #define XXTERN PLI_EXTERN PLI_DLLISPEC

 /* object is exported by the application */

+#undef EETERN
 #define EETERN PLI_EXTERN PLI_DLLESPEC
 #endif

@@ -124,7 +124,7 @@ if [ x"$dir_arg" != x ]; then
 else

 # Waiting for this to be detected by the "$instcmd $src $dsttmp" command
-# might cause directories to be created, which would be especially bad 
+# might cause directories to be created, which would be especially bad
 # if $src (and thus $dsttmp) contains '*'.

 	if [ -f $src -o -d $src ]
@@ -134,7 +134,7 @@ else
 		echo "install:  $src does not exist"
 		exit 1
 	fi
-	
+
 	if [ x"$dst" = x ]
 	then
 		echo "install:	no destination specified"
@@ -162,7 +162,7 @@ dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`

 # Skip lots of stat calls in the usual case.
 if [ ! -d "$dstdir" ]; then
-defaultIFS='	
+defaultIFS='
 '
 IFS="${IFS-${defaultIFS}}"

@@ -201,17 +201,17 @@ else

 # If we're going to rename the final executable, determine the name now.

-	if [ x"$transformarg" = x ] 
+	if [ x"$transformarg" = x ]
 	then
 		dstfile=`basename $dst`
 	else
-		dstfile=`basename $dst $transformbasename | 
+		dstfile=`basename $dst $transformbasename |
 			sed $transformarg`$transformbasename
 	fi

 # don't allow the sed command to completely eliminate the filename

-	if [ x"$dstfile" = x ] 
+	if [ x"$dstfile" = x ]
 	then
 		dstfile=`basename $dst`
 	else
@@ -242,7 +242,7 @@ else
 # Now rename the file to the real destination.

 	$doit $rmcmd -f $dstdir/$dstfile &&
-	$doit $mvcmd $dsttmp $dstdir/$dstfile 
+	$doit $mvcmd $dsttmp $dstdir/$dstfile

 fi &&

@@ -237,10 +237,10 @@ implementation is not found, the system will look in turn for overloaded
 implementations up the inheritance hierarchy. For example calling C<accept>
 on C<AstIf> will look in turn for:

-  void visit (AstIf* nodep, AstNUser* vup)
-  void visit (AstNodeIf* nodep, AstNUser* vup)
-  void visit (AstNodeStmt* nodep, AstNUser* vup)
-  void visit (AstNode* nodep, AstNUser* vup)
+  void visit (AstIf* nodep)
+  void visit (AstNodeIf* nodep)
+  void visit (AstNodeStmt* nodep)
+  void visit (AstNode* nodep)

 There are three ways data is passed between visitor functions.

@@ -485,10 +485,10 @@ be warning free.

 =item --enable-longtests

-In addition to the standard C, SystemC tests also run the tests in the
-C<test_verilated> and C<test_regress> directories when using I<make test>.
-This is disabled by default as SystemC installation problems would
-otherwise falsely indicate a Verilator problem.
+In addition to the standard C, SystemC examples, also run the tests in the
+C<test_regress> directory when using I<make test>.  This is disabled by
+default as SystemC installation problems would otherwise falsely indicate a
+Verilator problem.

 =back

@@ -709,7 +709,7 @@ Start GDB, then C<start> with the remaining arguments.
  Temporary breakpoint 1, main (argc=13, argv=0xbfffefa4, env=0xbfffefdc)
      at ../Verilator.cpp:615
  615         ios::sync_with_stdio();
-  (gdb) 
+  (gdb)

 You can then continue execution with breakpoints as required.

@@ -8,7 +8,7 @@ use strict;
 #======================================================================
 # main

-eval `modulecmd perl add synopsys-vcs_mx`;
+eval `modulecmd perl add synopsys-sim`;
 exec('vcs',@ARGV);

 #######################################################################
@@ -48,25 +48,25 @@ obj_dbg:

 .SUFFIXES:

-.PHONY: ../verilator_bin ../verilator_bin_dbg ../verilator_coverage_bin_dbg
+.PHONY: ../bin/verilator_bin ../bin/verilator_bin_dbg ../bin/verilator_coverage_bin_dbg

-opt: ../verilator_bin
+opt: ../bin/verilator_bin
 ifeq ($(VERILATOR_NO_OPT_BUILD),1)	# Faster laptop development... One build
-../verilator_bin: ../verilator_bin_dbg
+../bin/verilator_bin: ../bin/verilator_bin_dbg
 	-rm -rf $@ $@.exe
 	-cp -p $<$(EXEEXT) $@$(EXEEXT)
 else
-../verilator_bin: obj_opt prefiles
+../bin/verilator_bin: obj_opt prefiles
 	cd obj_opt && $(MAKE) -j 1  TGT=../$@ -f ../Makefile_obj serial
 	cd obj_opt && $(MAKE)       TGT=../$@ -f ../Makefile_obj
 endif

-dbg: ../verilator_bin_dbg ../verilator_coverage_bin_dbg
-../verilator_bin_dbg: obj_dbg prefiles
+dbg: ../bin/verilator_bin_dbg ../bin/verilator_coverage_bin_dbg
+../bin/verilator_bin_dbg: obj_dbg prefiles
 	cd obj_dbg && $(MAKE) -j 1  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
 	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj

-../verilator_coverage_bin_dbg: obj_dbg prefiles
+../bin/verilator_coverage_bin_dbg: obj_dbg prefiles
 	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj serial_vlcov
 	cd obj_dbg && $(MAKE)       TGT=../$@ VL_DEBUG=1 VL_VLCOV=1 -f ../Makefile_obj

@@ -64,6 +64,8 @@ LDFLAGS += @LDFLAGS@
 EXEEXT = @EXEEXT@
 CFG_CXXFLAGS_SRC = @CFG_CXXFLAGS_SRC@
 CFG_CXXFLAGS_PARSER = @CFG_CXXFLAGS_PARSER@
+# Compiler flags that turn on extra warnings
+CFG_CXXFLAGS_WEXTRA = @CFG_CXXFLAGS_WEXTRA@

 #### End of system configuration section. ####

@@ -73,7 +75,7 @@ TGT = ../../verilator_bin
 #################
 ifeq ($(VL_DEBUG),)
 # Optimize
-COPT = -O
+COPT = -O2
 else
 # Debug
 COPT = -ggdb -DVL_DEBUG
@@ -97,20 +99,15 @@ 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 $(CFG_CXXFLAGS_SRC) -Werror
+CPPFLAGS += -W -Wall $(CFG_CXXFLAGS_WEXTRA) $(CFG_CXXFLAGS_SRC) -Werror
 #CPPFLAGS += -pedantic-errors
 else
 CPPFLAGS += $(CFG_CXXFLAGS_SRC)
 endif
+
 CPPFLAGSWALL   = $(CPPFLAGS)
 CPPFLAGSPARSER = $(CPPFLAGS) $(CFG_CXXFLAGS_PARSER)

-ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
- SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
-#else if set, leave as-is.
-#else if SYSTEMPERL="" don't set _INCLUDE so source will figure it out
-endif
-
 # Allow RPM builds to specify hardcoded data directories
 # To do this:
 ifeq ($(CFG_WITH_DEFENV),yes)
@@ -118,8 +115,6 @@ ifeq ($(CFG_WITH_DEFENV),yes)
 CPPFLAGS += -DDEFENV_SYSTEMC_ARCH=\"$(SYSTEMC_ARCH)\"
 CPPFLAGS += -DDEFENV_SYSTEMC_INCLUDE=\"$(SYSTEMC_INCLUDE)\"
 CPPFLAGS += -DDEFENV_SYSTEMC_LIBDIR=\"$(SYSTEMC_LIBDIR)\"
- CPPFLAGS += -DDEFENV_SYSTEMPERL=\"$(SYSTEMPERL)\"
- CPPFLAGS += -DDEFENV_SYSTEMPERL_INCLUDE=\"$(SYSTEMPERL_INCLUDE)\"
 ifeq ($(VERILATOR_ROOT),)	# Use what we're given, or intuit
  CPPFLAGS += -DDEFENV_VERILATOR_ROOT=\"$(pkgdatadir)\"
 else
@@ -176,7 +176,7 @@ private:
 	    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 
+		// 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 (=).");
 	    }
@@ -323,7 +323,7 @@ private:
 	// Read sensitivitues
 	m_itemCombo = false;
 	m_itemSequent = false;
-	oldsensesp->iterateAndNext(*this);
+	if (oldsensesp) oldsensesp->iterateAndNext(*this);
 	bool combo = m_itemCombo;
 	bool sequent = m_itemSequent;

@@ -438,5 +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);
+    V3Global::dumpCheckGlobalTree("active", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -108,7 +108,7 @@ private:
 	    // Move the active's contents to the other active
 	    UINFO(4,"   merge active "<<sensesp<<" into "<<wantp<<endl);
 	    if (nodep->sensesStorep()) {
-		if (sensesp != nodep->sensesStorep()) nodep->v3fatalSrc("sensesStore should have been deleted earlier if different\n");
+		if (sensesp != nodep->sensesStorep()) nodep->v3fatalSrc("sensesStore should have been deleted earlier if different");
 		sensesp->unlinkFrBack();
 		// There may be other references to same sense tree,
 		// we'll be removing all references when we get to them,
@@ -160,5 +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);
+    V3Global::dumpCheckGlobalTree("activetop", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -67,7 +67,7 @@ private:
 	    timesp->unlinkFrBackWithNext();
 	    timenewp->addNext(timesp);
 	}
-	nodep->fmtp()->exprsp(timenewp);
+	nodep->fmtp()->addExprsp(timenewp);
 	if (!nodep->fmtp()->scopeNamep() && nodep->fmtp()->formatScopeTracking()) {
 	    nodep->fmtp()->scopeNamep(new AstScopeName(nodep->fileline()));
 	}
@@ -119,7 +119,7 @@ private:
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
-	if (stmtsp) bodysp = bodysp->addNext(stmtsp);
+	if (bodysp && stmtsp) bodysp = bodysp->addNext(stmtsp);
 	AstIf* ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
 	bodysp = ifp;
 	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
@@ -162,7 +162,7 @@ private:
 	// Bye
 	pushDeletep(nodep); VL_DANGLING(nodep);
    }
-    
+
    virtual void visit(AstIf* nodep) {
 	if (nodep->user1SetOnce()) return;
 	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
@@ -177,12 +177,12 @@ private:

 		// Recurse into the true case.
 		ifp->ifsp()->iterateAndNext(*this);
-		
+
 		// If the last else is not an else if, recurse into that too.
 		if (ifp->elsesp() && !nextifp) {
 		    ifp->elsesp()->iterateAndNext(*this);
 		}
-		
+
 		// Build a bitmask of the true predicates
 	        AstNode* predp = ifp->condp()->cloneTree(false);
 	        if (propp) {
@@ -195,13 +195,16 @@ private:
 		if (ifp->elsesp() && !nextifp) {
 		    hasDefaultElse = true;
 		}
-		
+
 		ifp = nextifp;
 	    } while (ifp);

 	    AstNode *newifp = nodep->cloneTree(false);
 	    bool allow_none = nodep->unique0Pragma();
-	    
+
+	    // Empty case means no property
+	    if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
+
 	    // 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)
@@ -246,20 +249,10 @@ private:
 		    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 			for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 			    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);
-
+			    if (nodep->casex() || nodep->casez() || nodep->caseInside()) {
+				onep = AstEqWild::newTyped(itemp->fileline(),
+							   nodep->exprp()->cloneTree(false),
+							   icondp->cloneTree(false));
 			    } else {
 				onep = AstEq::newTyped(icondp->fileline(),
 						       nodep->exprp()->cloneTree(false),
@@ -269,6 +262,9 @@ private:
 			    else propp = onep;
 			}
 		    }
+		    // Empty case means no property
+		    if (!propp) propp = new AstConst(nodep->fileline(), AstConst::LogicFalse());
+
 		    bool allow_none = has_default || nodep->unique0Pragma();
 		    AstNode* ohot = (allow_none
 				     ? static_cast<AstNode*>(new AstOneHot0(nodep->fileline(), propp))
@@ -354,5 +350,5 @@ public:
 void V3Assert::assertAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    AssertVisitor visitor (nodep);
-    V3Global::dumpCheckGlobalTree("assert.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("assert", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -137,5 +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);
+    V3Global::dumpCheckGlobalTree("assertpre", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -716,6 +716,7 @@ void AstNode::deleteTree() {

 #ifdef VL_LEAK_CHECKS
 void* AstNode::operator new(size_t size) {
+    // Optimization note: Aligning to cache line is a loss, due to lost packing
    AstNode* objp = static_cast<AstNode*>(::operator new(size));
    V3Broken::addNewed(objp);
    return objp;
@@ -734,6 +735,7 @@ void AstNode::operator delete(void* objp, size_t size) {

 void AstNode::iterateChildren(AstNVisitor& v) {
    // This is a very hot function
+    // Optimization note: Grabbing m_op#p->m_nextp is a net loss
    ASTNODE_PREFETCH(m_op1p);
    ASTNODE_PREFETCH(m_op2p);
    ASTNODE_PREFETCH(m_op3p);
@@ -766,11 +768,13 @@ void AstNode::iterateAndNext(AstNVisitor& v) {
 #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
+    if (nodep) ASTNODE_PREFETCH(nodep->m_nextp);
    while (nodep) {   // effectively: if (!this) return;  // Callers rely on this
+	if (nodep->m_nextp) ASTNODE_PREFETCH(nodep->m_nextp->m_nextp);
 	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");
+	// Optimization note: Doing PREFETCH_RW on m_iterpp is a net even
 	// cppcheck-suppress nullPointer
 	niterp->m_iterpp = &niterp;
 	niterp->accept(v);
@@ -902,7 +906,7 @@ bool AstNode::sameTreeIter(AstNode* node1p, AstNode* node2p, bool ignNext, bool
 //======================================================================
 // Static utilities

-ostream& operator<<(ostream& os, V3Hash rhs) {
+ostream& operator<<(ostream& os, const V3Hash& rhs) {
    return os<<hex<<setw(2)<<setfill('0')<<rhs.depth()
 	     <<"_"<<setw(6)<<setfill('0')<<rhs.hshval();
 }
@@ -1033,7 +1037,7 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
    if (doDump) {
 	{   // Write log & close
 	    UINFO(2,"Dumping "<<filename<<endl);
-	    const VL_UNIQUE_PTR<ofstream> logsp (V3File::new_ofstream(filename, append));
+	    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;
@@ -1057,6 +1061,8 @@ void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
    editCountSetLast();
 }

+void AstNode::v3errorEndFatal(ostringstream& str) const { v3errorEnd(str); assert(0); }
+
 void AstNode::v3errorEnd(ostringstream& str) const {
    if (!dynamic_cast<const AstNode*>(this)) {
 	// No known cases cause this, but better than a core dump
@@ -61,7 +61,7 @@ public:
  inline bool operator== (AstType lhs, AstType rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstType lhs, AstType::en rhs) { return (lhs.m_e == rhs); }
  inline bool operator== (AstType::en lhs, AstType rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, AstType rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstType& rhs) { return os<<rhs.ascii(); }

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

@@ -82,7 +82,7 @@ public:
    };
    enum en m_e;
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "UNSIGNED","SIGNED","NOSIGN"
 	};
 	return names[m_e];
@@ -107,7 +107,7 @@ public:
  inline bool operator== (AstNumeric lhs, AstNumeric rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstNumeric lhs, AstNumeric::en rhs) { return (lhs.m_e == rhs); }
  inline bool operator== (AstNumeric::en lhs, AstNumeric rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, AstNumeric rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstNumeric& rhs) { return os<<rhs.ascii(); }

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

@@ -203,19 +203,42 @@ public:
 	return AstEdgeType::ET_ILLEGAL;
    }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "%E-edge", "ANY", "BOTH", "POS", "NEG", "HIGH", "LOW",
 	    "COMBO","INITIAL","SETTLE","NEVER"
 	};
 	return names[m_e];
-    };
+    }
    const char* verilogKwd() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "%E-edge", "[any]", "edge", "posedge", "negedge", "[high]","[low]",
 	    "*","[initial]","[settle]","[never]"
 	};
 	return names[m_e];
-    };
+    }
+    // Return true iff this and the other have mutually exclusive transitions
+    bool exclusiveEdge(const AstEdgeType& other) const {
+        switch (m_e) {
+        case AstEdgeType::ET_POSEDGE:
+            switch (other.m_e) {
+            case AstEdgeType::ET_NEGEDGE:  // FALLTHRU
+            case AstEdgeType::ET_LOWEDGE:
+                return true;
+            default: {}
+            }
+            break;
+        case AstEdgeType::ET_NEGEDGE:
+            switch (other.m_e) {
+            case AstEdgeType::ET_POSEDGE:  // FALLTHRU
+            case AstEdgeType::ET_HIGHEDGE:
+                return true;
+            default: {}
+            }
+            break;
+        default: {}
+        }
+        return false;
+    }
    inline AstEdgeType () : m_e(ET_ILLEGAL) {}
    // cppcheck-suppress noExplicitConstructor
    inline AstEdgeType (en _e) : m_e(_e) {}
@@ -270,7 +293,7 @@ public:
    };
    enum en m_e;
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "%E-AT",
 	    "DIM_BITS", "DIM_DIMENSIONS", "DIM_HIGH", "DIM_INCREMENT", "DIM_LEFT",
 	    "DIM_LOW", "DIM_RIGHT", "DIM_SIZE", "DIM_UNPK_DIMENSIONS",
@@ -315,7 +338,7 @@ public:
    };
    enum en m_e;
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "%E-unk",
 	    "bit", "byte", "chandle", "int", "integer", "logic", "longint",
 	    "real", "shortint", "shortreal", "time",
@@ -328,7 +351,7 @@ public:
 	return names[m_e];
    };
    const char* dpiType() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "%E-unk",
 	    "unsigned char", "char", "void*", "int", "int", "svLogic", "long long",
 	    "double", "short int", "float", "long long",
@@ -340,7 +363,7 @@ public:
 	};
 	return names[m_e];
    };
-    static void test() {
+    static void selfTest() {
 	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).ascii()," MAX"),"Enum array mismatch");
 	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).dpiType()," MAX"),"Enum array mismatch");
    }
@@ -396,7 +419,7 @@ public:
 	return (m_e==LOGIC || m_e==BIT);
    }
    bool isDpiUnsupported() const {
-	return (m_e==LOGIC || m_e==TIME);
+	return (m_e==TIME);
    }
    bool isDpiUnsignable() const {  // Can add "unsigned" to DPI
 	return (m_e==BYTE || m_e==SHORTINT || m_e==INT || m_e==LONGINT || m_e==INTEGER);
@@ -427,6 +450,7 @@ public:
 	SUPPLY0,
 	SUPPLY1,
 	WIRE,
+	WREAL,
 	IMPLICITWIRE,
 	TRIWIRE,
 	TRI0,
@@ -445,16 +469,16 @@ public:
    explicit inline AstVarType (int _e) : m_e(static_cast<en>(_e)) {}
    operator en () const { return m_e; }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const 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
@@ -463,7 +487,7 @@ public:
  inline bool operator== (AstVarType lhs, AstVarType rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstVarType lhs, AstVarType::en rhs) { return (lhs.m_e == rhs); }
  inline bool operator== (AstVarType::en lhs, AstVarType rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, AstVarType rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstVarType& rhs) { return os<<rhs.ascii(); }

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

@@ -488,14 +512,14 @@ public:
 	else return m_e;
    }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "","VL_LIKELY","VL_UNLIKELY"};
 	return names[m_e]; }
  };
  inline bool operator== (AstBranchPred lhs, AstBranchPred rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstBranchPred lhs, AstBranchPred::en rhs) { return (lhs.m_e == rhs); }
  inline bool operator== (AstBranchPred::en lhs, AstBranchPred rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, AstBranchPred rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstBranchPred& rhs) { return os<<rhs.ascii(); }

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

@@ -521,14 +545,14 @@ public:
 	else return m_e;
    }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const 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(); }
+  inline ostream& operator<<(ostream& os, const AstVarAttrClocker& rhs) { return os<<rhs.ascii(); }

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

@@ -547,7 +571,7 @@ public:
    explicit inline VAlwaysKwd (int _e) : m_e(static_cast<en>(_e)) {}
    operator en () const { return m_e; }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "always","always_ff","always_latch","always_comb"};
 	return names[m_e]; }
  };
@@ -597,7 +621,7 @@ public:
    bool addNewline() const { return m_e!=DT_WRITE; }
    bool needScopeTracking() const { return m_e!=DT_DISPLAY && m_e!=DT_WRITE; }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "display","write","info","error","warning","fatal"};
 	return names[m_e]; }
  };
@@ -620,14 +644,14 @@ public:
    explicit inline AstParseRefExp (int _e) : m_e(static_cast<en>(_e)) {}
    operator en () const { return m_e; }
    const char* ascii() const {
-	static const char* names[] = {
+	static const char* const names[] = {
 	    "","TEXT","PREDOT"};
 	return names[m_e]; }
  };
  inline bool operator== (AstParseRefExp lhs, AstParseRefExp rhs) { return (lhs.m_e == rhs.m_e); }
  inline bool operator== (AstParseRefExp lhs, AstParseRefExp::en rhs) { return (lhs.m_e == rhs); }
  inline bool operator== (AstParseRefExp::en lhs, AstParseRefExp rhs) { return (lhs == rhs.m_e); }
-  inline ostream& operator<<(ostream& os, AstParseRefExp rhs) { return os<<rhs.ascii(); }
+  inline ostream& operator<<(ostream& os, const AstParseRefExp& rhs) { return os<<rhs.ascii(); }

 //######################################################################
 // VNumRange - Structure containing numberic range information
@@ -657,10 +681,14 @@ struct VNumRange {
 	return false;
    }
    //
+    class LeftRight {};
    VNumRange() : m_hi(0), m_lo(0), mu_flags(0) {}
    VNumRange(int hi, int lo, bool littleEndian)
 	: m_hi(0), m_lo(0), mu_flags(0)
 	{ init(hi,lo,littleEndian); }
+    VNumRange(LeftRight, int left, int right)
+        : m_hi(0), m_lo(0), mu_flags(0)
+        { init((right>left)?right:left, (right>left)?left:right, (right>left)); }
    ~VNumRange() {}
    // MEMBERS
    void init(int hi, int lo, bool littleEndian) {
@@ -679,7 +707,7 @@ struct VNumRange {
 	{ return (!m_ranged || (m_lo==0 && m_hi>=1 && !m_littleEndian)); }
    void dump(ostream& str) const { if (ranged()) str<<"["<<left()<<":"<<right()<<"]"; else str<<"[norg]"; }
 };
-inline ostream& operator<<(ostream& os, VNumRange rhs) { rhs.dump(os); return os; }
+inline ostream& operator<<(ostream& os, const VNumRange& rhs) { rhs.dump(os); return os; }

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

@@ -708,7 +736,7 @@ struct VBasicTypeKey {
 	if (!(m_nrange == rhs.m_nrange)) return false;  // lhs > rhs
 	return false; }
    VBasicTypeKey(int width, int widthMin, AstNumeric numeric, AstBasicDTypeKwd kwd,
-	     VNumRange nrange)
+		  const VNumRange& nrange)
 	: m_width(width), m_widthMin(widthMin), m_numeric(numeric),
 	  m_keyword(kwd), m_nrange(nrange) {}
    ~VBasicTypeKey() {}
@@ -732,8 +760,10 @@ class VNUser {
    } m_u;
 public:
    VNUser() {}
+    // non-explicit:
+    // cppcheck-suppress noExplicitConstructor
    VNUser(int i) { m_u.up = 0; m_u.ui = i; }
-    VNUser(void* p) { m_u.up = p; }
+    explicit VNUser(void* p) { m_u.up = p; }
    ~VNUser() {}
    // Casters
    WidthVP*	c() { return ((WidthVP*)m_u.up); }
@@ -890,7 +920,7 @@ public:
    AstNode* oldp() const { return m_oldp; }
    void dump(ostream& str=cout) const;
 };
-inline ostream& operator<<(ostream& os, AstNRelinker& rhs) { rhs.dump(os); return os;}
+inline ostream& operator<<(ostream& os, const AstNRelinker& rhs) { rhs.dump(os); return os;}

 //######################################################################
 // V3Hash -- Node hashing for V3Combine
@@ -902,7 +932,8 @@ class V3Hash {
    uint32_t	m_both;
    static const uint32_t M24 = ((1<<24)-1);
    void setBoth(uint32_t depth, uint32_t hshval) {
-	if (depth==0) depth=1; if (depth>255) depth=255;
+	if (depth==0) depth=1;
+	if (depth>255) depth=255;
 	m_both = (depth<<24) | (hshval & M24);
    }
 public:
@@ -915,7 +946,7 @@ public:
    inline bool operator== (const V3Hash& rh) const { return m_both==rh.m_both; }
    inline bool operator!= (const V3Hash& rh) const { return m_both!=rh.m_both; }
    inline bool operator< (const V3Hash& rh) const { return m_both<rh.m_both; }
-    // CREATORS
+    // CONSTRUCTORS
    class Illegal {};		// for creator type-overload selection
    class FullValue {};		// for creator type-overload selection
    explicit V3Hash(Illegal) { m_both=0; }
@@ -939,7 +970,7 @@ public:
    V3Hash(V3Hash h1, V3Hash h2, V3Hash h3, V3Hash h4) {
 	setBoth(1,((h1.hshval()*31+h2.hshval())*31+h3.hshval())*31+h4.hshval()); }
 };
-ostream& operator<<(ostream& os, V3Hash rhs);
+ostream& operator<<(ostream& os, const V3Hash& rhs);

 //######################################################################
 // AstNode -- Base type of all Ast types
@@ -1084,6 +1115,8 @@ public:
    // ACCESSORS
    virtual string name() const { return ""; }
    virtual void name(const string& name) { this->v3fatalSrc("name() called on object without name() method"); }
+    virtual void tag(const string& text) {}
+    virtual string tag() const { return ""; }
    virtual string verilogKwd() const { return ""; }
    string 	shortName() const;	// Name with __PVT__ removed for concatenating scopes
    static string dedotName(const string& namein);	// Name with dots removed
@@ -1229,6 +1262,7 @@ public:

    // METHODS - dump and error
    void	v3errorEnd(ostringstream& str) const;
+    void	v3errorEndFatal(ostringstream& str) const VL_ATTR_NORETURN;
    string	warnMore() const;
    virtual void dump(ostream& str=cout);
    void	dumpGdb(); // For GDB only
@@ -1254,7 +1288,7 @@ public:

    // METHODS - Iterate on a tree
    AstNode*	cloneTree(bool cloneNextLink);
-    bool	gateTree() { return gateTreeIter(); }  // Is tree gateOptimizable?
+    bool	gateTree() { return gateTreeIter(); }  // Is tree isGateOptimizable?
    bool	sameTree(AstNode* node2p);	// Does tree of this == node2p?
    bool	sameGateTree(AstNode* node2p);	// Does tree of this == node2p?, not allowing non-isGateOptimizable
    void	deleteTree();	// Always deletes the next link
@@ -1280,7 +1314,7 @@ public:
    virtual bool isUnlikely() const { return false; }	// Else $stop or similar statement which means an above IF statement is unlikely to be taken
    virtual int  instrCount() const { return 0; }
    virtual V3Hash sameHash() const { return V3Hash(V3Hash::Illegal()); }  // Not a node that supports it
-    virtual bool same(AstNode* otherp) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
    virtual bool hasDType() const { return false; }	// Iff has a data type; dtype() must be non null
    virtual AstNodeDType* getChildDTypep() const { return NULL; } // Iff has a non-null childDTypep(), as generic node function
    virtual bool maybePointedTo() const { return false; }  // Another AstNode* may have a pointer into this node, other then normal front/back/etc.
@@ -1362,7 +1396,7 @@ public:
    virtual bool stringFlavor() const { return false; }	// N flavor of nodes with both flavors?
    virtual int instrCount()	const { return widthInstrs(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode*) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
 };

 class AstNodeBiop : public AstNodeMath {
@@ -1389,7 +1423,7 @@ public:
    virtual bool stringFlavor() const { return false; }	// N flavor of nodes with both flavors?
    virtual int instrCount()	const { return widthInstrs(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode*) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
 };

 class AstNodeTriop : public AstNodeMath {
@@ -1415,7 +1449,7 @@ public:
    virtual bool sizeMattersThs() = 0; // True if output result depends on ths size
    virtual int instrCount()	const { return widthInstrs(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode*) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
 };

 class AstNodeBiCom : public AstNodeBiop {
@@ -1454,6 +1488,7 @@ public:
    virtual bool sizeMattersLhs() { return false; } virtual bool sizeMattersRhs() { return false; }
    virtual bool sizeMattersThs() { return false; }
    virtual int instrCount()	const { return instrCountBranch(); }
+    virtual AstNode* cloneType(AstNode* condp, AstNode* expr1p, AstNode* expr2p) = 0;
 };

 class AstNodePreSel : public AstNode {
@@ -1474,7 +1509,7 @@ public:
    void	attrp(AstAttrOf* nodep)  { return setOp4p((AstNode*)nodep); }
    // METHODS
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode*) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
 };

 class AstNodeStmt : public AstNode {
@@ -1506,8 +1541,9 @@ public:
    virtual bool cleanRhs() { return true; }
    virtual int  instrCount() const { return widthInstrs(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode*) const { return true; }
+    virtual bool same(const AstNode*) const { return true; }
    virtual string verilogKwd() const { return "="; }
+    virtual bool brokeLhsMustBeLvalue() const = 0;
 };

 class AstNodeFor : public AstNodeStmt {
@@ -1525,7 +1561,7 @@ public:
    virtual bool isGateOptimizable() const { return false; }
    virtual int  instrCount() const { return instrCountBranch(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode* samep) const { return true; }
+    virtual bool same(const AstNode* samep) const { return true; }
 };

 class AstNodeIf : public AstNodeStmt {
@@ -1547,7 +1583,7 @@ public:
    virtual bool isGateDedupable() const { return true; }
    virtual int  instrCount() const { return instrCountBranch(); }
    virtual V3Hash sameHash() const { return V3Hash(); }
-    virtual bool same(AstNode* samep) const { return true; }
+    virtual bool same(const AstNode* samep) const { return true; }
    void    branchPred(AstBranchPred flag) { m_branchPred = flag; }
    AstBranchPred branchPred() const { return m_branchPred; }
 };
@@ -1639,8 +1675,9 @@ public:
    ASTNODE_BASE_FUNCS(NodeText)
    virtual void dump(ostream& str=cout);
    virtual V3Hash sameHash() const { return V3Hash(text()); }
-    virtual bool same(AstNode* samep) const {
-	return text()==samep->castNodeText()->text(); }
+    virtual bool same(const AstNode* samep) const {
+	const AstNodeText* asamep = static_cast<const AstNodeText*>(samep);
+	return text() == asamep->text(); }
    const string& text() const { return m_text; }
 };

@@ -1674,6 +1711,8 @@ public:
    virtual bool maybePointedTo() const { return true; }
    virtual AstNodeDType* virtRefDTypep() const { return NULL; } // Iff has a non-null refDTypep(), as generic node function
    virtual void virtRefDTypep(AstNodeDType* nodep) { }	// Iff has refDTypep(), set as generic node function
+    virtual bool similarDType(AstNodeDType* samep) const = 0;  // Assignable equivalence.  Call skipRefp() on this and samep before calling
+    virtual AstNodeDType* subDTypep() const { return NULL; }  // Iff has a non-null subDTypep(), as generic node function
    //
    // Changing the width may confuse the data type resolution, so must clear TypeTable cache after use.
    void widthForce(int width, int sized) { m_width=width; m_widthMin=sized; }
@@ -1723,6 +1762,9 @@ public:
    virtual int widthAlignBytes() const; // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
    virtual int widthTotalBytes() const; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,...
    // op1 = members
+    virtual bool similarDType(AstNodeDType* samep) const {
+	return this==samep;  // We don't compare members, require exact equivalence
+    }
    AstMemberDType* membersp() const { return op1p()->castMemberDType(); } // op1 = AstMember list
    void addMembersp(AstNode* nodep) { addNOp1p(nodep); }
    bool packed() const { return m_packed; }
@@ -1753,20 +1795,28 @@ public:
    virtual void dump(ostream& str);
    virtual void dumpSmall(ostream& str);
    virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
-						     || (!m_refDTypep && childDTypep()))); return NULL; }
+						      || (!m_refDTypep && childDTypep()))); return NULL; }
    virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
 	m_refDTypep = m_refDTypep->clonep();
    }}
-    virtual bool same(AstNode* samep) const {
-	AstNodeArrayDType* sp = samep->castNodeArrayDType();
-	return (msb()==sp->msb()
-		&& subDTypep()==sp->subDTypep()
-		&& rangenp()->sameTree(sp->rangenp())); }  // HashedDT doesn't recurse, so need to check children
+    virtual bool same(const AstNode* samep) const {
+	const AstNodeArrayDType* asamep = static_cast<const AstNodeArrayDType*>(samep);
+	return (msb()==asamep->msb()
+		&& subDTypep()==asamep->subDTypep()
+		&& rangenp()->sameTree(asamep->rangenp())); }  // HashedDT doesn't recurse, so need to check children
+    virtual bool similarDType(AstNodeDType* samep) const {
+	const AstNodeArrayDType* asamep = static_cast<const AstNodeArrayDType*>(samep);
+	return (asamep
+		&& type() == samep->type()
+		&& msb() == asamep->msb()
+		&& rangenp()->sameTree(asamep->rangenp())
+		&& subDTypep()->skipRefp()->similarDType(asamep->subDTypep()->skipRefp()));
+    }
    virtual V3Hash sameHash() const { return V3Hash(V3Hash(m_refDTypep),V3Hash(msb()),V3Hash(lsb())); }
    AstNodeDType* getChildDTypep() const { return childDTypep(); }
    AstNodeDType* childDTypep() const { return op1p()->castNodeDType(); } // op1 = Range of variable
    void	childDTypep(AstNodeDType* nodep) { setOp1p(nodep); }
-    AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); }
+    virtual AstNodeDType* subDTypep() const { return m_refDTypep ? m_refDTypep : childDTypep(); }
    void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
    virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; }
    virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); }
@@ -1931,6 +1981,8 @@ private:
    bool	m_inLibrary:1;	// From a library, no error if not used, never top level
    bool	m_dead:1;	// LinkDot believes is dead; will remove in Dead visitors
    bool	m_internal:1;	// Internally created
+    bool	m_recursive:1;	// Recursive module
+    bool	m_recursiveClone:1;  // If recursive, what module it clones, otherwise NULL
    int		m_level;	// 1=top module, 2=cell off top module, ...
    int		m_varNum;	// Incrementing variable number
    int		m_typeNum;	// Incrementing implicit type number
@@ -1938,7 +1990,8 @@ public:
    AstNodeModule(FileLine* fl, const string& name)
 	: AstNode (fl)
 	,m_name(name), m_origName(name)
-	,m_modPublic(false), m_modTrace(false), m_inLibrary(false), m_dead(false), m_internal(false)
+	,m_modPublic(false), m_modTrace(false), m_inLibrary(false), m_dead(false)
+	,m_internal(false), m_recursive(false), m_recursiveClone(false)
 	,m_level(0), m_varNum(0), m_typeNum(0) { }
    ASTNODE_BASE_FUNCS(NodeModule)
    virtual void dump(ostream& str);
@@ -1968,6 +2021,10 @@ public:
    bool dead() const	 	{ return m_dead; }
    void internal(bool flag) 	{ m_internal = flag; }
    bool internal() const	{ return m_internal; }
+    void recursive(bool flag) { m_recursive = flag; }
+    bool recursive() const { return m_recursive; }
+    void recursiveClone(bool flag) { m_recursiveClone = flag; }
+    bool recursiveClone() const { return m_recursiveClone; }
 };

 //######################################################################
@@ -26,6 +26,7 @@
 #include <iomanip>
 #include <vector>
 #include <algorithm>
+#include VL_INCLUDE_UNORDERED_SET

 #include "V3Ast.h"
 #include "V3File.h"
@@ -69,7 +70,7 @@ void AstNodeClassDType::repairMemberCache() {
 }

 const char* AstNodeClassDType::broken() const {
-    set<AstMemberDType*> exists;
+    vl_unordered_set<AstMemberDType*> exists;
    for (AstMemberDType* itemp = membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
 	exists.insert(itemp);
    }
@@ -140,6 +141,13 @@ AstNodeBiop* AstLte::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
    }
 }

+AstNodeBiop* AstEqWild::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
+    if (lhsp->isDouble() && rhsp->isDouble()) {
+	return new AstEqD(fl, lhsp, rhsp);
+    } else {
+	return new AstEqWild(fl, lhsp, rhsp);
+    }
+}

 bool AstVar::isSigPublic() const {
    return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp() && !isGenVar()));
@@ -195,6 +203,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();
    }
@@ -217,7 +227,7 @@ string AstVar::vlArgType(bool named, bool forReturn, bool forFunc) const {
 	arg += "float";
    } else if (strtype) {
 	if (isInOnly()) arg += "const ";
-	arg += "string";
+	arg += "std::string";
    } else if (widthMin() <= 8) {
 	arg += "CData";
    } else if (widthMin() <= 16) {
@@ -539,28 +549,28 @@ string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
    return out;
 }

-bool AstSenTree::hasClocked() {
+bool AstSenTree::hasClocked() const {
    if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isClocked()) return true;
    }
    return false;
 }
-bool AstSenTree::hasSettle() {
+bool AstSenTree::hasSettle() const {
    if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isSettle()) return true;
    }
    return false;
 }
-bool AstSenTree::hasInitial() {
+bool AstSenTree::hasInitial() const {
    if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isInitial()) return true;
    }
    return false;
 }
-bool AstSenTree::hasCombo() {
+bool AstSenTree::hasCombo() const {
    if (!sensesp()) this->v3fatalSrc("SENTREE without any SENITEMs under it");
    for (AstNodeSenItem* senp = sensesp(); senp; senp=senp->nextp()->castNodeSenItem()) {
 	if (senp->isCombo()) return true;
@@ -754,10 +764,6 @@ void AstAlways::dump(ostream& str) {
    if (keyword() != VAlwaysKwd::ALWAYS) str<<" ["<<keyword().ascii()<<"]";
 }

-void AstArraySel::dump(ostream& str) {
-    this->AstNode::dump(str);
-    str<<" [start:"<<start()<<"] [length:"<<length()<<"]";
-}
 void AstAttrOf::dump(ostream& str) {
    this->AstNode::dump(str);
    str<<" ["<<attrType().ascii()<<"]";
@@ -773,6 +779,7 @@ void AstCCast::dump(ostream& str) {
 }
 void AstCell::dump(ostream& str) {
    this->AstNode::dump(str);
+    if (recursive()) str<<" [RECURSIVE]";
    if (modp()) { str<<" -> "; modp()->dump(str); }
    else { str<<" ->UNLINKED:"<<modName(); }
 }
@@ -881,6 +888,12 @@ void AstNodeModule::dump(ostream& str) {
    if (modPublic()) str<<" [P]";
    if (inLibrary()) str<<" [LIB]";
    if (dead()) str<<" [DEAD]";
+    if (recursiveClone()) str<<" [RECURSIVE-CLONE]";
+    else if (recursive()) str<<" [RECURSIVE]";
+}
+void AstPackageExport::dump(ostream& str) {
+    this->AstNode::dump(str);
+    str<<" -> "<<packagep();
 }
 void AstPackageImport::dump(ostream& str) {
    this->AstNode::dump(str);
@@ -893,6 +906,12 @@ void AstSel::dump(ostream& str) {
 	if (declElWidth()!=1) str<<"/"<<declElWidth();
    }
 }
+void AstSliceSel::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (declRange().ranged()) {
+        str<<" decl"<<declRange();
+    }
+}
 void AstTypeTable::dump(ostream& str) {
    this->AstNode::dump(str);
    for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
@@ -296,5 +296,5 @@ void V3Begin::debeginAll(AstNetlist* nodep) {
    if (state.anyFuncInBegin()) {
 	BeginRelinkVisitor brvisitor (nodep,&state);
    }
-    V3Global::dumpCheckGlobalTree("begin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("begin", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -29,7 +29,7 @@

 class V3Branch {
 public:
-    // CREATORS
+    // CONSTRUCTORS
    static void branchAll(AstNetlist* rootp);
 };

@@ -31,7 +31,7 @@
 #include <cstdarg>
 #include <unistd.h>
 #include <algorithm>
-#include <map>
+#include VL_INCLUDE_UNORDERED_MAP

 #include "V3Global.h"
 #include "V3Broken.h"
@@ -47,7 +47,7 @@ class BrokenTable : public AstNVisitor {
 private:
    // MEMBERS
    //   For each node, we keep if it exists or not.
-    typedef map<const AstNode*,int> NodeMap;
+    typedef vl_unordered_map<const AstNode*,int> NodeMap;  // Performance matters (when --debug)
    static NodeMap s_nodes;	// Set of all nodes that exist
    // BITMASK
    enum { FLAG_ALLOCATED	= 0x01 };	// new() and not delete()ed
@@ -62,16 +62,20 @@ public:
 	if (debug()>=9) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
-	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted\n");
+	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted");
 	}
 	if (iter!=s_nodes.end()) s_nodes.erase(iter);
    }
+#if defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ == 4
+    // GCC 4.4.* compiler warning bug, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39390
+# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
    static void addNewed(const AstNode* nodep) {
 	// Called by operator new on any node - only if VL_LEAK_CHECKS
 	if (debug()>=9) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter!=s_nodes.end() || (iter->second & FLAG_ALLOCATED)) {
-	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated\n");
+	    nodep->v3fatalSrc("Newing AstNode object that is already allocated");
 	}
 	if (iter == s_nodes.end()) {
 	    int flags = FLAG_ALLOCATED;  // This int needed to appease GCC 4.1.2
@@ -94,16 +98,16 @@ public:
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter == s_nodes.end()) {
 #ifdef VL_LEAK_CHECKS
-	    nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+	    nodep->v3fatalSrc("AstNode is in tree, but not allocated");
 #endif
 	} else {
 	    if (!(iter->second & FLAG_ALLOCATED)) {
 #ifdef VL_LEAK_CHECKS
-		nodep->v3fatalSrc("AstNode is in tree, but not allocated\n");
+		nodep->v3fatalSrc("AstNode is in tree, but not allocated");
 #endif
 	    }
 	    if (iter->second & FLAG_IN_TREE) {
-		nodep->v3fatalSrc("AstNode is already in tree at another location\n");
+		nodep->v3fatalSrc("AstNode is already in tree at another location");
 	    }
 	}
 	int or_flags = FLAG_IN_TREE | (linkable?FLAG_LINKABLE:0);
@@ -236,6 +240,15 @@ private:
 	nodep->iterateChildrenConst(*this);
 	BrokenTable::setUnder(nodep,false);
    }
+    virtual void visit(AstNodeAssign* nodep) {
+	processAndIterate(nodep);
+	if (v3Global.assertDTypesResolved()
+	    && nodep->brokeLhsMustBeLvalue()
+	    && nodep->lhsp()->castNodeVarRef()
+	    && !nodep->lhsp()->castNodeVarRef()->lvalue()) {
+	    nodep->v3fatalSrc("Assignment LHS is not an lvalue");
+	}
+    }
    virtual void visit(AstNode* nodep) {
 	processAndIterate(nodep);
    }
@@ -23,6 +23,8 @@
 //	for all AstCoverDecl, move the declaration into a _configure_coverage AstCFunc.
 //	For each variable that needs reset, add a AstCReset node.
 //
+//	For primary inputs, add _eval_debug_assertions.
+//
 //	This transformation honors outputSplitCFuncs.
 //*************************************************************************
 #include "config_build.h"
@@ -75,7 +77,8 @@ public:
 	m_numStmts += 1;
    }

-    V3CCtorsVisitor(AstNodeModule* nodep, string basename, string argsp="", string callargsp="") {
+    V3CCtorsVisitor(AstNodeModule* nodep, string basename, string argsp="", string callargsp="",
+		    const string& stmt="") {
 	m_basename = basename;
 	m_argsp = argsp;
 	m_callargsp = callargsp;
@@ -87,31 +90,81 @@ public:
 	m_tlFuncp->isStatic(false);
 	m_tlFuncp->slow(true);
 	m_tlFuncp->argTypes(m_argsp);
+	if (stmt != "") {
+	    m_tlFuncp->addStmtsp(new AstCStmt(nodep->fileline(), stmt));
+	}
 	m_funcp = m_tlFuncp;
 	m_modp->addStmtp(m_tlFuncp);
    }
+    ~V3CCtorsVisitor() {}
+private:
+    VL_UNCOPYABLE(V3CCtorsVisitor);
 };

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

-void V3CCtors::cctorsAll() {
-    UINFO(2,__FUNCTION__<<": "<<endl);
-    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castNodeModule()) {
-	// Process each module in turn
-	V3CCtorsVisitor var_reset (modp, "_ctor_var_reset");
-	V3CCtorsVisitor configure_coverage (modp, "_configure_coverage",
-						   EmitCBaseVisitor::symClassVar()+ ", bool first", "vlSymsp, first");
-
-	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;
+void V3CCtors::evalAsserts() {
+    AstNodeModule* modp = v3Global.rootp()->modulesp();  // Top module
+    AstCFunc* funcp = new AstCFunc(modp->fileline(), "_eval_debug_assertions", NULL, "void");
+    funcp->declPrivate(true);
+    funcp->isStatic(false);
+    funcp->slow(false);
+    funcp->ifdef("VL_DEBUG");
+    modp->addStmtp(funcp);
+    for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
+	if (AstVar* varp = np->castVar()) {
+	    if (varp->isPrimaryIn() && !varp->isSc()) {
+		if (AstBasicDType* basicp = varp->dtypeSkipRefp()->castBasicDType()) {
+		    int storedWidth = basicp->widthAlignBytes() * 8;
+		    int lastWordWidth = varp->width() % storedWidth;
+		    if (lastWordWidth != 0) {
+			// if (signal & CONST(upper_non_clean_mask)) { fail; }
+			AstNode* newp = new AstVarRef(varp->fileline(), varp, false);
+			if (varp->isWide()) {
+			    newp = new AstWordSel(varp->fileline(), newp,
+						  new AstConst(varp->fileline(), varp->widthWords()-1));
+			}
+			uint64_t value = VL_MASK_Q(storedWidth) & ~VL_MASK_Q(lastWordWidth);
+			V3Number num (varp->fileline(), storedWidth, value);
+			newp = new AstAnd(varp->fileline(), newp,
+					  new AstConst(varp->fileline(), num));
+			AstNodeIf* ifp = new AstIf(varp->fileline(), newp,
+						   new AstCStmt(varp->fileline(), "Verilated::overWidthError(\""+varp->prettyName()+"\");"));
+			ifp->branchPred(AstBranchPred::BP_UNLIKELY);
+			newp = ifp;
+			funcp->addStmtsp(newp);
+		    }
+		}
 	    }
 	}
    }
 }
+
+void V3CCtors::cctorsAll() {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    evalAsserts();
+    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=modp->nextp()->castNodeModule()) {
+        // Process each module in turn
+        {
+            V3CCtorsVisitor var_reset (modp, "_ctor_var_reset");
+            for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
+                if (AstVar* varp = np->castVar()) {
+                    var_reset.add(new AstCReset(varp->fileline(), new AstVarRef(varp->fileline(), varp, true)));
+                }
+            }
+        }
+        if (v3Global.opt.coverage()) {
+            V3CCtorsVisitor configure_coverage
+                (modp, "_configure_coverage", EmitCBaseVisitor::symClassVar()+ ", bool first", "vlSymsp, first",
+                 "if (0 && vlSymsp && first) {} // Prevent unused\n");
+            for (AstNode* np = modp->stmtsp(); np; np = np->nextp()) {
+                if (AstCoverDecl* coverp = np->castCoverDecl()) {
+                    AstNode* backp = coverp->backp();
+                    coverp->unlinkFrBack();
+                    configure_coverage.add(coverp);
+                    np = backp;
+                }
+            }
+        }
+    }
+}
@@ -30,6 +30,8 @@
 class V3CCtors {
 public:
    static void cctorsAll();
+private:
+    static void evalAsserts();
 };


@@ -174,7 +174,7 @@ private:
 	    for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 		//if (debug()>=9) icondp->dumpTree(cout," caseitem: ");
 		AstConst* iconstp = icondp->castConst();
-		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this\n");
+		if (!iconstp) nodep->v3fatalSrc("above 'can't parse' should have caught this");
 		if (neverItem(nodep, iconstp)) {
 		    // X in casez can't ever be executed
 		} else {
@@ -423,7 +423,7 @@ private:
 	// Handle any assertions
 	replaceCaseParallel(nodep, false);
 	// Replace the CASE... with IF...
-	if (debug()>=9) grouprootp->dumpTree(cout,"     _new: ");
+	if (debug()>=9 && grouprootp) grouprootp->dumpTree(cout,"     _new: ");
 	if (grouprootp) nodep->replaceWith(grouprootp);
 	else nodep->unlinkFrBack();
 	nodep->deleteTree(); VL_DANGLING(nodep);
@@ -489,7 +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);
+    V3Global::dumpCheckGlobalTree("case", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 void V3Case::caseLint(AstNodeCase* nodep) {
    UINFO(4,__FUNCTION__<<": "<<endl);
@@ -188,5 +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);
+    V3Global::dumpCheckGlobalTree("cast", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -496,7 +496,7 @@ private:
 	}

 	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc_edges.txt";
-	const VL_UNIQUE_PTR<ofstream> ofp (V3File::new_ofstream(filename));
+	const vl_unique_ptr<ofstream> ofp (V3File::new_ofstream(filename));
 	if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
 	*ofp<<"Edge Report for "<<v3Global.opt.prefix()<<endl;

@@ -591,14 +591,14 @@ private:
 	    vertexp->dstDomainp(senoutp);
 	    if (debug()>=9) {
 		UINFO(9,spaces(level)+"     Tracedst "<<vertexp);
-		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+		if (senoutp) { V3EmitV::verilogForTree(senoutp, cout); cout<<endl; }
 	    }
 	} else {
 	    vertexp->srcDomainSet(true);  // Note it's set - domainp may be null, so can't use that
 	    vertexp->srcDomainp(senoutp);
 	    if (debug()>=9) {
 		UINFO(9,spaces(level)+"     Tracesrc "<<vertexp);
-		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+		if (senoutp) { V3EmitV::verilogForTree(senoutp, cout); cout<<endl; }
 	    }
 	}
    }
@@ -629,9 +629,9 @@ private:
    }
    virtual void visit(AstNodeVarRef* nodep) {
 	if (m_scopep) {
-	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block\n");
+	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block");
 	    AstVarScope* varscp = nodep->varScopep();
-	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
 	    CdcVarVertex* varvertexp = makeVarVertex(varscp);
 	    UINFO(5," VARREF to "<<varscp<<endl);
 	    // We use weight of one for normal edges,
@@ -111,8 +111,8 @@ private:
    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 
+    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
@@ -253,7 +253,7 @@ private:
 	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");
+	if (!scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?");
 	m_statep->m_scopetopp = scopep;

 	// Create a wrapper change detection function that calls each change detection function
@@ -278,7 +278,7 @@ private:
 	}
    }
    virtual void visit(AstNodeMath* nodep) {
-	// Short-circuit 
+	// Short-circuit
    }
    //--------------------
    // Default: Just iterate
@@ -302,5 +302,5 @@ void V3Changed::changedAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    ChangedState state;
    ChangedVisitor visitor (nodep, &state);
-    V3Global::dumpCheckGlobalTree("changed.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("changed", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -297,5 +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);
+    V3Global::dumpCheckGlobalTree("clean", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -559,7 +559,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		if (!vVxp->inBeginp()) {
 		    // At this point, any variable not linked is an error
 		    // (It should have at least landed under the Head node)
-		    vVxp->nodep()->v3fatalSrc("Variable became stranded in clk gate detection\n");
+		    vVxp->nodep()->v3fatalSrc("Variable became stranded in clk gate detection");
 		}
 		if (!lastVxp || vVxp->sortCmp(lastVxp)) {
 		    // Different sources for this new node
@@ -611,7 +611,8 @@ class GaterVisitor : public GaterBaseVisitor {
 		    // Edges from IFs represent a real IF branch in the equation tree
 		    //UINFO(9,"  ifver "<<(void*)(edgep)<<" cc"<<edgep->dotColor()<<endl);
 		    eqnp = cVxp->nodep()->condp()->cloneTree(true);
-		    if (eqnp && cedgep->ifelseFalse()) {
+		    if (!eqnp) cVxp->nodep()->v3fatalSrc("null condition");
+		    if (cedgep->ifelseFalse()) {
 			eqnp = new AstNot(eqnp->fileline(),eqnp);
 		    }
 		    // We need to AND this term onto whatever was found below it
@@ -620,7 +621,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		}
 		// Top level we could choose to make multiple gaters, or ORs under the gater
 		// Right now we'll put OR lower down and let other optimizations deal
-		if (nodep) nodep = new AstOr(eqnp->fileline(),nodep,eqnp);
+		if (nodep) nodep = new AstOr(nodep->fileline(), nodep, eqnp);
 		else nodep = eqnp;
 		//if (debug()>=9) nodep->dumpTree(cout,"      followExpr: ");
 	    }
@@ -878,7 +879,7 @@ class GaterVisitor : public GaterBaseVisitor {

 public:
    // CONSTUCTORS
-    explicit GaterVisitor(AstNode* nodep) {
+    explicit GaterVisitor(AstNetlist* nodep) {
 	// AstAlways visitor does the real work, so most zeroing needs to be in clear()
 	clear();
 	nodep->accept(*this);
@@ -914,5 +915,5 @@ void V3ClkGater::clkGaterAll(AstNetlist* nodep) {
    // While the gater does well at some modules, it seems to slow down many others
    UINFO(5,"ClkGater is disabled due to performance issues\n");
    //GaterVisitor visitor (nodep);
-    V3Global::dumpCheckGlobalTree("clkgater.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("clkgater", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -192,7 +192,7 @@ private:
 	UINFO(4," TOPSCOPE   "<<nodep<<endl);
 	m_topScopep=nodep;
 	m_scopep = nodep->scopep();
-	if (!m_scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
+	if (!m_scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?");
 	//VV*****  We reset all user1p()
 	AstNode::user1ClearTree();
 	// Make top functions
@@ -413,5 +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);
+    V3Global::dumpCheckGlobalTree("clock", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -239,7 +239,7 @@ private:
 	    V3Hash hashval = it->first;
 	    AstNode* node1p = it->second;
 	    if (!node1p->castCFunc()) continue;
-	    if (hashval.isIllegal()) node1p->v3fatalSrc("Illegal (unhashed) nodes\n");
+	    if (hashval.isIllegal()) node1p->v3fatalSrc("Illegal (unhashed) nodes");
 	    for (V3Hashed::iterator eqit = it; eqit != m_hashed.end(); ++eqit) {
 		AstNode* node2p = eqit->second;
 		if (!(eqit->first == hashval)) break;
@@ -474,5 +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);
+    V3Global::dumpCheckGlobalTree("combine", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -104,7 +104,7 @@ class V3ConfigIgnores {
 public:
    inline static V3ConfigIgnores& singleton() { return s_singleton; }

-    void addIgnore(V3ErrorCode code, string wildname, int lineno, bool on) {
+    void addIgnore(V3ErrorCode code, const string& wildname, int lineno, bool on) {
 	// Insert
 	IgnLines* linesp = findWilds(wildname);
 	UINFO(9,"config addIgnore "<<wildname<<":"<<lineno<<", "<<code<<", "<<on<<endl);
@@ -305,8 +305,7 @@ private:
 	return (nodep->lsbp()->castConst()
 		&& nodep->widthp()->castConst()
 		&& nodep->lsbConst()==0
-		&& (int)nodep->widthConst()==nodep->fromp()->width()
-		&& 1);
+		&& (int)nodep->widthConst()==nodep->fromp()->width());
    }
    bool operandSelExtend(AstSel* nodep) {
 	// A pattern created by []'s after offsets have been removed
@@ -342,12 +341,39 @@ private:
 	replaceWChild(nodep, bip); VL_DANGLING(nodep);
 	return true;
    }
+    bool operandSelShiftLower(AstSel* nodep) {
+	// AND({a}, SHIFTR({b}, {c})) is often shorthand in C for Verilog {b}[{c} :+ {a}]
+	// becomes thought other optimizations
+	// SEL(SHIFTR({a},{b}),{lsb},{width}) -> SEL({a},{lsb+b},{width})
+	AstShiftR* shiftp = nodep->fromp()->castShiftR();
+	if (!(m_doV
+	      && shiftp
+	      && shiftp->rhsp()->castConst()
+	      && nodep->lsbp()->castConst()
+	      && nodep->widthp()->castConst()
+		)) return false;
+	AstNode* ap = shiftp->lhsp();
+	AstConst* bp = shiftp->rhsp()->castConst();
+	AstConst* lp = nodep->lsbp()->castConst();
+	if (bp->isWide() || bp->num().isFourState() || bp->num().isNegative()
+	    || lp->isWide() || lp->num().isFourState() || lp->num().isNegative()) return false;
+	int newLsb = lp->toSInt() + bp->toSInt();
+	if (newLsb + nodep->widthConst() > ap->width()) return false;
+	//
+	UINFO(9, "SEL(SHIFTR(a,b),l,w) -> SEL(a,l+b,w)\n");
+	if (debug()>=9) nodep->dumpTree(cout,"SEL(SH)-in:");
+	AstSel* newp = new AstSel(nodep->fileline(), ap->unlinkFrBack(), newLsb, nodep->widthConst());
+	newp->dtypeFrom(nodep);
+	if (debug()>=9) newp->dumpTree(cout,"SEL(SH)-ou:");
+	nodep->replaceWith(newp); VL_DANGLING(nodep);
+	return true;
+    }

-    bool operandBiExtendConst(AstNodeBiop* nodep) {
+    bool operandBiExtendConstShrink(AstNodeBiop* nodep) {
 	// Loop unrolling favors standalone compares
 	// EQ(const{width32}, EXTEND(xx{width3})) -> EQ(const{3}, xx{3})
-	// Beware that the constant must have zero bits (+ 1 if signed) or compare
-	// would be incorrect
+	// The constant must have zero bits (+ 1 if signed) or compare
+	// would be incorrect. See also operandBiExtendConst
 	AstExtend* extendp = nodep->rhsp()->castExtend();
 	if (!extendp) return false;
 	AstNode* smallerp = extendp->lhsp();
@@ -369,6 +395,19 @@ private:
 	if (debug()>=9) nodep->dumpTree(cout,"BI(EXTEND)-ou:");
 	return true;
    }
+    bool operandBiExtendConstOver(AstNodeBiop* nodep) {
+	// EQ(const{width32}, EXTEND(xx{width3})) -> constant
+	// When the constant has non-zero bits above the extend it's a constant.
+	// Avoids compiler warning
+	AstExtend* extendp = nodep->rhsp()->castExtend();
+	if (!extendp) return false;
+	AstNode* smallerp = extendp->lhsp();
+	int subsize = smallerp->width();
+	AstConst* constp = nodep->lhsp()->castConst();
+	if (!constp) return false;
+	if (constp->num().isBitsZero(constp->width()-1, subsize)) return false;
+	return true;
+    }

    AstNode* afterComment(AstNode* nodep) {
 	// Ignore comments, such as to determine if a AstIf is empty.
@@ -446,11 +485,7 @@ private:
 	if (!ifp   || ifp->nextp()) return false;  // Must be SINGLE statement
 	if (!elsep || elsep->nextp()) return false;
 	if (ifp->type() != elsep->type()) return false;  // Can't mix an assigndly and an assign
-	AstVarRef* ifvarp = ifp->lhsp()->castVarRef();
-	AstVarRef* elsevarp = elsep->lhsp()->castVarRef();
-	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->lhsp()->sameGateTree(elsep->lhsp())) return false;
 	if (!ifp->rhsp()->gateTree()) return false;
 	if (!elsep->rhsp()->gateTree()) return false;
 	return true;
@@ -555,7 +590,7 @@ private:
 	// Replace oldp node with a constant set to specified value
 	UASSERT (oldp, "Null old\n");
 	if (oldp->castConst() && !oldp->castConst()->num().isFourState()) {
-	    oldp->v3fatalSrc("Already constant??\n");
+	    oldp->v3fatalSrc("Already constant??");
 	}
 	AstNode* newp = new AstConst(oldp->fileline(), num);
 	newp->dtypeFrom(oldp);
@@ -1367,21 +1402,67 @@ private:
 	}
 	nodep->deleteTree(); VL_DANGLING(nodep);
    }
-
-    void replaceSelReplicate(AstSel* nodep) {
-	// SEL(REPLICATE(a,b),1,bit) => SEL(a,1,bit)
+    bool operandSelReplicate(AstSel* nodep) {
+	// SEL(REPLICATE(from,rep),lsb,width) => SEL(from,0,width) as long as SEL's width <= b's width
 	AstReplicate* repp = nodep->fromp()->castReplicate();
-	AstNode* fromp = repp->lhsp()->unlinkFrBack();
-	AstConst* lsbp = nodep->lsbp()->castConst();
-	AstNode* widthp = nodep->widthp()->unlinkFrBack();
+	AstNode* fromp = repp->lhsp();
+	AstConst* lsbp = nodep->lsbp()->castConst(); if (!lsbp) return false;
+	AstNode* widthp = nodep->widthp(); if (!widthp->castConst()) return false;
+	if (!fromp->width()) nodep->v3fatalSrc("Not widthed");
+	if ((lsbp->toUInt() / fromp->width())
+	    != ((lsbp->toUInt()+nodep->width()-1) / fromp->width())) return false;
+	//
+	fromp->unlinkFrBack();
+	widthp->unlinkFrBack();
 	AstSel* newp = new AstSel(nodep->fileline(),
 				  fromp,
 				  new AstConst(lsbp->fileline(), lsbp->toUInt() % fromp->width()),
 				  widthp);
 	newp->dtypeFrom(nodep);
 	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
+	return true;
+    }
+    bool operandRepRep(AstReplicate* nodep) {
+	// REPLICATE(REPLICATE2(from2,cnt2),cnt1) => REPLICATE(from2,(cnt1+cnt2))
+	AstReplicate* rep2p = nodep->lhsp()->castReplicate();
+	AstNode* from2p = rep2p->lhsp();
+	AstConst* cnt1p = nodep->rhsp()->castConst(); if (!cnt1p) return false;
+	AstConst* cnt2p = rep2p->rhsp()->castConst(); if (!cnt2p) return false;
+	//
+	from2p->unlinkFrBack();
+	cnt1p->unlinkFrBack();
+	cnt2p->unlinkFrBack();
+	AstReplicate* newp = new AstReplicate(nodep->fileline(),
+					      from2p, cnt1p->toUInt()*cnt2p->toUInt());
+	newp->dtypeFrom(nodep);
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
+	return true;
+    }
+    bool operandConcatSame(AstConcat* nodep) {
+	// CONCAT(fromp,fromp) -> REPLICATE(fromp,1+1)
+	// CONCAT(REP(fromp,cnt1),fromp) -> REPLICATE(fromp,cnt1+1)
+	// CONCAT(fromp,REP(fromp,cnt1)) -> REPLICATE(fromp,1+cnt1)
+	// CONCAT(REP(fromp,cnt1),REP(fromp,cnt2)) -> REPLICATE(fromp,cnt1+cnt2)
+	AstNode* from1p = nodep->lhsp(); uint32_t cnt1 = 1;
+	AstNode* from2p = nodep->rhsp(); uint32_t cnt2 = 1;
+	if (from1p->castReplicate()) {
+	    AstConst* cnt1p = from1p->castReplicate()->rhsp()->castConst(); if (!cnt1p) return false;
+	    from1p = from1p->castReplicate()->lhsp();
+	    cnt1 = cnt1p->toUInt();
+	}
+	if (from2p->castReplicate()) {
+	    AstConst* cnt2p = from2p->castReplicate()->rhsp()->castConst(); if (!cnt2p) return false;
+	    from2p = from2p->castReplicate()->lhsp();
+	    cnt2 = cnt2p->toUInt();
+	}
+	if (!operandsSame(from1p,from2p)) return false;
+	//
+	from1p->unlinkFrBack();
+	AstReplicate* newp = new AstReplicate(nodep->fileline(), from1p, cnt1+cnt2);
+	newp->dtypeFrom(nodep);
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
+	return true;
    }
-
    void replaceSelIntoBiop(AstSel* nodep) {
 	// SEL(BUFIF1(a,b),1,bit) => BUFIF1(SEL(a,1,bit),SEL(b,1,bit))
 	AstNodeBiop* fromp = nodep->fromp()->unlinkFrBack()->castNodeBiop();
@@ -1491,6 +1572,14 @@ private:
 			did=true;
 		    }
 		}
+		else if (m_params && valuep->castInitArray() && nodep->backp()->castPin()) {
+		    // Allow parameters to pass arrays
+		    // Earlier recursion of InitArray made sure each array value is constant
+		    // This exception is fairly fragile, i.e. doesn't support arrays of arrays or other stuff
+		    AstNode* newp = valuep->cloneTree(false);
+		    nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
+		    did = true;
+		}
 	    }
 	}
 	if (!did && m_required) {
@@ -1600,9 +1689,12 @@ private:
 		    // But might be same name with different scopes
 		    if (litemp->varrefp()->varScopep() < ritemp->varrefp()->varScopep()) return true;
 		    if (litemp->varrefp()->varScopep() > ritemp->varrefp()->varScopep()) return false;
+		    // Or rarely, different data types
+		    if (litemp->varrefp()->dtypep() < ritemp->varrefp()->dtypep()) return true;
+		    if (litemp->varrefp()->dtypep() > ritemp->varrefp()->dtypep()) return false;
 		}
 		// Sort by edge, AFTER variable, as we want multiple edges for same var adjacent
-		// note the SenTree optimizer requires this order (more general firsst, less general last)
+		// note the SenTree optimizer requires this order (more general first, less general last)
 		if (litemp->edgeType() < ritemp->edgeType()) return true;
 		if (litemp->edgeType() > ritemp->edgeType()) return false;
 	    }
@@ -1813,7 +1905,7 @@ private:
 	    }
 	    else if (0	// Disabled, as vpm assertions are faster without due to short-circuiting
 		     && operandIfIf(nodep)) {
-		UINFO(0,"IF({a}) IF({b}) => IF({a} && {b})"<<endl);
+		UINFO(9,"IF({a}) IF({b}) => IF({a} && {b})"<<endl);
 		AstNodeIf* lowerIfp = nodep->ifsp()->castNodeIf();
 		AstNode* condp = nodep->condp()->unlinkFrBack();
 		AstNode* lowerIfsp = lowerIfp->ifsp()->unlinkFrBackWithNext();
@@ -1829,6 +1921,51 @@ private:
 	}
    }

+    virtual void visit(AstDisplay* nodep) {
+        // DISPLAY(SFORMAT(text1)),DISPLAY(SFORMAT(text2)) -> DISPLAY(SFORMAT(text1+text2))
+        nodep->iterateChildren(*this);
+        if (stmtDisplayDisplay(nodep)) return;
+    }
+    bool stmtDisplayDisplay(AstDisplay* nodep) {
+        // DISPLAY(SFORMAT(text1)),DISPLAY(SFORMAT(text2)) -> DISPLAY(SFORMAT(text1+text2))
+        if (!m_modp) return false;  // Don't optimize under single statement
+        if (!nodep->backp()) return false;
+        AstDisplay* prevp = nodep->backp()->castDisplay();
+        if (!prevp) return false;
+        if (!((prevp->displayType() == nodep->displayType())
+              || (prevp->displayType() == AstDisplayType::DT_WRITE
+                  && nodep->displayType() == AstDisplayType::DT_DISPLAY)
+              || (prevp->displayType() == AstDisplayType::DT_DISPLAY
+                  && nodep->displayType() == AstDisplayType::DT_WRITE)))
+            return false;
+        if ((prevp->filep() && !nodep->filep())
+            || (!prevp->filep() && nodep->filep())
+            || !prevp->filep()->sameTree(nodep->filep())) return false;
+        if (!prevp->fmtp() || prevp->fmtp()->nextp()
+            || !nodep->fmtp() || nodep->fmtp()->nextp()) return false;
+        // We don't merge scopeNames as might be different scopes (late in process)
+        // We don't merge arguments as might need to later print warnings with right line numbers
+        AstSFormatF* pformatp = prevp->fmtp();
+        if (!pformatp || pformatp->exprsp() || pformatp->scopeNamep()) return false;
+        AstSFormatF* nformatp = nodep->fmtp();
+        if (!nformatp || nformatp->exprsp() || nformatp->scopeNamep()) return false;
+        //
+        UINFO(9,"DISPLAY(SF({a})) DISPLAY(SF({b})) -> DISPLAY(SF({a}+{b}))"<<endl);
+        // Convert DT_DISPLAY to DT_WRITE as may allow later optimizations
+        if (prevp->displayType() == AstDisplayType::DT_DISPLAY) {
+            prevp->displayType(AstDisplayType::DT_WRITE);
+            pformatp->text(pformatp->text()+"\n");
+        }
+        // We can't replace prev() as the edit tracking iterators will get confused.
+        // So instead we edit the prev note itself.
+        if (prevp->addNewline()) pformatp->text(pformatp->text()+"\n");
+        pformatp->text(pformatp->text()+nformatp->text());
+        if (!prevp->addNewline() && nodep->addNewline()) {
+            pformatp->text(pformatp->text()+"\n");
+        }
+        nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+        return true;
+    }
    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.
@@ -1867,7 +2004,7 @@ private:
 				UINFO(9,"     DispConst: "<<fmt<<" -> "<<out<<"  for "<<argp<<endl);
 				// fmt = out w/ replace % with %% as it must be literal.
 				fmt = VString::quotePercent(out);
-				argp->unlinkFrBack()->deleteTree();
+				argp->unlinkFrBack()->deleteTree(); VL_DANGLING(argp);
 			    }
 			    argp=nextp;
 			}
@@ -2067,7 +2204,7 @@ private:
    // This visit function here must allow for short-circuiting.
    TREEOPS("AstCond {$lhsp.isZero}",		"replaceWIteratedThs(nodep)");
    TREEOPS("AstCond {$lhsp.isNeqZero}",	"replaceWIteratedRhs(nodep)");
-    TREEOP ("AstCond{$condp->castNot(),       $expr1p, $expr2p}", "AstCond{$condp->op1p(), $expr2p, $expr1p}");
+    TREEOP ("AstCond{$condp.castNot,       $expr1p, $expr2p}", "AstCond{$condp->op1p(), $expr2p, $expr1p}");
    TREEOP ("AstNodeCond{$condp.width1, $expr1p.width1,   $expr1p.isAllOnes, $expr2p}", "AstLogOr {$condp, $expr2p}");  // a?1:b == a||b
    TREEOP ("AstNodeCond{$condp.width1, $expr1p.width1,   $expr1p,    $expr2p.isZero}", "AstLogAnd{$condp, $expr1p}");  // a?b:0 == a&&b
    TREEOP ("AstNodeCond{$condp.width1, $expr1p.width1,   $expr1p, $expr2p.isAllOnes}", "AstLogOr {AstNot{$condp}, $expr1p}");  // a?b:1 == ~a||b
@@ -2136,12 +2273,18 @@ private:
    TREEOP ("AstShiftR{operandShiftShift(nodep)}",	"replaceShiftShift(nodep)");
    TREEOP ("AstWordSel{operandWordOOB(nodep)}",	"replaceZero(nodep)");
    // Compress out EXTENDs to appease loop unroller
-    TREEOPV("AstEq    {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
-    TREEOPV("AstNeq   {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
-    TREEOPV("AstGt    {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
-    TREEOPV("AstGte   {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
-    TREEOPV("AstLt    {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
-    TREEOPV("AstLte   {$rhsp.castExtend,operandBiExtendConst(nodep)}",	"DONE");
+    TREEOPV("AstEq    {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstNeq   {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstGt    {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstGte   {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstLt    {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstLte   {$rhsp.castExtend,operandBiExtendConstShrink(nodep)}",	"DONE");
+    TREEOPV("AstEq    {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceZero(nodep)");
+    TREEOPV("AstNeq   {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceNum(nodep,1)");
+    TREEOPV("AstGt    {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceNum(nodep,1)");
+    TREEOPV("AstGte   {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceNum(nodep,1)");
+    TREEOPV("AstLt    {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceZero(nodep)");
+    TREEOPV("AstLte   {$rhsp.castExtend,operandBiExtendConstOver(nodep)}",	"replaceZero(nodep)");
    // Identical operands on both sides
    // AstLogAnd/AstLogOr already converted to AstAnd/AstOr for these rules
    // AstAdd->ShiftL(#,1) but uncommon
@@ -2201,12 +2344,12 @@ private:
    TREEOPV("AstRedAnd{$lhsp, $lhsp.width1}",	"replaceWLhs(nodep)");
    TREEOPV("AstRedOr {$lhsp, $lhsp.width1}",	"replaceWLhs(nodep)");
    TREEOPV("AstRedXor{$lhsp, $lhsp.width1}",	"replaceWLhs(nodep)");
-    TREEOPV("AstRedAnd{$lhsp->castConcat()}",	"AstAnd{AstRedAnd{$lhsp->castConcat()->lhsp()}, AstRedAnd{$lhsp->castConcat()->rhsp()}}");    // &{a,b} => {&a}&{&b}
-    TREEOPV("AstRedOr {$lhsp->castConcat()}",	"AstOr {AstRedOr {$lhsp->castConcat()->lhsp()}, AstRedOr {$lhsp->castConcat()->rhsp()}}");    // |{a,b} => {|a}|{|b}
-    TREEOPV("AstRedXor{$lhsp->castConcat()}",	"AstXor{AstRedXor{$lhsp->castConcat()->lhsp()}, AstRedXor{$lhsp->castConcat()->rhsp()}}");    // ^{a,b} => {^a}^{^b}
-    TREEOPV("AstRedAnd{$lhsp->castExtend(), $lhsp->width()>$lhsp->castExtend()->lhsp()->width()}",	"replaceZero(nodep)");	// &{0,...} => 0    Prevents compiler limited range error
-    TREEOPV("AstRedOr {$lhsp->castExtend()}",	"AstRedOr {$lhsp->castExtend()->lhsp()}");
-    TREEOPV("AstRedXor{$lhsp->castExtend()}",	"AstRedXor{$lhsp->castExtend()->lhsp()}");
+    TREEOPV("AstRedAnd{$lhsp.castConcat}",	"AstAnd{AstRedAnd{$lhsp->castConcat()->lhsp()}, AstRedAnd{$lhsp->castConcat()->rhsp()}}");    // &{a,b} => {&a}&{&b}
+    TREEOPV("AstRedOr {$lhsp.castConcat}",	"AstOr {AstRedOr {$lhsp->castConcat()->lhsp()}, AstRedOr {$lhsp->castConcat()->rhsp()}}");    // |{a,b} => {|a}|{|b}
+    TREEOPV("AstRedXor{$lhsp.castConcat}",	"AstXor{AstRedXor{$lhsp->castConcat()->lhsp()}, AstRedXor{$lhsp->castConcat()->rhsp()}}");    // ^{a,b} => {^a}^{^b}
+    TREEOPV("AstRedAnd{$lhsp.castExtend, $lhsp->width() > $lhsp->castExtend()->lhsp()->width()}",	"replaceZero(nodep)");	// &{0,...} => 0    Prevents compiler limited range error
+    TREEOPV("AstRedOr {$lhsp.castExtend}",	"AstRedOr {$lhsp->castExtend()->lhsp()}");
+    TREEOPV("AstRedXor{$lhsp.castExtend}",	"AstRedXor{$lhsp->castExtend()->lhsp()}");
    TREEOPV("AstOneHot{$lhsp.width1}",		"replaceWLhs(nodep)");
    TREEOPV("AstOneHot0{$lhsp.width1}",		"replaceNum(nodep,1)");
    // Binary AND/OR is faster than logical and/or (usually)
@@ -2218,7 +2361,7 @@ private:
    TREEOPV("AstConcat{operandConcatMove(nodep)}",	"moveConcat(nodep)");
    TREEOPV("AstConcat{$lhsp.isZero, $rhsp}",		"replaceExtend(nodep, nodep->rhsp())");
    // CONCAT(a[1],a[0]) -> a[1:0]
-    TREEOPV("AstConcat{$lhsp->castSel(), $rhsp->castSel(), ifAdjacentSel($lhsp->castSel(),,$rhsp->castSel())}",  "replaceConcatSel(nodep)");
+    TREEOPV("AstConcat{$lhsp.castSel, $rhsp.castSel, ifAdjacentSel($lhsp->castSel(),,$rhsp->castSel())}",  "replaceConcatSel(nodep)");
    TREEOPV("AstConcat{ifConcatMergeableBiop($lhsp), concatMergeable($lhsp,,$rhsp)}", "replaceConcatMerge(nodep)");
    // Common two-level operations that can be simplified
    TREEOP ("AstAnd {$lhsp.castOr, $rhsp.castOr, operandAndOrSame(nodep)}",	"replaceAndOr(nodep)");
@@ -2233,6 +2376,8 @@ private:
    TREEOPV("AstExtendS{$lhsp.castExtendS}",		"replaceExtend(nodep, nodep->lhsp()->castExtendS()->lhsp())");
    TREEOPV("AstReplicate{$lhsp, $rhsp.isOne, $lhsp->width()==nodep->width()}",	"replaceWLhs(nodep)");  // {1{lhs}}->lhs
    TREEOPV("AstReplicateN{$lhsp, $rhsp.isOne, $lhsp->width()==nodep->width()}", "replaceWLhs(nodep)");  // {1{lhs}}->lhs
+    TREEOPV("AstReplicate{$lhsp.castReplicate, operandRepRep(nodep)}", "DONE");  // {2{3{lhs}}}->{6{lhs}}
+    TREEOPV("AstConcat{operandConcatSame(nodep)}", "DONE");  // {a,a}->{2{a}}, {a,2{a}}->{3{a}, etc
    // Next rule because AUTOINST puts the width of bits in
    // to pins, even when the widths are exactly the same across the hierarchy.
    TREEOPV("AstSel{operandSelExtend(nodep)}",	"DONE");
@@ -2244,9 +2389,10 @@ private:
    TREEOPV("AstSel{$fromp.castSub, operandSelBiLower(nodep)}",	"DONE");
    TREEOPV("AstSel{$fromp.castXnor,operandSelBiLower(nodep)}",	"DONE");
    TREEOPV("AstSel{$fromp.castXor, operandSelBiLower(nodep)}",	"DONE");
+    TREEOPV("AstSel{$fromp.castShiftR, operandSelShiftLower(nodep)}",	"DONE");
    TREEOPC("AstSel{$fromp.castConst, $lsbp.castConst, $widthp.castConst, }",	"replaceConst(nodep)");
    TREEOPV("AstSel{$fromp.castConcat, $lsbp.castConst, $widthp.castConst, }",	"replaceSelConcat(nodep)");
-    TREEOPV("AstSel{$fromp.castReplicate, $lsbp.castConst, $widthp.isOne, }",	"replaceSelReplicate(nodep)");
+    TREEOPV("AstSel{$fromp.castReplicate, $lsbp.castConst, $widthp.castConst, operandSelReplicate(nodep) }",	"DONE");
    // V3Tristate requires selects below BufIf1.
    // Also do additional operators that are bit-independent, but only definite
    // win if bit select is a constant (otherwise we may need to compute bit index several times)
@@ -2400,14 +2546,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);
+    V3Global::dumpCheckGlobalTree("const", 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);
+    V3Global::dumpCheckGlobalTree("const_cpp", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

 AstNode* V3Const::constifyEdit(AstNode* nodep) {
@@ -2423,7 +2569,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);
+    V3Global::dumpCheckGlobalTree("const", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

 void V3Const::constifyAll(AstNetlist* nodep) {
@@ -2431,7 +2577,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);
+    V3Global::dumpCheckGlobalTree("const", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

 AstNode* V3Const::constifyExpensiveEdit(AstNode* nodep) {
@@ -168,6 +168,7 @@ private:
 		// Add signal to hold the old value
 		string newvarname = (string)"__Vtogcov__"+nodep->shortName();
 		AstVar* chgVarp = new AstVar (nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
+		chgVarp->fileline()->modifyWarnOff(V3ErrorCode::UNUSED, true);
 		m_modp->addStmtp(chgVarp);

 		// Create bucket for each dimension * bit.
@@ -395,5 +396,5 @@ public:
 void V3Coverage::coverage(AstNetlist* rootp) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    CoverageVisitor visitor (rootp);
-    V3Global::dumpCheckGlobalTree("coverage.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("coverage", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -29,7 +29,7 @@

 class V3Coverage {
 public:
-    // CREATORS
+    // CONSTRUCTORS
    static void coverage(AstNetlist* rootp);
 };

@@ -135,5 +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);
+    V3Global::dumpCheckGlobalTree("coveragejoin", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -29,7 +29,7 @@

 class V3CoverageJoin {
 public:
-    // CREATORS
+    // CONSTRUCTORS
    static void coverageJoin(AstNetlist* rootp);
 };

@@ -137,8 +137,10 @@ private:
    // VISITORS
    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
-	nodep->iterateChildren(*this);
-	checkAll(nodep);
+	if (!nodep->dead()) {
+	    nodep->iterateChildren(*this);
+	    checkAll(nodep);
+	}
 	m_modp = NULL;
    }
    virtual void visit(AstCFunc* nodep) {
@@ -280,12 +282,14 @@ private:
 	    AstNodeModule* nextmodp;
 	    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=nextmodp) {
 		nextmodp = modp->nextp()->castNodeModule();
-		if (modp->level()>2	&& modp->user1()==0 && !modp->internal()) {
+		if (modp->dead() || (modp->level()>2 && modp->user1()==0 && !modp->internal())) {
 		    // > 2 because L1 is the wrapper, L2 is the top user module
 		    UINFO(4,"  Dead module "<<modp<<endl);
 		    // 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);
+		    if (!modp->dead()) {  // If was dead didn't increment user1's
+			DeadModVisitor visitor(modp);
+		    }
 		    modp->unlinkFrBack()->deleteTree(); VL_DANGLING(modp);
 		    retry = true;
 		}
@@ -338,8 +342,8 @@ private:
 	    if (vscp->user1() == 0) {
 		UINFO(4,"  Dead "<<vscp<<endl);
 		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;
+		for (AssignMap::iterator itr = eqrange.first; itr != eqrange.second; ++itr) {
+		    AstNodeAssign* assp = itr->second;
 		    UINFO(4,"	 Dead assign "<<assp<<endl);
 		    assp->dtypep()->user1Inc(-1);
 		    assp->unlinkFrBack()->deleteTree(); VL_DANGLING(assp);
@@ -422,29 +426,29 @@ public:
 void V3Dead::deadifyModules(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DeadVisitor visitor (nodep, false, false, false, false);
-    V3Global::dumpCheckGlobalTree("deadModules.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
+    V3Global::dumpCheckGlobalTree("deadModules", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
 }

 void V3Dead::deadifyDTypes(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DeadVisitor visitor (nodep, false, true, false, false);
-    V3Global::dumpCheckGlobalTree("deadDtypes.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("deadDtypes", 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);
+    V3Global::dumpCheckGlobalTree("deadDtypesScoped", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

 void V3Dead::deadifyAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DeadVisitor visitor (nodep, true, true, false, true);
-    V3Global::dumpCheckGlobalTree("deadAll.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("deadAll", 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);
+    V3Global::dumpCheckGlobalTree("deadAllScoped", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -77,7 +77,6 @@ private:
    //  AstVarScope::user4p()	-> AstAlwaysPost*.  Post block for this variable
    //  AstVarScope::user5()	-> VarUsage. Tracks delayed vs non-delayed usage
    //  AstVar::user2()		-> bool.  Set true if already made warning
-    //  AstVar::user4()		-> int.   Vector number, for assignment creation
    //  AstVarRef::user2()	-> bool.  Set true if already processed
    //  AstAlwaysPost::user2()	-> ActActive*.  Points to activity block of signal (valid when AstAlwaysPost::user4p is valid)
    //  AstAlwaysPost::user4()	-> AstIf*.  Last IF (__Vdlyvset__) created under this AlwaysPost
@@ -102,7 +101,8 @@ private:
    typedef std::map<pair<AstNodeModule*,string>,AstVar*> VarMap;
    VarMap		m_modVarMap;	// Table of new var names created under module
    V3Double0		m_statSharedSet;// Statistic tracking
-
+    typedef std::map<AstVarScope*,int> ScopeVecMap;
+    ScopeVecMap m_scopeVecMap; // Next var number for each scope

    // METHODS
    static int debug() {
@@ -158,7 +158,7 @@ private:
 	if (oldactivep->sensesp() != m_activep->sensesp()) {
 	    if (!varrefp->varp()->fileline()->warnIsOff(V3ErrorCode::MULTIDRIVEN)
 		&& !varrefp->varp()->user2()) {
-		varrefp->varp()->v3warn(MULTIDRIVEN,"Signal has multiple driving blocks: "<<varrefp->varp()->prettyName()<<endl
+		varrefp->varp()->v3warn(MULTIDRIVEN,"Signal has multiple driving blocks with different clocking: "<<varrefp->varp()->prettyName()<<endl
 					<<varrefp->warnMore()<<"... Location of first driving block"<<endl
 					<<oldactivep->warnMore()<<"... Location of other driving block");
 		varrefp->varp()->user2(true);
@@ -195,7 +195,7 @@ private:
 	    arrayselp = lhsp->castArraySel();
 	}
 	if (!arrayselp) nodep->v3fatalSrc("No arraysel under bitsel?");
-	if (arrayselp->length()!=1) nodep->v3fatalSrc("ArraySel with length!=1 should have been removed in V3Slice");
+	if (arrayselp->dtypep()->skipRefp()->castUnpackArrayDType()) nodep->v3fatalSrc("ArraySel with unpacked arrays should have been removed in V3Slice");

 	UINFO(4,"AssignDlyArray: "<<nodep<<endl);
 	//
@@ -207,11 +207,11 @@ private:
 	    dimvalp.push_front(valp);
 	}
 	AstVarRef* varrefp = dimselp->castVarRef();
-	if (!varrefp) nodep->v3fatalSrc("No var underneath arraysels\n");
-	if (!varrefp->varScopep()) varrefp->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+	if (!varrefp) nodep->v3fatalSrc("No var underneath arraysels");
+	if (!varrefp->varScopep()) varrefp->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
 	varrefp->unlinkFrBack();
 	AstVar* oldvarp = varrefp->varp();
-	int modVecNum = oldvarp->user4();  oldvarp->user4(modVecNum+1);
+	int modVecNum = m_scopeVecMap[varrefp->varScopep()]++;
 	//
 	deque<AstNode*> dimreadps;		// Read value for each dimension of assignment
 	for (unsigned dimension=0; dimension<dimvalp.size(); dimension++) {
@@ -370,7 +370,7 @@ private:
 		&& nodep->lhsp()->castSel()->fromp()->castArraySel())) {
 	    AstNode* lhsp = nodep->lhsp()->unlinkFrBack();
 	    AstNode* newlhsp = createDlyArray(nodep, lhsp);
-	    if (m_inLoop) nodep->v3warn(E_BLKLOOPINIT,"Unsupported: Delayed assignment to array inside for loops (non-delayed is ok - see docs)");
+	    if (m_inLoop) nodep->v3warn(BLKLOOPINIT,"Unsupported: Delayed assignment to array inside for loops (non-delayed is ok - see docs)");
 	    if (newlhsp) {
 		nodep->lhsp(newlhsp);
 	    } else {
@@ -393,7 +393,7 @@ private:
 		if (!m_activep) nodep->v3fatalSrc("<= not under sensitivity block");
 		if (!m_activep->hasClocked()) nodep->v3error("Internal: Blocking <= assignment in non-clocked block, should have converted in V3Active");
 		AstVarScope* oldvscp = nodep->varScopep();
-		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+		if (!oldvscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp");
 		AstVarScope* dlyvscp = oldvscp->user1p()->castVarScope();
 		if (dlyvscp) {  // Multiple use of delayed variable
 		    AstActive* oldactivep = dlyvscp->user2p()->castActive();
@@ -433,7 +433,7 @@ private:
    }

    virtual void visit(AstNodeFor* nodep) {
-	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin\n");
+	nodep->v3fatalSrc("For statements should have been converted to while statements in V3Begin");
    }
    virtual void visit(AstWhile* nodep) {
 	bool oldloop = m_inLoop;
@@ -471,5 +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);
+    V3Global::dumpCheckGlobalTree("delayed", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -175,5 +175,5 @@ public:
 void V3Depth::depthAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DepthVisitor visitor (nodep);
-    V3Global::dumpCheckGlobalTree("depth.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
+    V3Global::dumpCheckGlobalTree("depth", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
 }
@@ -140,5 +140,5 @@ public:
 void V3DepthBlock::depthBlockAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DepthBlockVisitor visitor (nodep);
-    V3Global::dumpCheckGlobalTree("deepblock.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("deepblock", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -53,7 +53,8 @@ private:
    // STATE
    AstNodeModule*	m_modp;		// Current module
    AstScope*		m_scopep;	// Current scope
-    bool		m_needThis;	// Add thisp to function
+    bool		m_modSingleton; // m_modp is only instanced once
+    bool		m_needThis;	// Make function non-static
    FuncMmap		m_modFuncs;	// Name of public functions added

    // METHODS
@@ -63,41 +64,91 @@ private:
 	return level;
    }

-    string descopedName(AstScope* scopep, bool& hierThisr, AstVar* varp=NULL) {
+    static bool modIsSingleton(AstNodeModule* modp) {
+        // True iff there's exactly one instance of this module in the design.
+        int instances = 0;
+        for (AstNode* stmtp = modp->stmtsp(); stmtp; stmtp=stmtp->nextp()) {
+            if (stmtp->castScope()) {
+                if (++instances > 1) { return false; }
+            }
+        }
+        return (instances == 1);
+    }
+
+    // Construct the best prefix to reference an object in 'scopep'
+    // from a CFunc in 'm_scopep'. Result may be relative
+    // ("this->[...]") or absolute ("vlTOPp->[...]").
+    //
+    // Using relative references allows V3Combine'ing
+    // code across multiple instances of the same module.
+    //
+    // Sets 'hierThisr' true if the object is local to this scope
+    // (and could be made into a function-local later in V3Localize),
+    // false if the object is in another scope.
+    string descopedName(const AstScope* scopep, bool& hierThisr,
+                        const AstVar* varp=NULL) {
 	UASSERT(scopep, "Var/Func not scoped\n");
-	hierThisr = true;
+	hierThisr = (scopep == m_scopep);
+
+        // It's possible to disable relative references. This is a concession
+        // to older compilers (gcc < 4.5.x) that don't understand __restrict__
+        // well and emit extra ld/st to guard against pointer aliasing
+        // when this-> and vlTOPp-> are mixed in the same function.
+        //
+        // "vlTOPp" is declared "restrict" so better compilers understand
+        // that it won't alias with "this".
+        bool relativeRefOk = v3Global.opt.relativeCFuncs();
+
+        // Use absolute refs in top-scoped routines, keep them static.
+        // The DPI callback registration depends on representing top-level
+        // static routines as plain function pointers. That breaks if those
+        // become true OO routines.
+        //
+        // V3Combine wouldn't likely be able to combine top-level
+        // routines anyway, so there's no harm in keeping these static.
+        if (m_modp->isTop()) {
+            relativeRefOk = false;
+        }
+
+        // Use absolute refs if this scope is the only instance of the module.
+        // Saves a bit of overhead on passing the 'this' pointer, and there's no
+        // need to be nice to V3Combine when we have only a single instance.
+        // The risk that this prevents combining identical logic from differently-
+        // named but identical modules seems low.
+        if (m_modSingleton) {
+            relativeRefOk = false;
+        }
+
 	if (varp && varp->isFuncLocal()) {
+            hierThisr = true;
 	    return "";  // Relative to function, not in this
-	} else if (scopep == m_scopep && m_modp->isTop()) {
-	    //return "";  // Reference to scope we're in, no need to HIER-> it
-	    return "vlTOPp->";
-	} else if (scopep == m_scopep && !m_modp->isTop()
-		   && 0) {	// We no longer thisp-> as still get ambiguation problems
-	    m_needThis = true;
-	    return "thisp->";  // this-> but with restricted aliasing
-	} else if (scopep->aboveScopep() && scopep->aboveScopep()==m_scopep
-		   && 0  // DISABLED: GCC considers the pointers ambiguous, so goes ld/store crazy
-	    ) {
-	    // Reference to scope of cell directly under this module, can just "cell->"
-	    string name = scopep->name();
-	    string::size_type pos;
-	    if ((pos = name.rfind(".")) != string::npos) {
-		name.erase(0,pos+1);
-	    }
-	    hierThisr = false;
-	    return name+"->";
-	} else {
-	    // Reference to something else, use global variable
-	    UINFO(8,"      Descope "<<scopep<<endl);
-	    UINFO(8,"           to "<<scopep->name()<<endl);
-	    UINFO(8,"        under "<<m_scopep->name()<<endl);
-	    hierThisr = false;
-	    if (!scopep->aboveScopep()) { // Top
-		return "vlTOPp->";	// == "vlSymsp->TOPp->", but GCC would suspect aliases
-	    } else {
-		return scopep->nameVlSym()+".";
-	    }
-	}
+        } else if (relativeRefOk && scopep == m_scopep) {
+            m_needThis = true;
+            return "this->";
+        } else if (relativeRefOk && scopep->aboveScopep()
+                   && scopep->aboveScopep()==m_scopep) {
+            // Reference to scope of cell directly under this module, can just "cell->"
+            string name = scopep->name();
+            string::size_type pos;
+            if ((pos = name.rfind(".")) != string::npos) {
+                name.erase(0,pos+1);
+            }
+            m_needThis = true;
+            return name+"->";
+        } else {
+            // Reference to something elsewhere, or relative refences
+            // are disabled. Use global variable
+            UINFO(8,"      Descope "<<scopep<<endl);
+            UINFO(8,"           to "<<scopep->name()<<endl);
+            UINFO(8,"        under "<<m_scopep->name()<<endl);
+            if (!scopep->aboveScopep()) { // Top
+                // We could also return "vlSymsp->TOPp->" here, but GCC would
+                // suspect aliases.
+                return "vlTOPp->";
+            } else {
+                return scopep->nameVlSym()+".";
+            }
+        }
    }

    void makePublicFuncWrappers() {
@@ -138,8 +189,9 @@ private:
 		    for (AstNode* stmtp = newfuncp->argsp(); stmtp; stmtp=stmtp->nextp()) {
 			if (AstVar* portp = stmtp->castVar()) {
 			    if (portp->isIO() && !portp->isFuncReturn()) {
-				argsp = argsp->addNextNull(new AstVarRef(portp->fileline(), portp,
-									 portp->isOutput()));
+				AstNode* newp = new AstVarRef(portp->fileline(), portp, portp->isOutput());
+				if (argsp) argsp = argsp->addNextNull(newp);
+				else argsp = newp;
 			    }
 			}
 		    }
@@ -165,7 +217,7 @@ private:
 		    }
 		}
 		// Not really any way the user could do this, and we'd need to come up with some return value
-		//newfuncp->addStmtsp(new AstDisplay (newfuncp->fileline(), AstDisplayType::DT_DISPLAY,
+		//newfuncp->addStmtsp(new AstDisplay (newfuncp->fileline(), AstDisplayType::DT_WARNING,
 		//				      string("%%Error: ")+name+"() called with bad scope", NULL));
 		//newfuncp->addStmtsp(new AstStop (newfuncp->fileline()));
 		if (debug()>=9) newfuncp->dumpTree(cout,"   newfunc: ");
@@ -181,6 +233,7 @@ private:
    virtual void visit(AstNodeModule* nodep) {
 	m_modp = nodep;
 	m_modFuncs.clear();
+        m_modSingleton = modIsSingleton(m_modp);
 	nodep->iterateChildren(*this);
 	makePublicFuncWrappers();
 	m_modp = NULL;
@@ -221,11 +274,7 @@ private:
 	    nodep->iterateChildren(*this);
 	    nodep->user1(true);
 	    if (m_needThis) {
-		nodep->v3fatalSrc("old code");
-		// Really we should have more node types for backend optimization of this stuff
-		string text = v3Global.opt.modPrefix() + "_" + m_modp->name()
-		    +"* thisp = &("+m_scopep->nameVlSym()+");\n";
-		nodep->addInitsp(new AstCStmt(nodep->fileline(), text));
+                nodep->isStatic(false);
 	    }
 	    // If it's under a scope, move it up to the top
 	    if (m_scopep) {
@@ -247,11 +296,12 @@ private:
    }
 public:
    // CONSTRUCTORS
-    explicit DescopeVisitor(AstNetlist* nodep) {
-	m_modp = NULL;
-	m_scopep = NULL;
-	m_needThis = false;
-	nodep->accept(*this);
+    explicit DescopeVisitor(AstNetlist* nodep)
+        : m_modp(NULL),
+          m_scopep(NULL),
+          m_modSingleton(false),
+          m_needThis(false) {
+        nodep->accept(*this);
    }
    virtual ~DescopeVisitor() {}
 };
@@ -262,5 +312,5 @@ public:
 void V3Descope::descopeAll(AstNetlist* nodep) {
    UINFO(2,__FUNCTION__<<": "<<endl);
    DescopeVisitor visitor (nodep);
-    V3Global::dumpCheckGlobalTree("descope.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
+    V3Global::dumpCheckGlobalTree("descope", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
@@ -27,6 +27,7 @@
 #include <map>
 #include <vector>
 #include <algorithm>
+#include VL_INCLUDE_UNORDERED_SET

 #include "V3Global.h"
 #include "V3String.h"
@@ -36,6 +37,8 @@

 #define VL_VALUE_STRING_MAX_WIDTH 8192	// We use a static char array in VL_VALUE_STRING

+#define EMITC_NUM_CONSTW	8	// Number of VL_CONST_W_*X's in verilated.h (IE VL_CONST_W_8X is last)
+
 //######################################################################
 // Emit statements and math operators

@@ -69,7 +72,7 @@ public:
 		     const string& vformat, AstNode* exprsp, bool isScan);
    void displayEmit(AstNode* nodep, bool isScan);
    void displayArg(AstNode* dispp, AstNode** elistp, bool isScan,
-		    string vfmt, char fmtLetter);
+		    const string& vfmt, char fmtLetter);

    void emitVarDecl(AstVar* nodep, const string& prefixIfImp);
    typedef enum {EVL_IO, EVL_SIG, EVL_TEMP, EVL_PAR, EVL_ALL} EisWhich;
@@ -217,7 +220,7 @@ public:
    }
    virtual void visit(AstNodeCase* nodep) {
 	// In V3Case...
-	nodep->v3fatalSrc("Case statements should have been reduced out\n");
+	nodep->v3fatalSrc("Case statements should have been reduced out");
    }
    virtual void visit(AstComment* nodep) {
 	putsDecoration((string)"// "+nodep->name()+" at "+nodep->fileline()->ascii()+"\n");
@@ -277,54 +280,15 @@ public:
 	displayNode(nodep, NULL, nodep->text(), nodep->exprsp(), true);
    }
    virtual void visit(AstValuePlusArgs* nodep) {
-	string prefix;
-	char format = '?';
-	bool pct=false;
-	int got=0;
-	string txt = nodep->text();
-	for (string::const_iterator it=txt.begin(); it!=txt.end(); ++it) {
-	    char ch = *it;
-	    if (pct) {
-		pct = false;
-		switch (tolower(ch)) {
-		case '%':
-		    prefix += ch;
-		    break;
-		case 'd': // FALLTHRU
-		case 'o': // FALLTHRU
-		case 'h': // FALLTHRU
-		case 'x': // FALLTHRU
-		case 'b': // FALLTHRU
-		case 'v': // FALLTHRU
-		case 's':
-		    got++; format = tolower(ch);
-		    break;
-		case 'e': // FALLTHRU
-		case 'f': // FALLTHRU
-		case 'g':
-		    got++; format = tolower(ch);
-		    nodep->v3error("Unsupported $value$plusargs format qualifier: '"<<ch<<"'"<<endl);
-		    break;
-		default:
-		    got++;
-		    nodep->v3error("Illegal $value$plusargs format qualifier: '"<<ch<<"'"<<endl);
-		    break;
-		}
-	    }
-	    else if (ch == '%') pct = true;
-	    else prefix += ch;
-	}
-	if (got!=1) nodep->v3error("Missing or extra $value$plusargs format qualifier: '"<<nodep->text()<<"'"<<endl);
-	puts("VL_VALUEPLUSARGS_I");
-	emitIQW(nodep->exprsp());
+	puts("VL_VALUEPLUSARGS_IN");
+	emitIQW(nodep->outp());
 	puts("(");
-	puts(cvtToStr(nodep->exprsp()->widthMin()));  // Note argument width, not node width (which is always 32)
-	putbs(",");
-	putsQuoted(prefix);
-	putbs(",");
-	puts("'"); puts(cvtToStr(format)); puts("'");
+	puts(cvtToStr(nodep->outp()->widthMin()));
 	puts(",");
-	nodep->exprsp()->iterateAndNext(*this);
+	emitCvtPackStr(nodep->searchp());
+	puts(",");
+	putbs("");
+	nodep->outp()->iterateAndNext(*this);
 	puts(")");
    }
    virtual void visit(AstTestPlusArgs* nodep) {
@@ -470,14 +434,14 @@ public:
 	puts("}\n");
    }
    virtual void visit(AstStop* nodep) {
-	puts("vl_stop(");
+	puts("VL_STOP_MT(");
 	putsQuoted(nodep->fileline()->filename());
 	puts(",");
 	puts(cvtToStr(nodep->fileline()->lineno()));
 	puts(",\"\");\n");
    }
    virtual void visit(AstFinish* nodep) {
-	puts("vl_finish(");
+	puts("VL_FINISH_MT(");
 	putsQuoted(nodep->fileline()->filename());
 	puts(",");
 	puts(cvtToStr(nodep->fileline()->lineno()));
@@ -548,6 +512,30 @@ public:
 	}
 	visit(nodep->castNodeBiop());
    }
+    virtual void visit(AstPow* nodep) {
+	if (nodep->widthWords() > VL_MULS_MAX_WORDS) {
+	    nodep->v3error("Unsupported: Power of "<<nodep->width()<<" bits exceeds hardcoded limit VL_MULS_MAX_WORDS in verilatedos.h");
+	}
+	visit(nodep->castNodeBiop());
+    }
+    virtual void visit(AstPowSS* nodep) {
+	if (nodep->widthWords() > VL_MULS_MAX_WORDS) {
+	    nodep->v3error("Unsupported: Power of "<<nodep->width()<<" bits exceeds hardcoded limit VL_MULS_MAX_WORDS in verilatedos.h");
+	}
+	visit(nodep->castNodeBiop());
+    }
+    virtual void visit(AstPowSU* nodep) {
+	if (nodep->widthWords() > VL_MULS_MAX_WORDS) {
+	    nodep->v3error("Unsupported: Power of "<<nodep->width()<<" bits exceeds hardcoded limit VL_MULS_MAX_WORDS in verilatedos.h");
+	}
+	visit(nodep->castNodeBiop());
+    }
+    virtual void visit(AstPowUS* nodep) {
+	if (nodep->widthWords() > VL_MULS_MAX_WORDS) {
+	    nodep->v3error("Unsupported: Power of "<<nodep->width()<<" bits exceeds hardcoded limit VL_MULS_MAX_WORDS in verilatedos.h");
+	}
+	visit(nodep->castNodeBiop());
+    }
    virtual void visit(AstCCast* nodep) {
 	// Extending a value of the same word width is just a NOP.
 	if (nodep->size()>VL_WORDSIZE) {
@@ -618,33 +606,90 @@ public:
 	puts(nodep->hiername());
 	puts(nodep->varp()->name());
    }
+    void emitCvtPackStr(AstNode* nodep) {
+	if (AstConst* constp = nodep->castConst()) {
+	    putbs("std::string(");
+	    putsQuoted(constp->num().toString());
+	    puts(")");
+	} else {
+	    putbs("VL_CVT_PACK_STR_N");
+	    emitIQW(nodep);
+	    puts("(");
+	    if (nodep->isWide()) {
+		puts(cvtToStr(nodep->widthWords()));  // Note argument width, not node width (which is always 32)
+		puts(",");
+	    }
+	    nodep->iterateAndNext(*this);
+	    puts(")");
+	}
+    }
    void emitConstant(AstConst* nodep, AstVarRef* assigntop, const string& assignString) {
 	// Put out constant set to the specified variable, or given variable in a string
 	if (nodep->num().isFourState()) {
 	    nodep->v3error("Unsupported: 4-state numbers in this context");
 	} else if (nodep->num().isString()) {
-	    putbs("string(");
+	    putbs("std::string(");
 	    putsQuoted(nodep->num().toString());
 	    puts(")");
 	} else if (nodep->isWide()) {
-	    putbs("VL_CONST_W_");
-	    puts(cvtToStr(VL_WORDS_I(nodep->num().widthMin())));
-	    puts("X(");
-	    puts(cvtToStr(nodep->widthMin()));
-	    puts(",");
-	    if (!assigntop) {
-		puts(assignString);
-	    } else if (assigntop->castVarRef()) {
-		puts(assigntop->hiername());
-		puts(assigntop->varp()->name());
-	    } else {
-		assigntop->iterateAndNext(*this);
+	    int upWidth = nodep->num().widthMin();
+	    int chunks = 0;
+	    if (upWidth > EMITC_NUM_CONSTW*VL_WORDSIZE) {
+		// Output e.g. 8 words in groups of e.g. 8
+		chunks = (upWidth-1) / (EMITC_NUM_CONSTW*VL_WORDSIZE);
+		upWidth %= (EMITC_NUM_CONSTW*VL_WORDSIZE);
+		if (upWidth == 0) upWidth = (EMITC_NUM_CONSTW*VL_WORDSIZE);
 	    }
-	    for (int word=VL_WORDS_I(nodep->num().widthMin())-1; word>0; word--) {
-		// Only 32 bits - llx + long long here just to appease CPP format warning
-		ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word)));
+	    {	// Upper e.g. 8 words
+		if (chunks) {
+		    putbs("VL_CONSTHI_W_");
+		    puts(cvtToStr(VL_WORDS_I(upWidth)));
+		    puts("X(");
+		    puts(cvtToStr(nodep->widthMin()));
+		    puts(",");
+		    puts(cvtToStr(chunks*EMITC_NUM_CONSTW*VL_WORDSIZE));
+		} else {
+		    putbs("VL_CONST_W_");
+		    puts(cvtToStr(VL_WORDS_I(upWidth)));
+		    puts("X(");
+		    puts(cvtToStr(nodep->widthMin()));
+		}
+		puts(",");
+		if (!assigntop) {
+		    puts(assignString);
+		} else if (assigntop->castVarRef()) {
+		    puts(assigntop->hiername());
+		    puts(assigntop->varp()->name());
+		} else {
+		    assigntop->iterateAndNext(*this);
+		}
+		for (int word=VL_WORDS_I(upWidth)-1; word>=0; word--) {
+		    // Only 32 bits - llx + long long here just to appease CPP format warning
+		    ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
+		}
+		puts(")");
+	    }
+	    for (chunks--; chunks >= 0; chunks--) {
+		puts(";\n");
+		putbs("VL_CONSTLO_W_");
+		puts(cvtToStr(EMITC_NUM_CONSTW));
+		puts("X(");
+		puts(cvtToStr(chunks*EMITC_NUM_CONSTW*VL_WORDSIZE));
+		puts(",");
+		if (!assigntop) {
+		    puts(assignString);
+		} else if (assigntop->castVarRef()) {
+		    puts(assigntop->hiername());
+		    puts(assigntop->varp()->name());
+		} else {
+		    assigntop->iterateAndNext(*this);
+		}
+		for (int word=EMITC_NUM_CONSTW-1; word>=0; word--) {
+		    // Only 32 bits - llx + long long here just to appease CPP format warning
+		    ofp()->printf(",0x%08" VL_PRI64 "x", (vluint64_t)(nodep->num().dataWord(word+chunks*EMITC_NUM_CONSTW)));
+		}
+		puts(")");
 	    }
-	    ofp()->printf(",0x%08" VL_PRI64 "x)", (vluint64_t)(nodep->num().dataWord(0)));
 	} else if (nodep->isDouble()) {
 	    if (int(nodep->num().toDouble()) == nodep->num().toDouble()
 		&& nodep->num().toDouble() < 1000
@@ -780,12 +825,7 @@ class EmitCImp : EmitCStmts {
 	    // We should move them to a different stage.
 	    string filename = VL_DEV_NULL;
 	    newCFile(filename, slow, source);
-	    ofp = new V3OutSpFile (filename);
-	}
-	else if (optSystemPerl()) {
-	    string filename = filenameNoExt+".sp";
-	    newCFile(filename, slow, source);
-	    ofp = new V3OutSpFile (filename);
+	    ofp = new V3OutCFile (filename);
 	}
 	else if (optSystemC()) {
 	    string filename = filenameNoExt+(source?".cpp":".h");
@@ -832,12 +872,14 @@ class EmitCImp : EmitCStmts {
 	splitSizeInc(nodep);

 	puts("\n");
+	if (nodep->ifdef()!="") puts("#ifdef "+nodep->ifdef()+"\n");
 	if (nodep->isInline()) puts("VL_INLINE_OPT ");
 	puts(nodep->rtnTypeVoid()); puts(" ");
 	puts(modClassName(m_modp)+"::"+nodep->name()
 	     +"("+cFuncArgs(nodep)+") {\n");

-	puts("VL_DEBUG_IF(VL_PRINTF(\"  ");
+	// "+" in the debug indicates a print from the model
+	puts("VL_DEBUG_IF(VL_DBG_MSGF(\"+  ");
 	for (int i=0;i<m_modp->level();i++) { puts("  "); }
 	puts(modClassName(m_modp)+"::"+nodep->name()
 	     +"\\n\"); );\n");
@@ -845,16 +887,13 @@ class EmitCImp : EmitCStmts {
 	if (nodep->symProlog()) puts(EmitCBaseVisitor::symTopAssign()+"\n");

 	if (nodep->initsp()) putsDecoration("// Variables\n");
-	ofp()->putAlign(V3OutFile::AL_AUTO, 4);
 	for (AstNode* subnodep=nodep->argsp(); subnodep; subnodep = subnodep->nextp()) {
 	    if (AstVar* varp=subnodep->castVar()) {
 		if (varp->isFuncReturn()) emitVarDecl(varp, "");
 	    }
 	}
 	emitVarList(nodep->initsp(), EVL_ALL, "");
-	ofp()->putAlign(V3OutFile::AL_AUTO, 4);
 	emitVarList(nodep->stmtsp(), EVL_ALL, "");
-	ofp()->putAlign(V3OutFile::AL_AUTO, 4);

 	nodep->initsp()->iterateAndNext(*this);

@@ -870,6 +909,7 @@ class EmitCImp : EmitCStmts {

 	//puts("__Vm_activity = true;\n");
 	puts("}\n");
+	if (nodep->ifdef()!="") puts("#endif // "+nodep->ifdef()+"\n");
    }

    void emitChangeDet() {
@@ -901,7 +941,7 @@ class EmitCImp : EmitCStmts {
 		    if (nodep->lhsp()->castVarRef()) {
 			varname = ": "+nodep->lhsp()->castVarRef()->varp()->prettyName();
 		    }
-		    puts(")) VL_PRINTF(\"\tCHANGE: "+nodep->fileline()->ascii()
+		    puts(")) VL_DBG_MSGF(\"        CHANGE: "+nodep->fileline()->ascii()
 			 +varname+"\\n\"); );\n");
 		}
 	    }
@@ -962,9 +1002,8 @@ void EmitCStmts::emitVarDecl(AstVar* nodep, const string& prefixIfImp) {
    if (nodep->isIO()) {
 	if (nodep->isSc()) {
 	    m_ctorVarsVec.push_back(nodep);
-	    ofp()->putAlign(nodep->isStatic(), 4);	// sc stuff is a structure, so bigger alignment
 	    if (nodep->attrScClocked() && nodep->isInput()) {
-		puts("sc_in_clk\t");
+		puts("sc_in_clk ");
 	    } else {
 		if (nodep->isInout()) puts("sc_inout<");
 		else if (nodep->isInput()) puts("sc_in<");
@@ -972,7 +1011,7 @@ void EmitCStmts::emitVarDecl(AstVar* nodep, const string& prefixIfImp) {
 		else nodep->v3fatalSrc("Unknown type");

 		puts(nodep->scType());
-		puts(">\t");
+		puts("> ");
 	    }
 	    puts(nodep->name());
 	    emitDeclArrayBrackets(nodep);
@@ -983,8 +1022,6 @@ void EmitCStmts::emitVarDecl(AstVar* nodep, const string& prefixIfImp) {
 	    emitDeclArrayBrackets(nodep);
 	    puts(";\n");
 	} else { // C++ signals
-	    ofp()->putAlign(nodep->isStatic(), nodep->dtypeSkipRefp()->widthAlignBytes(),
-			    nodep->dtypeSkipRefp()->widthTotalBytes());
 	    if (nodep->isInout()) puts("VL_INOUT");
 	    else if (nodep->isInput()) puts("VL_IN");
 	    else if (nodep->isOutput()) puts("VL_OUT");
@@ -1011,8 +1048,6 @@ void EmitCStmts::emitVarDecl(AstVar* nodep, const string& prefixIfImp) {
    } else {
 	// Arrays need a small alignment, but may need different padding after.
 	// For example three VL_SIG8's needs alignment 1 but size 3.
-	ofp()->putAlign(nodep->isStatic(), nodep->dtypeSkipRefp()->widthAlignBytes(),
-			nodep->dtypeSkipRefp()->widthTotalBytes());
 	if (nodep->isStatic() && prefixIfImp=="") puts("static ");
 	if (nodep->isStatic()) puts("VL_ST_"); else puts("VL_");
 	if (nodep->widthMin() <= 8) {
@@ -1235,7 +1270,6 @@ void EmitCStmts::displayEmit(AstNode* nodep, bool isScan) {
 	    if (dispp) {}
 	    puts("VL_SFORMATF_NX(");
 	} else {
-	    isStmt = true;
 	    nodep->v3fatalSrc("Unknown displayEmit node type");
 	}
 	ofp()->putsQuoted(emitDispState.m_format);
@@ -1267,7 +1301,7 @@ void EmitCStmts::displayEmit(AstNode* nodep, bool isScan) {
 }

 void EmitCStmts::displayArg(AstNode* dispp, AstNode** elistp, bool isScan,
-			    string vfmt, char fmtLetter) {
+			    const string& vfmt, char fmtLetter) {
    // Print display argument, edits elistp
    AstNode* argp = *elistp;
    if (!argp) {
@@ -1434,7 +1468,8 @@ void EmitCImp::emitVarReset(AstVar* varp) {
 	}
 	bool zeroit = (varp->attrFileDescr() // Zero it out, so we don't core dump if never call $fopen
 		       || (varp->basicp() && varp->basicp()->isZeroInit())
-		       || (varp->name().size()>=1 && varp->name()[0]=='_' && v3Global.opt.underlineZero()));
+		       || (varp->name().size()>=1 && varp->name()[0]=='_' && v3Global.opt.underlineZero())
+		       || (v3Global.opt.xInitial() == "fast" || v3Global.opt.xInitial() == "0"));
 	if (varp->isWide()) {
 	    // DOCUMENT: We randomize everything.  If the user wants a _var to be zero,
 	    // there should be a initial statement.  (Different from verilator2.)
@@ -1482,9 +1517,7 @@ void EmitCImp::emitCoverageDecl(AstNodeModule* modp) {

 void EmitCImp::emitCtorImp(AstNodeModule* modp) {
    puts("\n");
-    if (optSystemPerl() && modp->isTop()) {
-	puts("SP_CTOR_IMP("+modClassName(modp)+")");
-    } else if (optSystemC() && modp->isTop()) {
+    if (optSystemC() && modp->isTop()) {
 	puts("VL_SC_CTOR_IMP("+modClassName(modp)+")");
    } else {
 	puts("VL_CTOR_IMP("+modClassName(modp)+")");
@@ -1502,7 +1535,6 @@ void EmitCImp::emitCtorImp(AstNodeModule* modp) {
    putsDecoration("// Reset structure values\n");
    puts("_ctor_var_reset();\n");
    emitTextSection(AstType::atScCtor);
-    if (optSystemPerl()) puts("SP_AUTO_CTOR;\n");
    puts("}\n");
 }

@@ -1521,9 +1553,7 @@ void EmitCImp::emitCoverageImp(AstNodeModule* modp) {
    if (v3Global.opt.coverage() ) {
 	puts("\n// Coverage\n");
 	// Rather than putting out VL_COVER_INSERT calls directly, we do it via this function
-	// This gets around gcc slowness constructing all of the template arguments
-	// SystemPerl 1.301 is much faster, but it's nice to remain back
-	// compatible, and have a common wrapper.
+	// This gets around gcc slowness constructing all of the template arguments.
 	puts("void "+modClassName(m_modp)+"::__vlCoverInsert(uint32_t* countp, bool enable, const char* filenamep, int lineno, int column,\n");
 	puts(  	"const char* hierp, const char* pagep, const char* commentp) {\n");
 	puts(   "static uint32_t fake_zero_count = 0;\n");  // static doesn't need save-restore as constant
@@ -1533,8 +1563,8 @@ void EmitCImp::emitCoverageImp(AstNodeModule* modp) {
 	puts(	"  \"filename\",filenamep,");
 	puts(	"  \"lineno\",lineno,");
 	puts(	"  \"column\",column,\n");
-	//puts(	"\"hier\",string(__VlSymsp->name())+hierp,");  // Need to move hier into scopes and back out if do this
-	puts(	"\"hier\",string(name())+hierp,");
+	//puts(	"\"hier\",std::string(__VlSymsp->name())+hierp,");  // Need to move hier into scopes and back out if do this
+	puts(	"\"hier\",std::string(name())+hierp,");
 	puts(	"  \"page\",pagep,");
 	puts(	"  \"comment\",commentp);\n");
 	puts("}\n");
@@ -1703,25 +1733,45 @@ void EmitCImp::emitSensitives() {

 void EmitCImp::emitWrapEval(AstNodeModule* modp) {
    puts("\nvoid "+modClassName(modp)+"::eval() {\n");
-    puts(EmitCBaseVisitor::symClassVar()+" = this->__VlSymsp; // Setup global symbol table\n");
+    puts("VL_DEBUG_IF(VL_DBG_MSGF(\"+++++TOP Evaluate "+modClassName(modp)+"::eval\\n\"); );\n");
+    puts(EmitCBaseVisitor::symClassVar()+" = this->__VlSymsp;  // Setup global symbol table\n");
    puts(EmitCBaseVisitor::symTopAssign()+"\n");
+    puts("#ifdef VL_DEBUG\n");
+    putsDecoration("// Debug assertions\n");
+    puts("_eval_debug_assertions();\n");
+    puts("#endif // VL_DEBUG\n");
    putsDecoration("// Initialize\n");
    puts("if (VL_UNLIKELY(!vlSymsp->__Vm_didInit)) _eval_initial_loop(vlSymsp);\n");
    if (v3Global.opt.inhibitSim()) {
 	puts("if (VL_UNLIKELY(__Vm_inhibitSim)) return;\n");
    }
+
+    if (v3Global.opt.threads()) {  // THREADED-TODO move to per-train
+	uint32_t trainId = 0;
+	putsDecoration("// Train "+cvtToStr(trainId)+" start\n");
+	puts("VL_DEBUG_IF(VL_DBG_MSGF(\"Train starting, trainId="+cvtToStr(trainId)+"\\n\"););\n");
+	puts("Verilated::trainId("+cvtToStr(trainId)+");\n");
+    }
+
    putsDecoration("// Evaluate till stable\n");
-    puts("VL_DEBUG_IF(VL_PRINTF(\"\\n----TOP Evaluate "+modClassName(modp)+"::eval\\n\"); );\n");
    puts("int __VclockLoop = 0;\n");
-    puts("QData __Vchange=1;\n");
+    puts("QData __Vchange = 1;\n");
    puts("while (VL_LIKELY(__Vchange)) {\n");
-    puts(    "VL_DEBUG_IF(VL_PRINTF(\" Clock loop\\n\"););\n");
-    puts(    "vlSymsp->__Vm_activity = true;\n");
+    puts(    "VL_DEBUG_IF(VL_DBG_MSGF(\"+ Clock loop\\n\"););\n");
+    if (v3Global.opt.trace()) {
+	puts("vlSymsp->__Vm_activity = true;\n");
+    }
    puts(    "_eval(vlSymsp);\n");
    puts(    "__Vchange = _change_request(vlSymsp);\n");
-    puts(    "if (++__VclockLoop > "+cvtToStr(v3Global.opt.convergeLimit())
-	     +") vl_fatal(__FILE__,__LINE__,__FILE__,\"Verilated model didn't converge\");\n");
+    puts(    "if (VL_UNLIKELY(++__VclockLoop > "+cvtToStr(v3Global.opt.convergeLimit())
+	     +")) VL_FATAL_MT(__FILE__,__LINE__,__FILE__,\"Verilated model didn't converge\");\n");
    puts("}\n");
+    if (v3Global.opt.threads()) {  // THREADED-TODO move to end of all trains on thread
+	puts("Verilated::endOfThreadTrain(vlSymsp->__Vm_evalMsgQp);\n");
+    }
+    if (v3Global.opt.threads()) {
+	puts("Verilated::endOfEval(vlSymsp->__Vm_evalMsgQp);\n");
+    }
    puts("}\n");
    splitSizeInc(10);

@@ -1729,15 +1779,17 @@ void EmitCImp::emitWrapEval(AstNodeModule* modp) {
    puts("\nvoid "+modClassName(modp)+"::_eval_initial_loop("+EmitCBaseVisitor::symClassVar()+") {\n");
    puts("vlSymsp->__Vm_didInit = true;\n");
    puts("_eval_initial(vlSymsp);\n");
-    puts(    "vlSymsp->__Vm_activity = true;\n");
+    if (v3Global.opt.trace()) {
+	puts("vlSymsp->__Vm_activity = true;\n");
+    }
    puts(    "int __VclockLoop = 0;\n");
-    puts(    "QData __Vchange=1;\n");
+    puts(    "QData __Vchange = 1;\n");
    puts(    "while (VL_LIKELY(__Vchange)) {\n");
    puts(        "_eval_settle(vlSymsp);\n");
    puts(        "_eval(vlSymsp);\n");
    puts(	 "__Vchange = _change_request(vlSymsp);\n");
-    puts(        "if (++__VclockLoop > "+cvtToStr(v3Global.opt.convergeLimit())
-		 +") vl_fatal(__FILE__,__LINE__,__FILE__,\"Verilated model didn't DC converge\");\n");
+    puts(        "if (VL_UNLIKELY(++__VclockLoop > "+cvtToStr(v3Global.opt.convergeLimit())
+		 +")) VL_FATAL_MT(__FILE__,__LINE__,__FILE__,\"Verilated model didn't DC converge\");\n");
    puts(    "}\n");
    puts("}\n");
    splitSizeInc(10);
@@ -1787,7 +1839,6 @@ void EmitCStmts::emitVarList(AstNode* firstp, EisWhich which, const string& pref
 		}
 	    }
 	}
-	ofp()->putAlign(isstatic, 4, 0, prefixIfImp);
    }
 }

@@ -1814,20 +1865,20 @@ void EmitCImp::emitIntFuncDecls(AstNodeModule* modp) {
 	AstCFunc* funcp = *it;
 	if (!funcp->dpiImport()) {  // DPI is prototyped in __Dpi.h
 	    ofp()->putsPrivate(funcp->declPrivate());
+	    if (funcp->ifdef()!="") puts("#ifdef "+funcp->ifdef()+"\n");
 	    if (funcp->isStatic()) puts("static ");
-	    puts(funcp->rtnTypeVoid()); puts("\t");
+	    puts(funcp->rtnTypeVoid()); puts(" ");
 	    puts(funcp->name()); puts("("+cFuncArgs(funcp)+");\n");
+	    if (funcp->ifdef()!="") puts("#endif // "+funcp->ifdef()+"\n");
 	}
    }
 }

 void EmitCImp::emitInt(AstNodeModule* modp) {
    // Always have this first; gcc has short circuiting if #ifdef is first in a file
-    if (!optSystemPerl()) {  // else done for us automatically
-	puts("#ifndef _"+modClassName(modp)+"_H_\n");
-	puts("#define _"+modClassName(modp)+"_H_\n");
-	puts("\n");
-    }
+    puts("#ifndef _"+modClassName(modp)+"_H_\n");
+    puts("#define _"+modClassName(modp)+"_H_\n");
+    puts("\n");

    ofp()->putsIntTopInclude();
    if (v3Global.needHeavy()) {
@@ -1849,14 +1900,19 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
 	// do this before including our main .h file so that any references to
 	// types defined in svdpi.h are available
 	puts("#include \""+ topClassName() +"__Dpi.h\"\n");
-	puts("\n");
    }
+    puts("\n");

    // Declare foreign instances up front to make C++ happy
    puts("class "+symClassName()+";\n");
+    vl_unordered_set<string> didClassName;
    for (AstNode* nodep=modp->stmtsp(); nodep; nodep = nodep->nextp()) {
 	if (AstCell* cellp=nodep->castCell()) {
-	    puts("class "+modClassName(cellp->modp())+";\n");
+	    string className = modClassName(cellp->modp());
+	    if (didClassName.find(className)==didClassName.end()) {
+		puts("class "+className+";\n");
+		didClassName.insert(className);
+	    }
 	}
    }
    if (v3Global.opt.trace()) {
@@ -1871,19 +1927,19 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
    } else {
 	puts("VL_MODULE("+modClassName(modp)+") {\n");
    }
-    if (optSystemPerl()) puts("/*AUTOATTR(verilated)*/\n\n");
    ofp()->resetPrivate();
    ofp()->putsPrivate(false);  // public:

-    // Instantiated modules
-    if (optSystemPerl()) {
-	puts("/*AUTOSUBCELLS*/\n\n");
-    } else {
-	putsDecoration("// CELLS\n");
-	if (modp->isTop()) puts("// Public to allow access to /*verilator_public*/ items;\n");
-	if (modp->isTop()) puts("// otherwise the application code can consider these internals.\n");
+    {  // Instantiated cells
+	bool did = false;
 	for (AstNode* nodep=modp->stmtsp(); nodep; nodep = nodep->nextp()) {
 	    if (AstCell* cellp=nodep->castCell()) {
+		if (!did) {
+		    did = true;
+		    putsDecoration("// CELLS\n");
+		    if (modp->isTop()) puts("// Public to allow access to /*verilator_public*/ items;\n");
+		    if (modp->isTop()) puts("// otherwise the application code can consider these internals.\n");
+		}
 		ofp()->putsCellDecl(modClassName(cellp->modp()), cellp->name());
 	    }
 	}
@@ -1907,18 +1963,14 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
    puts("\n// INTERNAL VARIABLES\n");
    if (modp->isTop()) puts("// Internals; generally not touched by application code\n");
    ofp()->putsPrivate(!modp->isTop());  // private: unless top
-    ofp()->putAlign(V3OutFile::AL_AUTO, 8);
-    puts(symClassName()+"*\t__VlSymsp;\t\t// Symbol table\n");
+    puts(symClassName()+"* __VlSymsp;  // Symbol table\n");
    ofp()->putsPrivate(false);  // public:
    if (modp->isTop()) {
 	if (v3Global.opt.inhibitSim()) {
-	    ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(bool));
-	    puts("bool\t__Vm_inhibitSim;\t///< Set true to disable evaluation of module\n");
+	    puts("bool __Vm_inhibitSim;  ///< Set true to disable evaluation of module\n");
 	}
    }
-    ofp()->putAlign(V3OutFile::AL_AUTO, 8);
    emitCoverageDecl(modp);	// may flip public/private
-    ofp()->putAlign(V3OutFile::AL_AUTO, 8);

    puts("\n// PARAMETERS\n");
    if (modp->isTop()) puts("// Parameters marked /*verilator public*/ for use by application code\n");
@@ -1950,8 +2002,8 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
    ofp()->resetPrivate();
    // We don't need a private copy constructor, as VerilatedModule has one for us.
    ofp()->putsPrivate(true);
-    puts(modClassName(modp)+"& operator= (const "+modClassName(modp)+"&);\t///< Copying not allowed\n");
-    puts(modClassName(modp)+"(const "+modClassName(modp)+"&);\t///< Copying not allowed\n");
+    puts(modClassName(modp)+"& operator= (const "+modClassName(modp)+"&);  ///< Copying not allowed\n");
+    puts(modClassName(modp)+"(const "+modClassName(modp)+"&);  ///< Copying not allowed\n");

    ofp()->putsPrivate(false);  // public:
    if (optSystemC() && modp->isTop()) {
@@ -1970,7 +2022,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
 	if (modp->isTop()) puts("/// Destroy the model; called (often implicitly) by application code\n");
 	puts("~"+modClassName(modp)+"();\n");
    }
-    if (v3Global.opt.trace() && !optSystemPerl()) {
+    if (v3Global.opt.trace()) {
 	if (modp->isTop()) puts("/// Trace signals in the model; called by application code\n");
 	puts("void trace (VerilatedVcdC* tfp, int levels, int options=0);\n");
 	if (modp->isTop() && optSystemC()) {
@@ -1979,8 +2031,6 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
 	}
    }

-    puts("\n// USER METHODS\n");
-    if (optSystemPerl()) puts("/*AUTOMETHODS*/\n");
    emitTextSection(AstType::atScInt);

    puts("\n// API METHODS\n");
@@ -1992,7 +2042,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) {
 	if (!optSystemC()) puts("/// Simulation complete, run final blocks.  Application must call on completion.\n");
 	puts("void final();\n");
 	if (v3Global.opt.inhibitSim()) {
-	    puts("void inhibitSim(bool flag) { __Vm_inhibitSim=flag; }\t///< Set true to disable evaluation of module\n");
+	    puts("void inhibitSim(bool flag) { __Vm_inhibitSim=flag; }  ///< Set true to disable evaluation of module\n");
 	}
    }

@@ -2007,7 +2057,7 @@ void EmitCImp::emitInt(AstNodeModule* modp) {

    emitIntFuncDecls(modp);

-    if (!optSystemPerl() && v3Global.opt.trace()) {
+    if (v3Global.opt.trace()) {
 	ofp()->putsPrivate(false);  // public:
 	puts("static void traceInit ("+v3Global.opt.traceClassBase()+"* vcdp, void* userthis, uint32_t code);\n");
 	puts("static void traceFull ("+v3Global.opt.traceClassBase()+"* vcdp, void* userthis, uint32_t code);\n");
@@ -2025,24 +2075,20 @@ void EmitCImp::emitInt(AstNodeModule* modp) {

    // Save/restore
    if (v3Global.opt.savable() && modp->isTop()) {
-	puts("inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   "+modClassName(modp)+"& rhs) {rhs.__Vserialize(os); return os;}\n");
-	puts("inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, "+modClassName(modp)+"& rhs) {rhs.__Vdeserialize(os); return os;}\n");
+	puts("inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   "+modClassName(modp)+"& rhs) {\n"
+	     "Verilated::quiesce(); rhs.__Vserialize(os); return os; }\n");
+	puts("inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, "+modClassName(modp)+"& rhs) {\n"
+	     "Verilated::quiesce(); rhs.__Vdeserialize(os); return os; }\n");
 	puts("\n");
    }

    // finish up h-file
-    if (!optSystemPerl()) {
-	puts("#endif  /*guard*/\n");
-    }
+    puts("#endif // guard\n");
 }

 //----------------------------------------------------------------------

 void EmitCImp::emitImp(AstNodeModule* modp) {
-    if (optSystemPerl()) {
-	puts("//############################################################\n");
-	puts("#sp implementation\n");
-    }
    ofp()->printf("#include \"%-20s // For This\n",
 		  (modClassName(modp)+".h\"").c_str());

@@ -2053,11 +2099,7 @@ void EmitCImp::emitImp(AstNodeModule* modp) {
 	puts("\n");
 	puts("#include \"verilated_dpi.h\"\n");
    }
-
-    if (optSystemPerl() && (splitFilenum() || !m_fast)) {
-	puts("\n");
-	puts("SP_MODULE_CONTINUED("+modClassName(modp)+");\n");
-    }
+    puts("\n");

    emitTextSection(AstType::atScImpHdr);

@@ -2090,13 +2132,6 @@ void EmitCImp::emitImp(AstNodeModule* modp) {
 	}
    }

-    if (m_fast && splitFilenum()==0) {
-	if (v3Global.opt.trace() && optSystemPerl() && m_modp->isTop()) {
-	    puts("\n");
-	    puts("\n/*AUTOTRACE(__MODULE__,recurse,activity,exists)*/\n\n");
-	}
-    }
-
    // Blocks
    puts("\n//--------------------\n");
    puts("// Internal Methods\n");
@@ -2114,15 +2149,7 @@ void EmitCImp::main(AstNodeModule* modp, bool slow, bool fast) {
 	UINFO(0,"  Emitting "<<modClassName(modp)<<endl);
    }

-    if (optSystemPerl()) {
-	m_ofp = newOutCFile(modp, !m_fast, true);
-
-	if (m_fast) {
-	    puts("#sp interface\n");
-	    emitInt (modp);
-	}
-    }
-    else if (optSystemC()) {
+    if (optSystemC()) {
 	if (m_fast) {
 	    m_ofp = newOutCFile (modp, !m_fast, false/*source*/);
 	    emitInt (modp);
@@ -2187,11 +2214,7 @@ class EmitCTrace : EmitCStmts {

    void emitTraceHeader() {
 	// Includes
-	if (optSystemPerl()) {
-	    puts("#include \"SpTraceVcd.h\"\n");
-	} else {
-	    puts("#include \"verilated_vcd_c.h\"\n");
-	}
+	puts("#include \"verilated_vcd_c.h\"\n");
 	puts("#include \""+ symClassName() +".h\"\n");
 	puts("\n");
    }
@@ -2200,11 +2223,7 @@ class EmitCTrace : EmitCStmts {
 	puts("\n//======================\n\n");

 	puts("void "+topClassName()+"::trace (");
-	if (optSystemPerl()) {
-	    puts("SpTraceFile* tfp, int, int) {\n");
-	} else {
-	    puts("VerilatedVcdC* tfp, int, int) {\n");
-	}
+	puts("VerilatedVcdC* tfp, int, int) {\n");
 	puts(  "tfp->spTrace()->addCallback ("
 	       "&"+topClassName()+"::traceInit"
 	       +", &"+topClassName()+"::traceFull"
@@ -2216,12 +2235,12 @@ class EmitCTrace : EmitCStmts {
 	     +v3Global.opt.traceClassBase()+"* vcdp, void* userthis, uint32_t code) {\n");
 	putsDecoration("// Callback from vcd->open()\n");
 	puts(topClassName()+"* t=("+topClassName()+"*)userthis;\n");
-	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp; // Setup global symbol table\n");
-	puts("if (!Verilated::calcUnusedSigs()) vl_fatal(__FILE__,__LINE__,__FILE__,\"Turning on wave traces requires Verilated::traceEverOn(true) call before time 0.\");\n");
+	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp;  // Setup global symbol table\n");
+	puts("if (!Verilated::calcUnusedSigs()) VL_FATAL_MT(__FILE__,__LINE__,__FILE__,\"Turning on wave traces requires Verilated::traceEverOn(true) call before time 0.\");\n");

 	puts("vcdp->scopeEscape(' ');\n");
 	puts("t->traceInitThis (vlSymsp, vcdp, code);\n");
-	puts("vcdp->scopeEscape('.');\n");  // Restore so SystemPerl traced files won't break
+	puts("vcdp->scopeEscape('.');\n");  // Restore so later traced files won't break
 	puts("}\n");
 	splitSizeInc(10);

@@ -2229,7 +2248,7 @@ class EmitCTrace : EmitCStmts {
 	     +v3Global.opt.traceClassBase()+"* vcdp, void* userthis, uint32_t code) {\n");
 	putsDecoration("// Callback from vcd->dump()\n");
 	puts(topClassName()+"* t=("+topClassName()+"*)userthis;\n");
-	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp; // Setup global symbol table\n");
+	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp;  // Setup global symbol table\n");
 	puts("t->traceFullThis (vlSymsp, vcdp, code);\n");
 	puts("}\n");
 	splitSizeInc(10);
@@ -2244,7 +2263,7 @@ class EmitCTrace : EmitCStmts {
 	     +v3Global.opt.traceClassBase()+"* vcdp, void* userthis, uint32_t code) {\n");
 	putsDecoration("// Callback from vcd->dump()\n");
 	puts(topClassName()+"* t=("+topClassName()+"*)userthis;\n");
-	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp; // Setup global symbol table\n");
+	puts(EmitCBaseVisitor::symClassVar()+" = t->__VlSymsp;  // Setup global symbol table\n");
 	puts("if (vlSymsp->getClearActivity()) {\n");
 	puts("t->traceChgThis (vlSymsp, vcdp, code);\n");
 	puts("}\n");
@@ -2388,7 +2407,7 @@ class EmitCTrace : EmitCStmts {
 	    puts("int c=code;\n");
 	    puts("if (0 && vcdp && c) {}  // Prevent unused\n");
 	    if (nodep->funcType() == AstCFuncType::TRACE_INIT) {
-		puts("vcdp->module(vlSymsp->name()); // Setup signal names\n");
+		puts("vcdp->module(vlSymsp->name());  // Setup signal names\n");
 	    } else if (nodep->funcType() == AstCFuncType::TRACE_INIT_SUB) {
 	    } else if (nodep->funcType() == AstCFuncType::TRACE_FULL) {
 	    } else if (nodep->funcType() == AstCFuncType::TRACE_FULL_SUB) {
@@ -2399,7 +2418,6 @@ class EmitCTrace : EmitCStmts {
 	    if (nodep->initsp()) putsDecoration("// Variables\n");
 	    emitVarList(nodep->initsp(), EVL_ALL, "");
 	    nodep->initsp()->iterateAndNext(*this);
-	    ofp()->putAlign(V3OutFile::AL_AUTO, 4);

 	    putsDecoration("// Body\n");
 	    puts("{\n");
@@ -46,7 +46,6 @@ public:
    void putsDecoration(const string& str) { if (v3Global.opt.decoration()) puts(str); }
    void putsQuoted(const string& str) { ofp()->putsQuoted(str); }
    bool optSystemC() { return v3Global.opt.systemC(); }
-    bool optSystemPerl() { return v3Global.opt.systemPerl(); }
    static string symClassName() { return v3Global.opt.prefix()+"__Syms"; }
    static string symClassVar()  { return symClassName()+"* __restrict vlSymsp"; }
    static string symTopAssign() { return v3Global.opt.prefix()+"* __restrict vlTOPp VL_ATTR_UNUSED = vlSymsp->TOPp;"; }
@@ -32,30 +32,15 @@
 #include "V3EmitCBase.h"
 #include "V3Stats.h"

-#define EMITCINLINES_NUM_CONSTW	10	// Number of VL_CONST_W_*X's in verilated.h (IE VL_CONST_W_9X is last)
-
 //######################################################################

 class EmitCInlines : EmitCBaseVisitor {
    // STATE
-    vector<V3Double0>	m_wordWidths;	// What sizes are used?

    // METHODS
    void emitInt();

    // VISITORS
-    virtual void visit(AstVar* nodep) {
-	// All wide constants load into variables, so we can just hunt for them
-	nodep->iterateChildren(*this);
-	int words = nodep->widthWords();
-	if (words >= EMITCINLINES_NUM_CONSTW ) {
-	    if (int(m_wordWidths.size()) <= words) {
-		m_wordWidths.resize(words+5);
-	    }
-	    ++ m_wordWidths.at(words);
-	    v3Global.needHInlines(true);
-	}
-    }
    virtual void visit(AstBasicDType* nodep) {
 	if (nodep->keyword() == AstBasicDTypeKwd::STRING) {
 	    v3Global.needHeavy(true);  // #include <string> via verilated_heavy.h when we create symbol file
@@ -94,33 +79,10 @@ void EmitCInlines::emitInt() {

    puts("\n//======================\n\n");

-    for (unsigned words=0; words<m_wordWidths.size(); words++) {
-	if (m_wordWidths.at(words)) {
-	    puts("#ifndef VL_HAVE_CONST_W_"+cvtToStr(words)+"X\n");
-	    puts("# define VL_HAVE_CONST_W_"+cvtToStr(words)+"X\n");
-	    puts("static inline WDataOutP VL_CONST_W_"+cvtToStr(words)+"X(int obits, WDataOutP o\n");
-	    puts("\t");
-	    for (int i=words-1; i>=0; --i) {
-		puts(",IData d"+cvtToStr(i));
-		if (i && (i % 8 == 0)) puts("\n\t");
-	    }
-	    puts(") {\n");
-	    puts("   ");
-	    for (int i=words-1; i>=0; --i) {
-		puts(" o["+cvtToStr(i)+"]=d"+cvtToStr(i)+";");
-		if (i && (i % 8 == 0)) puts("\n   ");
-	    }
-	    puts("\n");
-	    puts("    for(int i="+cvtToStr(words)+";i<VL_WORDS_I(obits);i++) o[i] = (IData)0x0;\n");
-	    puts("    return o;\n");
-	    puts("}\n");
-	    puts("#endif\n");
-	    puts("\n");
-	}
-    }
+    // Placeholder - v3Global.needHInlines(true) currently not used

    puts("//======================\n\n");
-    puts("#endif  /*guard*/\n");
+    puts("#endif // guard\n");
 }

 //######################################################################
@@ -112,8 +112,8 @@ class EmitCSyms : EmitCBaseVisitor {
 	// We didn'e have all m_scopes loaded when we encountered variables, so expand them now
 	// It would be less code if each module inserted its own variables.
 	// Someday.  For now public isn't common.
-	for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
-	    AstScope* scopep = it->first;  AstNodeModule* smodp = it->second;
+	for (vector<ScopeModPair>::iterator itsc = m_scopes.begin(); itsc != m_scopes.end(); ++itsc) {
+	    AstScope* scopep = itsc->first;  AstNodeModule* smodp = itsc->second;
 	    for (vector<ModVarPair>::iterator it = m_modVars.begin(); it != m_modVars.end(); ++it) {
 		AstNodeModule* modp = it->first;
 		AstVar* varp = it->second;
@@ -124,10 +124,10 @@ class EmitCSyms : EmitCBaseVisitor {
 		    string scpName;
 		    string varBase;
 		    if (whole.substr(0,10) == "__DOT__TOP") whole.replace(0,10,"");
-		    string::size_type pos = whole.rfind("__DOT__");
-		    if (pos != string::npos) {
-			scpName = whole.substr(0,pos);
-			varBase = whole.substr(pos+strlen("__DOT__"));
+		    string::size_type dpos = whole.rfind("__DOT__");
+		    if (dpos != string::npos) {
+			scpName = whole.substr(0,dpos);
+			varBase = whole.substr(dpos+strlen("__DOT__"));
 		    } else {
 			varBase = whole;
 		    }
@@ -238,7 +238,6 @@ class EmitCSyms : EmitCBaseVisitor {
    virtual void visit(AstConst*) {}
    // Default
    virtual void visit(AstNode* nodep) {
-	nameCheck(nodep);
 	nodep->iterateChildren(*this);
    }
    //---------------------------------------
@@ -270,12 +269,7 @@ void EmitCSyms::emitSymHdr() {
    puts("#define _"+symClassName()+"_H_\n");
    puts("\n");

-    if (optSystemPerl()) puts("#include \"systemperl.h\"\n");
-    else if (optSystemC()) puts("#include \"systemc.h\"\n");
-
-    if (optSystemPerl() || optSystemC()) {
-	puts("#include \"verilated_sc.h\"\n");
-    }
+    ofp()->putsIntTopInclude();
    if (v3Global.needHeavy()) {
 	puts("#include \"verilated_heavy.h\"\n");
    } else {
@@ -308,14 +302,12 @@ void EmitCSyms::emitSymHdr() {
    ofp()->putsPrivate(false);  // public:

    puts("\n// LOCAL STATE\n");
-    ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(vluint64_t));
    puts("const char* __Vm_namep;\n");	// Must be before subcells, as constructor order needed before _vlCoverInsert.
-    ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(bool));
-    puts("bool\t__Vm_activity;\t\t///< Used by trace routines to determine change occurred\n");
-    ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(bool));
-    puts("bool\t__Vm_didInit;\n");
+    if (v3Global.opt.trace()) {
+	puts("bool __Vm_activity;  ///< Used by trace routines to determine change occurred\n");
+    }
+    puts("bool __Vm_didInit;\n");

-    ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(vluint64_t));
    puts("\n// SUBCELL STATE\n");
    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
 	AstScope* scopep = it->first;  AstNodeModule* modp = it->second;
@@ -329,24 +321,31 @@ void EmitCSyms::emitSymHdr() {
 	}
    }

-    puts("\n// COVERAGE\n");
    if (m_coverBins) {
-	ofp()->putAlign(V3OutFile::AL_AUTO, sizeof(uint32_t));
-	puts("uint32_t\t__Vcoverage["); puts(cvtToStr(m_coverBins)); puts("];\n");
+	puts("\n// COVERAGE\n");
+	puts("uint32_t __Vcoverage["); puts(cvtToStr(m_coverBins)); puts("];\n");
    }

-    puts("\n// SCOPE NAMES\n");
-    for (ScopeNames::iterator it = m_scopeNames.begin(); it != m_scopeNames.end(); ++it) {
-	puts("VerilatedScope __Vscope_"+it->second.m_symName+";\n");
+    {  // Scope names
+	bool did = false;
+	for (ScopeNames::iterator it = m_scopeNames.begin(); it != m_scopeNames.end(); ++it) {
+	    if (!did) {
+	        did = true;
+	        puts("\n// SCOPE NAMES\n");
+	    }
+	    puts("VerilatedScope __Vscope_"+it->second.m_symName+";\n");
+	}
    }

    puts("\n// CREATORS\n");
    puts(symClassName()+"("+topClassName()+"* topp, const char* namep);\n");
-    puts((string)"~"+symClassName()+"() {};\n");
+    puts((string)"~"+symClassName()+"() {}\n");

    puts("\n// METHODS\n");
    puts("inline const char* name() { return __Vm_namep; }\n");
-    puts("inline bool getClearActivity() { bool r=__Vm_activity; __Vm_activity=false; return r;}\n");
+    if (v3Global.opt.trace()) {
+	puts("inline bool getClearActivity() { bool r=__Vm_activity; __Vm_activity=false; return r; }\n");
+    }
    if (v3Global.opt.savable() ) {
 	puts("void __Vserialize(VerilatedSerialize& os);\n");
 	puts("void __Vdeserialize(VerilatedDeserialize& os);\n");
@@ -354,7 +353,7 @@ void EmitCSyms::emitSymHdr() {
    puts("\n");
    puts("} VL_ATTR_ALIGNED(64);\n");
    puts("\n");
-    puts("#endif  /*guard*/\n");
+    puts("#endif // guard\n");
 }

 void EmitCSyms::emitSymImp() {
@@ -380,7 +379,9 @@ void EmitCSyms::emitSymImp() {
    puts(symClassName()+"::"+symClassName()+"("+topClassName()+"* topp, const char* namep)\n");
    puts("\t// Setup locals\n");
    puts("\t: __Vm_namep(namep)\n");	// No leak, as we get destroyed when the top is destroyed
-    puts("\t, __Vm_activity(false)\n");
+    if (v3Global.opt.trace()) {
+	puts("\t, __Vm_activity(false)\n");
+    }
    puts("\t, __Vm_didInit(false)\n");
    puts("\t// Setup submodule names\n");
    char comma=',';
@@ -431,11 +432,17 @@ void EmitCSyms::emitSymImp() {
 	}
    }

-    puts("// Setup scope names\n");
-    for (ScopeNames::iterator it = m_scopeNames.begin(); it != m_scopeNames.end(); ++it) {
-	puts("__Vscope_"+it->second.m_symName+".configure(this,name(),");
-	putsQuoted(it->second.m_prettyName);
-	puts(");\n");
+    {  // Setup scope names
+	bool did = false;
+	for (ScopeNames::iterator it = m_scopeNames.begin(); it != m_scopeNames.end(); ++it) {
+	    if (!did) {
+		did = true;
+		puts("// Setup scope names\n");
+	    }
+	    puts("__Vscope_"+it->second.m_symName+".configure(this,name(),");
+	    putsQuoted(it->second.m_prettyName);
+	    puts(");\n");
+	}
    }

    if (v3Global.dpi()) {
@@ -523,7 +530,9 @@ void EmitCSyms::emitSymImp() {
 	    puts("void "+symClassName()+"::"+funcname+"("+classname+"& os) {\n");
 	    puts(   "// LOCAL STATE\n");
 	    // __Vm_namep presumably already correct
-	    puts(   "os"+op+"__Vm_activity;\n");
+	    if (v3Global.opt.trace()) {
+		puts(   "os"+op+"__Vm_activity;\n");
+	    }
 	    puts(   "os"+op+"__Vm_didInit;\n");
 	    puts(   "// SUBCELL STATE\n");
 	    for (vector<ScopeModPair>::iterator it = m_scopes.begin(); it != m_scopes.end(); ++it) {
@@ -62,6 +62,8 @@ public:
 	of.puts("\n### Switches...\n");
 	of.puts("# Coverage output mode?  0/1 (from --coverage)\n");
 	of.puts("VM_COVERAGE = "); of.puts(v3Global.opt.coverage()?"1":"0"); of.puts("\n");
+	of.puts("# Threaded output mode?  0/1/N threads (from --threads)\n");
+	of.puts("VM_THREADS = "); of.puts(cvtToStr(v3Global.opt.threads())); of.puts("\n");
 	of.puts("# Tracing output mode?  0/1 (from --trace)\n");
 	of.puts("VM_TRACE = "); of.puts(v3Global.opt.trace()?"1":"0"); of.puts("\n");

@@ -90,15 +92,10 @@ public:
 		    if (v3Global.opt.coverage()) {
 			putMakeClassEntry(of, "verilated_cov.cpp");
 		    }
-		    if (v3Global.opt.systemPerl()) {
-			putMakeClassEntry(of, "Sp.cpp");  // Note Sp.cpp includes SpTraceVcdC
-		    }
-		    else {
-			if (v3Global.opt.trace()) {
-			    putMakeClassEntry(of, "verilated_vcd_c.cpp");
-			    if (v3Global.opt.systemC()) {
-				putMakeClassEntry(of, "verilated_vcd_sc.cpp");
-			    }
+		    if (v3Global.opt.trace()) {
+			putMakeClassEntry(of, "verilated_vcd_c.cpp");
+			if (v3Global.opt.systemC()) {
+			    putMakeClassEntry(of, "verilated_vcd_sc.cpp");
 			}
 		    }
 		}
@@ -106,7 +103,7 @@ public:
 		}
 		else {
 		    for (AstCFile* nodep = v3Global.rootp()->filesp(); nodep; nodep=nodep->nextp()->castCFile()) {
-			if (nodep->source() && nodep->slow()==slow && nodep->support()==support) {
+			if (nodep->source() && nodep->slow()==(slow!=0) && nodep->support()==(support!=0)) {
 			    putMakeClassEntry(of, nodep->name());
 			}
 		    }
@@ -139,22 +136,16 @@ public:
 	of.puts("PERL = "+V3Options::getenvPERL()+"\n");
 	of.puts("# Path to Verilator kit (from $VERILATOR_ROOT)\n");
 	of.puts("VERILATOR_ROOT = "+V3Options::getenvVERILATOR_ROOT()+"\n");
-	of.puts("# Path to SystemPerl kit top (from $SYSTEMPERL)\n");
-	of.puts("SYSTEMPERL = "+V3Options::getenvSYSTEMPERL()+"\n");
-	of.puts("# Path to SystemPerl kit includes (from $SYSTEMPERL_INCLUDE)\n");
-	of.puts("SYSTEMPERL_INCLUDE = "+V3Options::getenvSYSTEMPERL_INCLUDE()+"\n");
 	of.puts("# SystemC include directory with systemc.h (from $SYSTEMC_INCLUDE)\n");
 	of.puts(string("SYSTEMC_INCLUDE ?= ")+V3Options::getenvSYSTEMC_INCLUDE()+"\n");
 	of.puts("# SystemC library directory with libsystemc.a (from $SYSTEMC_LIBDIR)\n");
 	of.puts(string("SYSTEMC_LIBDIR ?= ")+V3Options::getenvSYSTEMC_LIBDIR()+"\n");

 	of.puts("\n### Switches...\n");
-	of.puts("# SystemPerl output mode?  0/1 (from --sp)\n");
-	of.puts(string("VM_SP = ")+(v3Global.opt.systemPerl()?"1":"0")+"\n");
 	of.puts("# SystemC output mode?  0/1 (from --sc)\n");
-	of.puts(string("VM_SC = ")+((v3Global.opt.systemC()&&!v3Global.opt.systemPerl())?"1":"0")+"\n");
-	of.puts("# SystemPerl or SystemC output mode?  0/1 (from --sp/--sc)\n");
-	of.puts(string("VM_SP_OR_SC = ")+(v3Global.opt.systemC()?"1":"0")+"\n");
+	of.puts(string("VM_SC = ")+((v3Global.opt.systemC())?"1":"0")+"\n");
+	of.puts("# Legacy or SystemC output mode?  0/1 (from --sc)\n");
+	of.puts(string("VM_SP_OR_SC = $(VM_SC)\n"));
 	of.puts("# Deprecated\n");
 	of.puts(string("VM_PCLI = ")+(v3Global.opt.systemC()?"0":"1")+"\n");
 	of.puts("# Deprecated: SystemC architecture to find link library path (from $SYSTEMC_ARCH)\n");
@@ -168,16 +159,16 @@ public:

 	of.puts("# User CFLAGS (from -CFLAGS on Verilator command line)\n");
 	of.puts("VM_USER_CFLAGS = \\\n");
-	const V3StringSet& cFlags = v3Global.opt.cFlags();
-	for (V3StringSet::const_iterator it = cFlags.begin(); it != cFlags.end(); ++it) {
+	const V3StringList& cFlags = v3Global.opt.cFlags();
+	for (V3StringList::const_iterator it = cFlags.begin(); it != cFlags.end(); ++it) {
 	    of.puts("\t"+*it+" \\\n");
 	}
 	of.puts("\n");

 	of.puts("# User LDLIBS (from -LDFLAGS on Verilator command line)\n");
 	of.puts("VM_USER_LDLIBS = \\\n");
-	const V3StringSet& ldLibs = v3Global.opt.ldLibs();
-	for (V3StringSet::const_iterator it = ldLibs.begin(); it != ldLibs.end(); ++it) {
+	const V3StringList& ldLibs = v3Global.opt.ldLibs();
+	for (V3StringList::const_iterator it = ldLibs.begin(); it != ldLibs.end(); ++it) {
 	    of.puts("\t"+*it+" \\\n");
 	}
 	of.puts("\n");
@@ -238,10 +238,6 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
    virtual void visit(AstSFormatF* nodep) {
 	visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
    }
-    virtual void visit(AstValuePlusArgs* nodep) {
-	visitNodeDisplay(nodep, NULL, nodep->text(), nodep->exprsp());
-    }
-
    virtual void visit(AstFOpen* nodep) {
 	putfs(nodep,nodep->verilogKwd());
 	putbs(" (");
@@ -497,6 +493,10 @@ class EmitVBaseVisitor : public EmitCBaseVisitor {
 	}
 	puts("]");
    }
+    virtual void visit(AstSliceSel* nodep) {
+        nodep->fromp()->iterateAndNext(*this);
+        puts(cvtToStr(nodep->declRange()));
+    }
    virtual void visit(AstTypedef* nodep) {
 	putfs(nodep,"typedef ");
 	nodep->dtypep()->iterateAndNext(*this); puts(" ");
@@ -37,8 +37,13 @@
 // Emit statements and math operators

 class EmitXmlFileVisitor : public AstNVisitor {
+    // NODE STATE
+    //Entire netlist:
+    // AstNode::user1           -> uint64_t, number to connect crossrefs
+
    // MEMBERS
    V3OutFile*	m_ofp;
+    uint64_t	m_id;

    // METHODS
    static int debug() {
@@ -64,10 +69,21 @@ class EmitXmlFileVisitor : public AstNVisitor {
    }

    // XML methods
+    void outputId(AstNode* nodep) {
+	if (!nodep->user1()) { nodep->user1(++m_id); }
+	puts("\""+cvtToStr(nodep->user1())+"\"");
+    }
    void outputTag(AstNode* nodep, string tag) {
 	if (tag=="") tag = VString::downcase(nodep->typeName());
 	puts("<"+tag+" "+nodep->fileline()->xml());
+	if (nodep->castNodeDType()) { puts(" id="); outputId(nodep); }
 	if (nodep->name()!="") { puts(" name="); putsQuoted(nodep->prettyName()); }
+	if (nodep->tag()!="") { puts(" tag="); putsQuoted(nodep->tag()); }
+	if (AstNodeDType* dtp = nodep->castNodeDType()) {
+	    if (dtp->subDTypep()) { puts(" sub_dtype_id="); outputId(dtp->subDTypep()->skipRefp()); }
+	} else {
+	    if (nodep->dtypep()) { puts(" dtype_id="); outputId(nodep->dtypep()->skipRefp()); }
+	}
    }
    void outputChildrenEnd(AstNode* nodep, string tag) {
 	if (tag=="") tag = VString::downcase(nodep->typeName());
@@ -110,13 +126,13 @@ class EmitXmlFileVisitor : public AstNVisitor {
 	outputChildrenEnd(nodep, "port");
    }
    virtual void visit(AstAssignW* nodep) {
-	outputTag(nodep, "contAssign");	// IEEE: vpiContAssign
-	outputChildrenEnd(nodep, "contAssign");
+	outputTag(nodep, "contassign");	// IEEE: vpiContAssign
+	outputChildrenEnd(nodep, "contassign");
    }

    // Data types
    virtual void visit(AstBasicDType* nodep) {
-	outputTag(nodep, "basicDType ");
+	outputTag(nodep, "basicdtype ");
 	if (nodep->isRanged()) {
 	    puts(" left=\""+cvtToStr(nodep->left())+"\"");
 	    puts(" right=\""+cvtToStr(nodep->right())+"\"");
@@ -132,50 +148,12 @@ class EmitXmlFileVisitor : public AstNVisitor {
 public:
    EmitXmlFileVisitor(AstNode* nodep, V3OutFile* ofp) {
 	m_ofp = ofp;
+	m_id = 0;
 	nodep->accept(*this);
    }
    virtual ~EmitXmlFileVisitor() {}
 };

-//######################################################################
-// Emit to a stream (perhaps stringstream)
-
-class EmitXmlPrefixedFormatter : public V3OutFormatter {
-    ostream&	m_os;
-    string	m_prefix;	// What to print at beginning of each line
-    int		m_flWidth;	// Padding of fileline
-    int		m_column;	// Rough location; need just zero or non-zero
-    FileLine*	m_prefixFl;
-    // METHODS
-    virtual void putcOutput(char chr) {
-	if (chr == '\n') {
-	    m_column = 0;
-	    m_os<<chr;
-	} else {
-	    if (m_column == 0) {
-		m_column = 10;
-		m_os<<m_prefixFl->ascii()+":";
-		m_os<<V3OutFile::indentSpaces(m_flWidth-(m_prefixFl->ascii().length()+1));
-		m_os<<" ";
-		m_os<<m_prefix;
-	    }
-	    m_column++;
-	    m_os<<chr;
-	}
-    }
-public:
-    void prefixFl(FileLine* fl) { m_prefixFl = fl; }
-    FileLine* prefixFl() const { return m_prefixFl; }
-    int column() const { return m_column; }
-    EmitXmlPrefixedFormatter(ostream& os, const string& prefix, int flWidth)
-	: V3OutFormatter("__STREAM", V3OutFormatter::LA_VERILOG)
-	, m_os(os), m_prefix(prefix), m_flWidth(flWidth) {
-	m_column = 0;
-	m_prefixFl = v3Global.rootp()->fileline();  // NETLIST's fileline instead of NULL to avoid NULL checks
-    }
-    virtual ~EmitXmlPrefixedFormatter() {}
-};
-
 //######################################################################
 // EmitXml class functions

@@ -85,7 +85,7 @@ string V3Error::lineStr (const char* filename, int lineno) {
    const char* fnslashp = strrchr (filename, '/');
    if (fnslashp) filename = fnslashp+1;
    out<<filename<<":"<<dec<<lineno<<":";
-    const char* spaces = "                    ";
+    const char* const spaces = "                    ";
    size_t numsp = out.str().length(); if (numsp>20) numsp = 20;
    out<<(spaces + numsp);
    return out.str();
@@ -29,6 +29,7 @@
 #include <map>
 #include <set>
 #include <deque>
+#include <cassert>

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

@@ -47,7 +48,6 @@ public:
 	I_LINT,		// All lint messages
 	I_DEF_NETTYPE_WIRE,  // `default_nettype is WIRE (false=NONE)
 	// Error codes:
-	E_BLKLOOPINIT,	// Error: Delayed assignment to array inside for loops
 	E_DETECTARRAY,	// Error: Unsupported: Can't detect changes on arrayed variable
 	E_MULTITOP,	// Error: Multiple top level modules
 	E_TASKNSVAR,	// Error: Task I/O not simple
@@ -59,7 +59,9 @@ public:
 	ASSIGNDLY,	// Assignment delays
 	ASSIGNIN,	// Assigning to input
 	BLKANDNBLK,	// Blocked and non-blocking assignments to same variable
+	BLKLOOPINIT,	// Delayed assignment to array inside for loops
 	BLKSEQ,		// Blocking assignments in sequential block
+	BSSPACE,	// Backslash space
 	CASEINCOMPLETE,	// Case statement has missing values
 	CASEOVERLAP,	// Case statements overlap
 	CASEWITHX,	// Case with X values
@@ -67,6 +69,7 @@ public:
 	CDCRSTLOGIC,	// Logic in async reset path
 	CLKDATA,        // Clock used as data
 	CMPCONST,	// Comparison is constant due to limited range
+	COLONPLUS,	// :+ instead of +:
 	COMBDLY,	// Combinatorial delayed assignment
 	DEFPARAM,	// Style: Defparam
 	DECLFILENAME,	// Declaration doesn't match filename
@@ -120,13 +123,13 @@ public:
 	    // Boolean
 	    " I_COVERAGE", " I_TRACING", " I_LINT", " I_DEF_NETTYPE_WIRE",
 	    // Errors
-	    "BLKLOOPINIT", "DETECTARRAY", "MULTITOP", "TASKNSVAR",
+	    "DETECTARRAY", "MULTITOP", "TASKNSVAR",
 	    // Warnings
 	    " EC_FIRST_WARN",
 	    "ALWCOMBORDER", "ASSIGNDLY", "ASSIGNIN",
-	    "BLKANDNBLK", "BLKSEQ",
+	    "BLKANDNBLK", "BLKLOOPINIT", "BLKSEQ", "BSSPACE",
 	    "CASEINCOMPLETE", "CASEOVERLAP", "CASEWITHX", "CASEX", "CDCRSTLOGIC", "CLKDATA",
-	    "CMPCONST", "COMBDLY", "DEFPARAM", "DECLFILENAME",
+	    "CMPCONST", "COLONPLUS", "COMBDLY", "DEFPARAM", "DECLFILENAME",
 	    "ENDLABEL", "GENCLK",
 	    "IFDEPTH", "IMPERFECTSCH", "IMPLICIT", "IMPURE",
 	    "INCABSPATH", "INITIALDLY",
@@ -149,6 +152,7 @@ public:
    // Warnings we'll present to the user as errors
    // Later -Werror- options may make more of these.
    bool pretendError() const { return ( m_e==ASSIGNIN || m_e==BLKANDNBLK
+					 || m_e==BLKLOOPINIT
 					 || m_e==IMPURE || m_e==MODDUP); }
    // Warnings to mention manual
    bool mentionManual() const { return ( m_e==EC_FATALSRC || m_e==SYMRSVDWORD
@@ -156,9 +160,11 @@ public:

    // Warnings that are lint only
    bool lintError() const { return ( m_e==ALWCOMBORDER
+				      || m_e==BSSPACE
 				      || m_e==CASEINCOMPLETE || m_e==CASEOVERLAP
 				      || m_e==CASEWITHX || m_e==CASEX
 				      || m_e==CMPCONST
+				      || m_e==COLONPLUS
 				      || m_e==ENDLABEL
 				      || m_e==IMPLICIT
 				      || m_e==LITENDIAN
@@ -213,7 +219,7 @@ class V3Error {
    V3Error() { cerr<<("Static class"); abort(); }

  public:
-    // CREATORS
+    // CONSTRUCTORS
    // ACCESSORS
    static void		debugDefault(int level) { s_debugDefault = level; }
    static int		debugDefault() { return s_debugDefault; }
@@ -253,23 +259,30 @@ class V3Error {
 // Global versions, so that if the class doesn't define a operator, we get the functions anyways.
 inline int debug() { return V3Error::debugDefault(); }
 inline void v3errorEnd(ostringstream& sstr) { V3Error::v3errorEnd(sstr); }
+inline void v3errorEndFatal(ostringstream& sstr) { V3Error::v3errorEnd(sstr); assert(0); VL_UNREACHABLE }

 // Theses allow errors using << operators: v3error("foo"<<"bar");
 // Careful, you can't put () around msg, as you would in most macro definitions
 // Note the commas are the comma operator, not separating arguments. These are needed to insure
 // evaluation order as otherwise we couldn't insure v3errorPrep is called first.
 #define v3warnCode(code,msg) v3errorEnd((V3Error::v3errorPrep(code), (V3Error::v3errorStr()<<msg), V3Error::v3errorStr()));
-#define v3warn(code,msg) v3warnCode(V3ErrorCode::code,msg)
-#define v3info(msg)  v3warn(EC_INFO,msg)
-#define v3fatal(msg) v3warn(EC_FATAL,msg)
-#define v3error(msg) v3warn(EC_ERROR,msg)
+#define v3warnCodeFatal(code,msg) v3errorEndFatal((V3Error::v3errorPrep(code), (V3Error::v3errorStr()<<msg), V3Error::v3errorStr()));
+#define v3warn(code,msg) v3warnCode(V3ErrorCode::code, msg)
+#define v3info(msg)  v3warnCode(V3ErrorCode::EC_INFO, msg)
+#define v3error(msg) v3warnCode(V3ErrorCode::EC_ERROR, msg)
+#define v3fatal(msg) v3warnCodeFatal(V3ErrorCode::EC_FATAL, msg)
 // Use this instead of fatal() to mention the source code line.
-#define v3fatalSrc(msg) v3warn(EC_FATALSRC,__FILE__<<":"<<dec<<__LINE__<<": "<<msg)
+#define v3fatalSrc(msg) v3warnCodeFatal(V3ErrorCode::EC_FATALSRC, __FILE__<<":"<<dec<<__LINE__<<": "<<msg)

 #define UINFO(level,stmsg) {if(VL_UNLIKELY(debug()>=(level))) { cout<<"- "<<V3Error::lineStr(__FILE__,__LINE__)<<stmsg; }}
 #define UINFONL(level,stmsg) {if(VL_UNLIKELY(debug()>=(level))) { cout<<stmsg; } }

-#define UDEBUGONLY(stmts) {stmts}
+#ifdef VL_DEBUG
+# define UDEBUGONLY(stmts) {stmts}
+#else
+# define UDEBUGONLY(stmts) {if (0) {stmts}}
+#endif
+
 #define UASSERT(condition,stmsg) { if (VL_UNLIKELY(!(condition))) { v3fatalSrc(stmsg); }}
 // For use in V3Ast static functions only
 #define UASSERT_STATIC(condition,stmsg) { if (VL_UNLIKELY(!(condition))) { cerr<<"Internal Error: "<<__FILE__<<":"<<dec<<__LINE__<<":"<<(stmsg)<<endl; abort(); } }
--- a/Show More
+++ b/Show More