Version bump

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

.gitignore

@@ -23,3 +23,5 @@ gdbrun*
 internals.txt
 verilator.txt
 verilator_bin*
+verilator_coverage_bin*
+verilator.pc

Changes

@@ -3,6 +3,495 @@ Revision history for Verilator
 The contributors that suggested a given feature are shown in [].  [by ...]
 indicates the contributor was also the author of the fix; Thanks!
 
+* Verilator 3.878 2015-11-01
+
+**    Add --vpi flag, and fix VPI linkage, bug969. [Arthur Kahlich]
+
+**    Support genvar indexes into arrayed cells, bug517.  [Todd Strader]
+
+**    Support $sformatf, bug977. [Johan Bjork]
+
+***   Support elaboration assertions, bug973. [Johan Bjork]
+
+***   Support $display with non-format arguments, bug467. [Jamey Hicks]
+
+****  Add VerilatedScopeNameMap for introspection, bug966. [Todd Strader]
+
+****  Ignore %l in $display, bug983. [Todd Strader]
+
+****  Fix very long module names, bug937. [Todd Strader]
+
+****  Fix internal error on dotted refs into generates, bug958. [Jie Xu]
+
+****  Fix structure parameter constant propagation, bug968. [Todd Strader]
+
+****  Fix enum constant propagation, bug970. [Todd Strader]
+
+****  Fix mis-optimizing public DPI functions, bug963. [Wei Song]
+
+****  Fix package:scope.scope variable references.
+
+****  Fix $fwrite to constant stderr/stdout, bug961. [Wei Song]
+
+****  Fix struct.enum.name method calls, bug855. [Jonathon Donaldson]
+
+****  Fix dot indexing into arrayed inferfaces, bug978.  [Johan Bjork]
+
+****  Fix crash in commandArgsPlusMatch, bug987. [Jamie Iles]
+
+****  Fix error message on missing interface, bug985. [Todd Strader]
+
+
+* Verilator 3.876 2015-08-12
+
+***   Add tracing_on, etc to vlt files, bug932. [Frederic Requin]
+
+****  Support extraction of enum bits, bug951. [Jonathon Donaldson]
+
+****  Fix MinGW compiler error, bug927, bug929. [Hans Tichelaar]
+
+****  Fix .c files to be treated as .cpp, bug930. [Jonathon Donaldson]
+
+****  Fix string-to-int space conversion, bug931. [Fabrizio Ferrandi]
+
+****  Fix dpi imports inside generates. [Michael Tresidder]
+
+****  Fix rounding in trace $timescale, bug946. [Frederic Requin]
+
+****  Fix $fopen with SV string, bug947. [Sven Stucki]
+
+****  Fix hashed error with typedef inside block, bug948. [Sven Stucki]
+
+****  Fix makefile with --coverage, bug953. [Eivind Liland]
+
+****  Fix coverage documentation, bug954. [Thomas J Whatson]
+
+****  Fix parameters with function parameter arguments, bug952. [Jie Xu]
+
+****  Fix size casts as second argument of cast item, bug950. [Jonathon Donaldson]
+
+
+* Verilator 3.874 2015-06-06
+
+***   Add pkg-config .pc file, bug919. [Stefan Wallentowitz]
+
+****  Fix installing missing manpages, bug908. [Ahmed El-Mahmoudy]
+
+****  Fix sign extension in large localparams, bug910. [Mike Thyer]
+
+****  Fix core dump in sync-async warnings, bug911. [Sebastian Dressler]
+
+****  Fix truncation warning with -pins-bv, bug912. [Alfonso Martinez]
+
+****  Fix Cygwin uint32 compile, bug914. [Matthew Barr]
+
+****  Fix preprocessing stringified newline escapes, bug915. [Anton Rapp]
+
+****  Fix part-select in constant function, bug916. [Andrew Bardsley]
+
+****  Fix width extension on mis-width ports, bug918. [Patrick Maupin]
+
+****  Fix width propagation on sized casts, bug925. [Jonathon Donaldson]
+
+****  Fix MSVC++ compiler error, bug927. [Hans Tichelaar]
+
+
+* Verilator 3.872 2015-04-05
+
+***   Add VerilatedVcdFile to allow real-time waveforms, bug890. [HyungKi Jeong]
+
+***   Add --clk and related optimizations, msg1533. [Jie Xu]
+
+***   Fix order of C style arrays. [Duraid Madina]
+
+****  Add --dump-treei-<srcfile>, bug894. [Jie Xu]
+
+****  Fix comma-instantiations with parameters, bug884. [Franck Jullien]
+
+****  Fix SystemC arrayed bit vectors, bug886. [David Poole]
+
+****  Fix compile error on MinGW, bug887. [HyungKi Jeong]
+
+
+* Verilator 3.870 2015-02-12
+
+****  Suppress COMBDLY when inside always_latch, bug864. [Iztok Jeras]
+
+****  Support cast operator with expression size, bug865. [Iztok Jeras]
+
+****  Add warning on slice selection out of bounds, bug875. [Cong Van Nguyen].
+
+****  Fix member select error broke in 3.868, bug867. [Iztok Jeras]
+
+****  Fix $sccanf from string, bug866. [David Pierce]
+
+****  Fix VM_PARALLEL_BUILDS broke in 3.868, bug870. [Hiroki Honda]
+
+****  Fix non-ANSI modport instantiations, bug868. [Kevin Thompson]
+
+****  Fix UNOPTFLAT change detect on multidim arrays, bug872. [Andrew Bardsley]
+
+****  Fix slice connections of arrays to ports, bug880. [Varun Koyyalagunta]
+
+****  Fix mis-optimizing gate assignments in unopt blocks, bug881. [Mike Thyer]
+
+****  Fix sign extension of pattern members, bug882. [Iztok Jeras]
+
+****  Fix clang compile warnings.
+
+
+* Verilator 3.868 2014-12-20
+
+**    New verilator_coverage program added to replace SystemPerl's vcoverage.
+
+**    PSL support was removed, please use System Verilog assertions.
+
+**    SystemPerl mode is deprecated and now untested.
+
+***   Support enum.first/name and similar methods, bug460, bug848.
+
+***   Add 'string' printing and comparisons, bug746, bug747, etc.
+
+***   Inline C functions that are used only once, msg1525. [Jie Xu]
+
+***   Fix tracing SystemC signals with structures, bug858. [Eivind Liland]
+      Note that SystemC traces will no longer show the signals
+      in the wrapper, they can be seen one level further down.
+
+****  Add --stats-vars, bug851. [Jeremy Bennett]
+
+****  Fix bare generates in interfaces, bug789. [Bob Newgard]
+
+****  Fix underscores in real literals, bug863. [Jonathon Donaldson]
+
+
+* Verilator 3.866 2014-11-15
+
+***   Fix +define+A+B to define A and B to match other simulators, bug847. [Adam Krolnik]
+
+***   Add optimization of wires from arrayed cells, msg1447. [Jie Xu]
+
+***   Add optimization of operators between concats, msg1447. [Jie Xu]
+
+***   Add public enums, bug833. [Jonathon Donaldson]
+
+***   Trace_off now operates on cells, bug826. [Lane Brooks]
+
+****  Fix public parameters in unused packages, bug804. [Jonathon Donaldson]
+
+****  Fix select when partially out-of-bound, bug823. [Cliffort Wolf]
+
+****  Fix generate unrolling with function call, bug830. [Steven Slatter]
+
+****  Fix cast-to-size context-determined sizing, bug828. [Geoff Barrett]
+
+****  Fix not tracing modules following primitives, bug837. [Jie Xu]
+
+****  Fix trace overflow on huge arrays, bug834. [Geoff Barrett]
+
+****  Fix quoted comment slashes in defines, bug845. [Adam Krolnik]
+
+
+* Verilator 3.864 2014-09-21
+
+***   Support power operator with real, bug809. [Jonathon Donaldson]
+
+****  Improve verilator_profcfunc time attributions. [Jonathon Donaldson]
+
+****  Fix duplicate anonymous structures in $root, bug788. [Bob Newgard]
+
+****  Fix mis-optimization of bit-swap in wide signal, bug800. [Jie Xu]
+
+****  Fix error when tracing public parameters, bug722. [Jonathon Donaldson]
+
+****  Fix dpiGetContext in dotted scopes, bug740. [Geoff Barrett]
+
+****  Fix over-shift structure optimization error, bug803. [Jeff Bush]
+
+****  Fix optional parameter keyword in module #(), bug810. [Iztok Jeras]
+
+****  Fix $warning/$error multi-argument ordering, bug816. [Jonathon Donaldson]
+
+****  Fix clang warnings, bug818. [Iztok Jeras]
+
+****  Fix string formats under deep expressions, bug820. [Iztok Jeras]
+
+
+* Verilator 3.862 2014-06-10
+
+***   Using command line -Wno-{WARNING} now overrides file-local lint_on.
+
+***   Add -P to suppress `line and blanks with preprocessing, bug781. [Derek Lockhart]
+
+***   Support SV 2012 package import before port list.
+
+****  Change SYMRSVDWORD to print as warning rather than error.
+
+****  Fix seg-fault with variable of parameterized interface, bug692. [Jie Xu]
+
+****  Fix false name conflict on cells in generate blocks, bug749. [Igor Lesik]
+
+****  Fix pattern assignment to basic types, bug767. [Jie Xu]
+
+****  Fix pattern assignment to conditionals, bug769. [Jie Xu]
+
+****  Fix shift corner-cases, bug765, bug766, bug768, bug772, bug774, bug776. [Clifford Wolf]
+
+****  Fix C compiler interpreting signing, bug773. [Clifford Wolf]
+
+****  Fix late constant division by zero giving X error, bug775. [Clifford Wolf]
+
+****  Fix gate primitives with arrays and non-arrayed pins.
+
+****  Fix DETECTARRAY error on packed arrays, bug770. [Jie Xu]
+
+****  Fix ENDLABEL warnings on escaped identifiers.
+
+****  Fix string corruption, bug780. [Derek Lockhart]
+
+
+* Verilator 3.860 2014-05-11
+
+**    PSL is no longer supported, please use System Verilog assertions.
+
+**    Support '{} assignment pattern on arrays, bug355.
+
+**    Support streaming operators, bug649. [Glen Gibb]
+
+**    Fix expression problems with -Wno-WIDTH, bug729, bug736, bug737, bug759.
+      Where WIDTH warnings were ignored this might result in different
+      warning messages and results, though it should better match the spec.
+      [Clifford Wolf]
+
+***   Add --no-trace-params.
+
+***   Add assertions on 'unique if', bug725. [Jeff Bush]
+
+***   Add PINCONNECTEMPTY warning. [Holger Waechtler]
+
+***   Support parameter arrays, bug683. [Jeremy Bennett]
+
+***   Fix begin_keywords "1800+VAMS", msg1211.
+
+****  Documentation fixes, bug723. [Glen Gibb]
+
+****  Support {} in always sensitivity lists, bug745. [Igor Lesik]
+
+****  Fix tracing of package variables and real arrays.
+
+****  Fix tracing of packed arrays without --trace-structs, bug742. [Jie Xu]
+
+****  Fix missing coverage line on else-if, bug727. [Sharad Bagri]
+
+****  Fix modport function import not-found error.
+
+****  Fix power operator calculation, bug730, bug735. [Clifford Wolf]
+
+****  Fix reporting struct members as reserved words, bug741. [Chris Randall]
+
+****  Fix change detection error on unions, bug758. [Jie Xu]
+
+****  Fix -Wno-UNOPTFLAT change detection with 64-bits, bug762. [Clifford Wolf]
+
+****  Fix shift-right optimization, bug763. [Clifford Wolf]
+
+****  Fix Mac OS-X test issues. [Holger Waechtler]
+
+****  Fix C++-2011 warnings.
+
+
+* Verilator 3.856 2014-03-11
+
+***   Support case inside, bug708. [Jan Egil Ruud]
+
+***   Add parameters into trace files, bug706. [Alex Solomatnikov]
+
+****  Fix parsing "#0 'b0", bug256.
+
+****  Fix array bound checks on real variables.
+
+****  Fix --skip-identical mis-detecting on OS-X, bug707.
+
+****  Fix missing VL_SHIFTRS_IQI with WIDTH warning, bug714. [Fabrizio Ferrandi]
+
+****  Fix signed shift right optimization, bug715. [Fabrizio Ferrandi]
+
+****  Fix internal error on "input x =" syntax error, bug716. [Lane Brooks]
+
+****  Fix slice extraction from packed array, bug717. [Jan Egil Ruud]
+
+****  Fix inside statement EQWILD error, bug718. [Jan Egil Ruud]
+
+
+* Verilator 3.855 2014-01-18
+
+***   Support modport import, bug696. [Jeremy Bennett]
+
+***   Add --trace-structs to show struct names, bug673. [Chris Randall]
+
+****  Fix tracing of packed structs, bug705. [Jie Xu]
+
+****  Fix --lint-only with MinGW, msg1283. [HyungKi Jeong]
+
+****  Fix some delayed assignments of typedefed unpacked arrays.
+
+****  Fix wire declarations with size and not range, bug466. [Alex Solomatnikov]
+
+****  Fix parameter pin vs. normal pin error, bug704. [Alex Solomatnikov]
+
+
+* Verilator 3.854 2013-11-26
+
+***   Add UNPACKED warning to convert unpacked structs. [Jeremy Bennett]
+
+***   Add --compiler clang to work around compiler bug, bug694. [Stefan Ludwig]
+
+****  Support vpi_get of vpiSuppressVal, bug687. [Varun Koyyalagunta]
+
+****  Support vpi_get_time, bug688. [Varun Koyyalagunta]
+
+****  Fix evaluation of chained parameter functions, bug684. [Ted Campbell]
+
+****  Fix enum value extension of '1.
+
+****  Fix multiple VPI variable callbacks, bug679. [Rich Porter]
+
+****  Fix vpi_get of vpiSize, bug680. [Rich Porter]
+
+****  Fix vpi_remove_cb inside callback, bug689. [Varun Koyyalagunta]
+
+****  Fix crash with coverage of structures, bug691. [Eivind Liland]
+
+****  Fix array assignment from const var, bug693. [Jie Xu]
+
+
+* Verilator 3.853 2013-09-30
+
+****  Add --no-order-clock-delay to work around bug613. [Charlie Brej]
+
+
+* Verilator 3.852 2013-09-29
+
+***   Support named function and task arguments. [Chris Randall]
+
+***   Report SELRANGE warning for non-generate if, bug675. [Roland Kruse]
+
+****  Fix ordering of $fgetc, msg1229. [Frederic Requin]
+
+****  Fix --output-split-cfunc to count internal functions. [Chris Randall]
+
+****  Fix crash on 32-bit Ubuntu, bug670. [Mark Jackson Pulver]
+
+
+* Verilator 3.851 2013-08-15
+
+***   Fix ordering of clock enables with delayed assigns, bug613. [Jeremy Bennett]
+
+***   Fix vpi_iterate on memory words, bug655. [Rich Porter]
+
+****  Fix final duplicate declarations when non-inlined, bug661. [Charlie Brej]
+
+****  Fix interface ports with comma lists, msg1058. [Ed Lander]
+
+****  Fix parameter real conversion from integer.
+
+****  Fix clang warnings, bug668.  [Yutetsu Takatsukasa]
+
+
+* Verilator 3.850 2013-06-02
+
+**    Support interfaces and modports, bug102.  [Byron Bradley, Jeremy Bennett]
+
+***   Duplicate clock gate optimization on by default, bug621.
+
+****  Fix arrayed input compile error, bug645. [Krzysztof Jankowski]
+
+****  Fix GCC version runtime changes, bug651. [Jeremy Bennett]
+
+****  Fix packed array select internal error, bug652. [Krzysztof Jankowski]
+
+
+* Verilator 3.847 2013-05-11
+
+***   Add ALWCOMBORDER warning.  [KC Buckenmaier]
+
+***   Add --pins-sc-uint and --pins-sc-biguint, bug638. [Alex Hornung]
+
+****  Support "signal[vec]++".
+
+****  Fix simulation error when inputs and MULTIDRIVEN, bug634. [Ted Campbell]
+
+****  Fix module resolution with __, bug631. [Jason McMullan]
+
+****  Fix packed array non-zero right index select crash, bug642. [Krzysztof Jankowski]
+
+****  Fix nested union crash, bug643. [Krzysztof Jankowski]
+
+
+* Verilator 3.846 2013-03-09
+
+**    IEEE 1800-2012 is now the default language.  This adds 4 new keywords
+      and updates the svdpi.h and vpi_user.h header files.
+
+***   Add --report-unoptflat, bug611. [Jeremy Bennett]
+
+***   Add duplicate clock gate optimization, msg980. [Varun Koyyalagunta]
+      Disabled unless -OD or -O3 used, please try it as may get some
+      significant speedups.
+
+***   Fix wrong dot resolution under inlining. [Art Stamness]
+
+****  Support pattern assignment features, bug616, bug617, bug618. [Ed Lander]
+
+****  Support bind in $unit, bug602. [Ed Lander]
+
+****  Support <number>'() sized casts, bug628. [Ed Lander]
+
+****  Fix DETECTARRAY on packed structures, bug610. [Jeremy Bennett]
+
+****  Fix LITENDIAN on unpacked structures, bug614. [Wai Sum Mong]
+
+****  Fix 32-bit OS VPI scan issue, bug615.  [Jeremy Bennett, Rich Porter]
+
+****  Fix opening a VerilatedVcdC file multiple times, msg1021. [Frederic Requin]
+
+****  Fix UNOPTFLAT circular array bounds crossing, bug630. [Jie Xu]
+
+
+* Verilator 3.845 2013/02/04
+
+***   Fix nested packed arrays and struct, bug600. [Jeremy Bennett]
+      Packed arrays are now represented as a single linear vector in
+      Verilated models.  This may affect packed arrays that are public or
+      accessed via the VPI.
+
+***   Support wires with data types, bug608. [Ed Lander]
+
+***   Support bind, to module names only, bug602. [Ed Lander]
+
+***   Support VPI product info, warning calls, etc, bug588. [Rick Porter]
+
+***   Support $left, $right and related functions, bug448. [Iztok Jeras]
+
+***   Support inside expressions.
+
+***   Define SYSTEMVERILOG, SV_COV_START and other IEEE mandated predefines.
+
+****  Fix pin width mismatch error, bug595.  [Alex Solomatnikov]
+
+****  Fix implicit one bit parameter selection, bug603.  [Jeremy Bennett]
+
+****  Fix signed/unsigned parameter misconversion, bug606.  [Jeremy Bennett]
+
+****  Fix segfault on multidimensional dotted arrays, bug607.  [Jie Xu]
+
+****  Fix per-bit array output connection error, bug414.  [Jan Egil Ruud]
+
+****  Fix package logic var compile error.
+
+****  Fix enums with X values.
+
+
 * Verilator 3.844 2013/01/09
 
 ***   Support "unsigned int" DPI import functions, msg966.  [Alex Lee]
@@ -13,7 +502,7 @@ indicates the contributor was also the author of the fix; Thanks!
 
 ****  Fix task inlining under $display and case, bug589, bug598.  [Holger Waechtler]
 
-****  Fix package import of non-localparam parameter, bug591.  [Jeremy Bennett]
+****  Fix package import of non-localparam parameter, bug474, bug591.  [Jeremy Bennett]
 
 ****  Fix package import of package imports, partial bug592.  [Jeremy Bennett]
 
@@ -251,7 +740,7 @@ indicates the contributor was also the author of the fix; Thanks!
 ***  Support $fopen and I/O with integer instead of `verilator_file_descriptor.
 
 ***  Support coverage in -cc and -sc output modes.  [John Li]
-     Note this requires SystemPerl 1.338 or newer.	
+     Note this requires SystemPerl 1.338 or newer.
 
 **** Fix vpi_register_cb using bad s_cb_data, bug370.  [by Thomas Watts]
 
@@ -2151,7 +2640,7 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs.  See C-h m [M-x describe-mode].
 
-Copyright 2001-2013 by Wilson Snyder.  This program is free software; you
+Copyright 2001-2015 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.

MANIFEST.SKIP

@@ -1,6 +1,5 @@
 ^CVS/
 /CVS/
-\.gdbinit$
 \.git/
 \.svn/
 \.(bak|old)/
@@ -13,6 +12,7 @@
 .*\.tex
 .*\.key
 .*\.vcd
+.*\.1
 /obj_dir/
 /obj_dbg/
 /obj_opt/
@@ -23,11 +23,14 @@
 src/Makefile$
 src/Makefile_obj$
 include/verilated.mk$
+test_regress/.gdbinit$
 config.cache$
 config.status$
 verilator.log
 verilator.tex
+verilator.pc$
 verilator_bin.*
+verilator_coverage_bin.*
 .vcsmx_rebuild$
 autom4te\.cache/
 nodist/

Makefile.in

@@ -3,13 +3,11 @@
 #
 # This file is part of Verilator.
 #
-# Author: Wilson Snyder <[email protected]>
-#
 # Code available from: http://www.veripool.org/verilator
 #
 #*****************************************************************************
 #
-# Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+# Copyright 2003-2015 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.
@@ -86,6 +84,10 @@ infodir = @infodir@
 # Generally ${prefix}/share/verilator
 pkgdatadir = @pkgdatadir@
 
+# Directory in which to install pkgconfig file
+# Generall ${prefix}/share/pkgconfig
+pkgconfigdir = @pkgconfigdir@
+
 # Directory in which to install data across multiple architectures
 datarootdir = @datarootdir@
 
@@ -100,10 +102,11 @@ PACKAGE_VERSION = @PACKAGE_VERSION@
 
 SHELL = /bin/sh
 
-SUBDIRS = src test_verilated test_c test_sc test_sp test_regress test_vcs
+SUBDIRS = src test_verilated test_c test_sc test_regress
 
 INFOS = README README.html README.pdf internals.txt internals.html \
-        internals.pdf verilator.txt verilator.html verilator.1 verilator.pdf
+        internals.pdf verilator.txt verilator.html verilator.pdf \
+	$(VL_INST_MAN_FILES)
 
 # Files that can be generated, but should be up to date for a distribution.
 DISTDEP = info Makefile
@@ -120,7 +123,10 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	include/.*ignore \
 	include/vltstd/*.[chv]* \
 	.*attributes */.*attributes  */*/.*attributes \
-	src/.*ignore src/*.in src/*.cpp src/*.[chly] src/astgen src/bisonpre src/*fix \
+	src/.*ignore src/*.in src/*.cpp src/*.[chly] \
+	src/astgen src/bisonpre src/*fix src/cppcheck_filtered \
+	src/vlcovgen \
+	src/.gdbinit \
 	src/*.pl src/*.pod \
 	test_*/.*ignore test_*/Makefile* test_*/*.cpp \
 	test_*/*.pl test_*/*.v test_*/*.vc test_*/*.vh \
@@ -138,6 +144,7 @@ DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 
 INST_PROJ_FILES = \
 	bin/verilator \
+	bin/verilator_coverage \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
 	include/verilated.mk \
@@ -147,6 +154,7 @@ INST_PROJ_FILES = \
 INST_PROJ_BIN_FILES = \
 	verilator_bin \
 	verilator_bin_dbg \
+	verilator_coverage_bin_dbg \
 
 DISTFILES := $(DISTFILES_INC)
 
@@ -163,7 +171,8 @@ all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 .PHONY:verilator_exe
 .PHONY:verilator_bin
 .PHONY:verilator_bin_dbg
-verilator_exe verilator_bin verilator_bin_dbg:
+.PHONY:verilator_coverage_bin_dbg
+verilator_exe verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg:
 	@echo ------------------------------------------------------------
 	@echo "making verilator in src" ; \
 	  (cd src && $(MAKE) $(OBJCACHE_JOBS) )
@@ -177,17 +186,15 @@ msg_test: all_nomsg
 
 .PHONY:test
 ifeq ($(CFG_WITH_LONGTESTS),yes)	# Local... Else don't burden users
-test: test_vcs test_c test_sc test_sp test_verilated test_regress
+test: test_c test_sc test_verilated test_regress
 else
-test: test_c test_sc test_sp
+test: test_c test_sc
 endif
 	@echo "Tests passed!"
 	@echo
 	@echo "Type 'make install' to install documentation."
 	@echo
 
-test_vcs: all_nomsg
-	@(cd test_vcs && $(MAKE))
 test_c: all_nomsg
 	@(cd test_c && $(MAKE))
 test_c_debug: all_nomsg
@@ -196,10 +203,6 @@ test_sc: all_nomsg
 	@(cd test_sc && $(MAKE))
 test_sc_debug: all_nomsg
 	@(cd test_sc && $(MAKE) test_debug)
-test_sp: all_nomsg
-	@(cd test_sp && $(MAKE))
-test_sp_debug: all_nomsg
-	@(cd test_sp && $(MAKE) test_debug)
 test_verilated: all_nomsg
 	@(cd test_verilated && $(MAKE))
 test_regress: all_nomsg
@@ -208,7 +211,7 @@ test_regress: all_nomsg
 info: $(INFOS)
 
 # Use --no-split to avoid creating filenames > 14 chars.
-verilator.1: ${srcdir}/bin/verilator
+%.1: ${srcdir}/bin/%
 	pod2man $< $@
 
 verilator.txt: ${srcdir}/bin/verilator
@@ -226,16 +229,16 @@ verilator.pdf: ${srcdir}/bin/verilator Makefile
 	pdflatex verilator.tex
 	-rm -f verilator.toc verilator.aux verilator.idx verilator.out
 
-README: readme.pod
+README: README.pod
 	-rm -f $@
 	$(POD2TEXT) --loose $< > $@
 
-README.html: readme.pod
+README.html: README.pod
 	pod2html $< >$@
 
 # PDF needs DIST variables; but having configure.ac as dependency isn't detected
-README.pdf: readme.pod Makefile
-	pod2latex --full --out README.tex readme.pod
+README.pdf: README.pod Makefile
+	pod2latex --full --out README.tex README.pod
 	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) README File" "${DISTDATE}" < README.tex > README2.tex
 	mv README2.tex README.tex
 	pdflatex README.tex
@@ -259,13 +262,13 @@ internals.pdf: internals.pod Makefile
 	-rm -f internals.toc internals.aux internals.idx internals.out
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
-VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg \
-	verilator_includer verilator_profcfunc
+VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg \
+	verilator_coverage verilator_includer verilator_profcfunc
 # Some scripts go into both the search path and pkgdatadir,
 # so they can be found by the user, and under $VERILATOR_ROOT.
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
-VL_INST_MAN_FILES = verilator.1
+VL_INST_MAN_FILES = verilator.1 verilator_coverage.1 verilator_profcfunc.1
 
 VL_INST_INC_BLDDIR_FILES = \
 	include/verilated.mk \
@@ -279,14 +282,15 @@ 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 \
-	                  test_sp/Makefile test_sp/Makefile_obj \
 
 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 )
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/bin
 	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
 
@@ -294,7 +298,7 @@ installbin:
 # So important we use $< so VPATH is searched
 installman: $(VL_INST_MAN_FILES)
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
-	for p in $< ; do \
+	for p in $^ ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
@@ -309,12 +313,13 @@ installdata:
 	done
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_c
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_sc
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_sp
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_v
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/examples/$$p; \
 	done
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgconfigdir)
+	$(INSTALL_DATA) verilator.pc $(DESTDIR)$(pkgconfigdir)
 
 # We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
 uninstall:
@@ -324,6 +329,7 @@ uninstall:
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir)/examples && rm -f $(VL_INST_DATA_SRCDIR_FILES)
+	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
 	-rmdir $(DESTDIR)$(pkgdatadir)/bin
 	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
 	-rmdir $(DESTDIR)$(pkgdatadir)/include
@@ -333,6 +339,7 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_v
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
 	-rmdir $(DESTDIR)$(pkgdatadir)
+	-rmdir $(DESTDIR)$(pkgconfigdir)
 
 install: all_nomsg install-all
 install-all: installbin installman installdata install-msg
@@ -349,6 +356,7 @@ INST_PROJ_CVS = cp_if_cvs_diff
 install-project: dist
 	@echo "Install-project to $(DIRPROJECT)"
 	strip verilator_bin*
+	strip verilator_coverage_bin*
 	$(MAKE) install-project-quick
 	for p in $(VL_INST_MAN_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \
@@ -372,6 +380,7 @@ endif
 install-cadtools: dist
 	@echo "Install-project to $(CAD_DIR)"
 	strip verilator_bin*
+	strip verilator_coverage_bin*
 	$(MAKE) install-cadtools-quick
 	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/man/man1
 	for p in $(VL_INST_MAN_FILES) ; do \
@@ -398,21 +407,25 @@ endif
 # VERILATOR_AUTHOR_SITE
 endif
 
-CPPCHECK = cppcheck
-CPPCHECK_FLAGS = --enable=all --inline-suppr --suppress=unusedScopedObject
+# Use --xml flag to see the cppcheck code to use for suppression
+CPPCHECK = src/cppcheck_filtered
+CPPCHECK_FLAGS = --enable=all --inline-suppr \
+	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList
+CPPCHECK_FLAGS += --xml
 CPPCHECK_CPP = $(wildcard $(srcdir)/include/*.cpp $(srcdir)/src/*.cpp)
 CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CPPCHECK_CPP))
+CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
 
 cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -I$(srcdir)/include -I$(srcdir)/src $<
+	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 $(CPPCHECK_INC) $<
 
 ftp: info
 
 install-msg:
 	@echo "Installed!"
 	@echo
-	@echo "Fod documentation see 'man verilator' or 'verilator --help'"
+	@echo "For documentation see 'man verilator' or 'verilator --help'"
 	@echo "For forums and to report bugs see http://www.veripool.org/verilator"
 	@echo
 
@@ -454,8 +467,9 @@ clean mostlyclean distclean maintainer-clean::
 	rm -f *.tex
 
 distclean maintainer-clean::
-	rm -f Makefile config.status config.cache config.log verilator_bin* TAGS
-	rm -f include/verilated.mk
+	rm -f Makefile config.status config.cache config.log TAGS
+	rm -f verilator_bin* verilator_coverage_bin*
+	rm -f include/verilated.mk include/verilated_config.h
 
 TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
 	${srcdir}/*.in ${srcdir}/*.pod

README.pod

@@ -5,11 +5,13 @@
 
 =head1 NAME
 
-This is the Verilator Package README file.
+This is the Verilator package README file.
 
 =head1 DISTRIBUTION
 
-This package is Copyright 2003-2013 by Wilson Snyder.  (Report bugs to
+http://www.veripool.org/verilator
+
+This package is Copyright 2003-2015 by Wilson Snyder.  (Report bugs to
 L<http://www.veripool.org/>.)
 
 Verilator is free software; you can redistribute it and/or modify it under
@@ -24,14 +26,14 @@ more details.
 
 =head1 DESCRIPTION
 
-Verilator converts synthesizable (not behavioral) Verilog code into C++ or
-SystemC code.  It is not a complete simulator, just a translator.
+Verilator converts synthesizable (generally not behavioral) Verilog code
+into C++ or SystemC code.  It is not a complete simulator, just a
+translator.
 
 Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
 reads the specified Verilog code, lints it, and optionally adds coverage
 code.  For C++ format, it outputs .cpp and .h files.  For SystemC format,
-it outputs .sp files for the SystemPerl preprocessor available at
-http://www.veripool.org.
+it outputs .cpp and .h files using the standard SystemC headers.
 
 The resulting files are then compiled with C++.  The user writes a little
 C++ wrapper file, which instantiates the top level module.  This is
@@ -41,14 +43,11 @@ The resulting executable will perform the actual simulation.
 
 =head1 SUPPORTED SYSTEMS
 
-Verilator is developed and has primary testing on:
-
-    SuSE 11.1 AMD64 i686-linux-2.6.27, GCC 4.3.2
-
-Versions have also built on Redhat Linux, Macs OS-X, HPUX and Solaris.  It
-should run with minor porting on any Linix-ish platform.  Verilator also
-works on Windows under Cygwin, and Windows under MinGW (gcc -mno-cygwin).
-Verilated output (not Verilator itself) compiles under MSVC++ 2008.
+Verilator is developed and has primary testing on Ubuntu.  Versions have
+also built on Redhat Linux, Macs OS-X, HPUX and Solaris.  It should run
+with minor porting on any Linix-ish platform.  Verilator also works on
+Windows under Cygwin, and Windows under MinGW (gcc -mno-cygwin).  Verilated
+output (not Verilator itself) compiles under MSVC++ 2008 and newer.
 
 =head1 INSTALLATION
 
@@ -71,19 +70,11 @@ Download the latest package from that site, and decompress.
 =item
 
 If you will be using SystemC (vs straight C++ output), download SystemC
-2.0.1 from L<http://www.systemc.org>.  Follow their installation
-instructions.  You will need to set SYSTEMC_INCLUDE to point to the
-include directory with systemc.h in it, and SYSTEMC_LIBDIR to points
-to the directory with libsystemc.a in it.  (Older installations may
-set SYSTEMC and SYSTEMC_ARCH instead.)
-
-=item
-
-If you will be using SystemPerl or coverage, download and install
-System-Perl, L<http://www.veripool.org/systemperl>.  Note you'll need to
-set a C<SYSTEMPERL> environment variable to point to the downloaded kit.
-Optionally also set C<SYSTEMPERL_INCLUDE> to point to the installed
-headers.
+from L<http://www.systemc.org>.  Follow their installation instructions.
+You will need to set SYSTEMC_INCLUDE to point to the include directory with
+systemc.h in it, and SYSTEMC_LIBDIR to points to the directory with
+libsystemc.a in it.  (Older installations may set SYSTEMC and SYSTEMC_ARCH
+instead.)
 
 =item
 
@@ -98,8 +89,8 @@ C<cd> to the Verilator directory containing this README.
 You now have to decide how you're going to eventually install the kit.
 
 Note Verilator builds the current value of VERILATOR_ROOT, SYSTEMC_INCLUDE,
-SYSTEMC_LIBDIR, SYSTEMPERL, and SYSTEMPERL_INCLUDE as defaults into the
-executable, so try to have them correct before configuring.
+and SYSTEMC_LIBDIR as defaults into the executable, so try to have them
+correct before configuring.
 
 =over 4
 
@@ -107,7 +98,7 @@ executable, so try to have them correct before configuring.
 
 Our personal favorite is to always run Verilator from the kit directory.
 This allows the easiest experimentation and upgrading.  It's also how most
-EDA tools operate; to run any of them you point to the tarball.
+EDA tools operate; to run you point to the tarball, no install is needed.
 
     export VERILATOR_ROOT=`pwd`   # if your shell is bash
     setenv VERILATOR_ROOT `pwd`   # if your shell is csh
@@ -126,9 +117,10 @@ and add it to path using Modules/modulecmd:
     After installing you'll want a module file like the following:
 
     set install_root /CAD_DISK/verilator/{version-number-used-above}
-    setenv VERILATOR_ROOT $install_root
+    unsetenv VERILATOR_ROOT
     prepend-path PATH $install_root/bin
     prepend-path MANPATH $install_root/man
+    prepend-path PKG_CONFIG_PATH $install_root/share/pkgconfig
 
 =item 3.
 
@@ -156,11 +148,10 @@ PATH.
 
 Type C<make> to compile Verilator.
 
-Type C<make test_c> to check the compilation.
+Type C<make test> to check the compilation.
 
-Type C<make test> for a more complete test.  You may get a error about the
-Bit::Vector Perl package.  You will need to install it and SystemPerl if
-you want all tests to pass.
+Configure with C<--enable-longtests> for more complete developer tests.
+Additional packages may be required for these tests.
 
 You may get a error about a typedef conflict for uint32_t.  Edit
 verilated.h to change the typedef to work, probably to @samp{typedef
@@ -195,15 +186,13 @@ The directories in the kit after de-taring are as follows:
     bin/verilator               => Compiler Wrapper invoked to Verilate code
     include/                    => Files that should be in your -I compiler path
     include/verilated*.cpp      => Global routines to link into your simulator
-    include/verilated.h         => Global headers
+    include/verilated*.h        => Global headers
     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_sp                     => Example Verilog->SystemPerl conversion
-    test_vcs                    => Example Verilog->VCS conversion (test the test)
     test_verilated              => Internal tests
     test_regress                => Internal tests
 

TODO

@@ -1,6 +1,6 @@
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2004-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -30,21 +30,6 @@ Configure/Make/Install
 	* Full MSVC++ compilation (does scons support this?) (4.000?)
 	* Distribute with flex/bison already expanded?
 	  Flex library not needed.  Probably too difficult to be worth it.
-	* Integrate SystemPerl coverage
-    	      (Note in /usr/include there are no upper cased include files.)
-		Coverage.pm		-- Need all functionality, but in C?
-		Coverage/Item.pm	-- Need all functionality, but in C?
-		Coverage/ItemKey.pm	-- Need all functionality, but in C?
-		sp_preproc		-- Some steps in here need to be moved to generated C
-		src/Sp.cpp		-- n/a
-		src/SpCommon.h		-- mostly overlaps verilatedos.h
-		src/SpCoverage.cpp/h	-- All needed
-		src/SpFunctor.cpp/h	-- No longer used
-		src/SpTraceVcd.cpp/h	-- MOVED
-		src/SpTraceVcdC.cpp/h	-- MOVED
-		src/sp_log.cpp/h	-- Not needed
-		src/systemperl.h	-- some stuff may be cut
-		vcoverage		-- Need all functionality, but in C?
 
 Testing:
 	* Move test_c/sp/v/verilated into test_regress format (4.000?)
@@ -53,6 +38,7 @@ Testing:
 	* New random program generator
 	* Better graph viewer with search and zoom
 	* Port and test against opencores.org code
+	* // verilator debug in code so can see only tree affecting those nodes
 
 Usability:
 	* Detect and pre-remove most UNOPTFLATs (4.000) 

bin/verilator_coverage

@@ -0,0 +1,291 @@
+: # -*-Mode: perl;-*- use perl, wherever it is
+eval 'exec perl -wS $0 ${1+"$@"}'
+  if 0;
+######################################################################
+#
+# Copyright 2003-2015 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+######################################################################
+
+require 5.006_001;
+use warnings;
+BEGIN {
+    if ($ENV{DIRPROJECT} && $ENV{DIRPROJECT_PERL_BOOT}) {
+	# Magic to allow author testing of perl packages in local directory
+	require $ENV{DIRPROJECT}."/".$ENV{DIRPROJECT_PERL_BOOT};
+    }
+}
+
+use Getopt::Long;
+use FindBin qw($RealBin $RealScript);
+use IO::File;
+use Pod::Usage;
+use Cwd qw(abs_path getcwd);
+
+use strict;
+use vars qw ($Debug @Opt_Verilator_Sw);
+
+#######################################################################
+#######################################################################
+# main
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+
+$Debug = 0;
+
+# No arguments can't do anything useful.  Give help
+if ($#ARGV < 0) {
+    pod2usage(-exitstatus=>2, -verbose=>0);
+}
+
+# We sneak a look at the flags so we can do some pre-environment checks
+# All flags will hit verilator...
+foreach my $sw (@ARGV) {
+    $sw = "'$sw'" if $sw =~ m![^---a-zA-Z0-9_/\\:.+]!;
+    push @Opt_Verilator_Sw, $sw;
+}
+
+Getopt::Long::config ("no_auto_abbrev","pass_through");
+if (! GetOptions (
+	  # Major operating modes
+	  "help"	=> \&usage,
+	  "debug:s"	=> \&debug,
+	  # "version!"	=> \&version,	# Also passthru'ed
+	  # Additional parameters
+	  "<>"		=> sub {},	# Ignored
+    )) {
+    pod2usage(-exitstatus=>2, -verbose=>0);
+}
+
+# Normal, non gdb
+run (verilator_coverage_bin()
+     ." ".join(' ',@Opt_Verilator_Sw));
+
+#----------------------------------------------------------------------
+
+sub usage {
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
+}
+
+sub debug {
+    shift;
+    my $level = shift;
+    $Debug = $level||3;
+}
+
+#######################################################################
+#######################################################################
+# Builds
+
+sub verilator_coverage_bin {
+    my $bin = "";
+    # Use VERILATOR_ROOT if defined, else assume verilator_bin is in the search path
+    my $basename = ($ENV{VERILATOR_COVERAGE_BIN}
+		    || "verilator_coverage_bin_dbg");
+    if (defined($ENV{VERILATOR_ROOT})) {
+	my $dir = $ENV{VERILATOR_ROOT};
+	if (-x "$dir/bin/$basename") {  # From a "make install" into VERILATOR_ROOT
+	    $bin = "$dir/bin/$basename";
+	} else {
+	    $bin = "$dir/$basename";  # From pointing to kit directory
+	}
+    } else {
+	if (-x "$RealBin/$basename") {
+	    $bin = "$RealBin/$basename";  # From path/to/verilator with verilator_bin installed
+	} else {
+	    $bin = $basename;  # Find in PATH
+	}
+	# Note we don't look under bin/$basename which would be right if running
+	# in the kit dir. Running that would likely break, since
+	# VERILATOR_ROOT wouldn't be set and Verilator won't find internal files.
+    }
+    return $bin;
+}
+
+#######################################################################
+#######################################################################
+# Utilities
+
+sub run {
+    # Run command, check errors
+    my $command = shift;
+    $! = undef;  # Cleanup -x
+    print "\t$command\n" if $Debug>=3;
+    system($command);
+    my $status = $?;
+    if ($status) {
+	if ($! =~ /no such file or directory/i) {
+	    warn "%Error: verilator_coverage: Misinstalled, or VERILATOR_ROOT might need to be in environment\n";
+	}
+	if ($Debug) {  # For easy rerunning
+	    warn "%Error: export VERILATOR_ROOT=".($ENV{VERILATOR_ROOT}||"")."\n";
+	    warn "%Error: $command\n";
+	}
+	if ($status & 127) {
+	    if (($status & 127) == 8 || ($status & 127) == 11) { # SIGFPA or SIGSEGV
+		warn "%Error: Verilator_coverage internal fault, sorry.\n" if !$Debug;
+	    } elsif (($status & 127) == 6) {  # SIGABRT
+		warn "%Error: Verilator_coverage aborted.\n" if !$Debug;
+	    } else {
+		warn "%Error: Verilator_coverage threw signal $status.\n" if !$Debug;
+	    }
+	}
+	die "%Error: Command Failed $command\n";
+    }
+}
+
+#######################################################################
+#######################################################################
+package main;
+__END__
+
+=pod
+
+=head1 NAME
+
+verilator_coverage - Verilator coverage analyzer
+
+=head1 SYNOPSIS
+
+    verilator_coverage --help
+    verilator_coverage --version
+
+    verilator_coverage --annotate <obj>
+
+    verilator_coverage  -write merged.dat -read <datafiles>...
+
+Verilator_coverage processes Verilator coverage reports.
+
+With --anotate, it reads the specified data file and generates annotated
+source code with coverage metrics annotated.  If multiple coverage points
+exist on the same line, additional lines will be inserted to report the
+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
+into Emacs and do a M-x keep-lines to include only those statistics of
+interest.
+
+For Verilog conditions that should never occur, you should add a $stop
+statement.  This will remove the coverage during the next build.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item I<filename>
+
+Specify input data file, may be repeated to read multiple inputs.  If no
+data file is specified, by default coverage.dat is read.
+
+=item --annotate I<output_directory>
+
+Sprcifies the directory name that source files with annotated coverage data
+should be written to.
+
+=item --annotate-all
+
+Specifies all files should be shown.  By default, only those source files
+which have low coverage are written to the output directory.
+
+=item --annotate-min I<count>
+
+Specifies the minimum occurrence count that should be flagged if the
+coverage point does not include a specified threshold.  Defaults to 10.
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item --rank
+
+Print an experimental report listing the relative importance of each test
+in covering all of the coverage points.  The report shows "Covered" which
+indicates the number of points that test covers; a test is considered to
+cover a point if it has a bucket count of at least 1. The "rank" column has
+a higher number t indicate the test is more important, and rank 0 means the
+test does not need to be run to cover the points.  "RankPts" indicates the
+number of coverage points this test will contribute to overall coverage if
+all tests are run in the order of highest to lowest rank.
+
+=item --unlink
+
+When using --write to combine coverage data, unlink all input files after
+the output has been created.
+
+=item --version
+
+Displays program version and exits.
+
+=item --write I<filename>
+
+Specifies the aggregate coverage results, summed across all the files,
+should be written to the given filename.  This is useful in scripts to
+combine many sequential runs into one master coverage file.
+
+=back
+
+=head1 VERILOG ARGUMENTS
+
+The following arguments are compatible with GCC, VCS and most Verilog
+programs.
+
+=over 4
+
+=item +libext+I<ext>+I<ext>...
+
+Defines the extensions for Verilog files.
+
+=item +define+I<var>+I<value>
+=item -DI<var>=I<value>
+
+Defines the given variable.
+
+=item +incdir+I<dir>
+=item -II<dir>
+
+Specifies a directory for finding include files.
+
+=item -f I<file>
+
+Specifies a file containing additional command line arguments.
+
+=item -y I<dir>
+
+Specifies a module search directory.
+
+=back
+
+=head1 DISTRIBUTION
+
+The latest version is available from L<http://www.veripool.org/>.
+
+Copyright 2003-2015 by Wilson Snyder.  Verilator is free software; you can
+redistribute it and/or modify the Verilator internals under the terms of
+either the GNU Lesser General Public License Version 3 or the Perl Artistic
+License Version 2.0.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+C<verilator>
+
+L<verilator_coverage --help> which is the source for this document.
+
+=cut
+
+######################################################################

bin/verilator_difftree

@@ -235,7 +235,7 @@ Do not show differences in line numbering.
 
 The latest version is available from L<http://www.veripool.org/verilator>.
 
-Copyright 2005-2013 by Wilson Snyder.  This package is free software; you can
+Copyright 2005-2015 by Wilson Snyder.  This package is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

bin/verilator_includer

@@ -3,7 +3,7 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2013 by Wilson Snyder. This package is free software; you can
+# Copyright 2003-2015 by Wilson Snyder. This package is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU Lesser
 # General Public License Version 3 or the Perl Artistic License Version 2.0.
 ######################################################################
@@ -12,5 +12,9 @@ require 5.005;
 use warnings;
 print "// DESCR"."IPTION: Generated by verilator_includer via makefile\n";
 foreach my $param (@ARGV) {
-    print "#include \"$param\"\n"
+    if ($param =~ /^-D([^=]+)=(.*)/) {
+	print "#define $1 $2\n"
+    } else {
+	print "#include \"$param\"\n"
+    }
 }

bin/verilator_profcfunc

@@ -118,6 +118,18 @@ sub profcfunc {
 		$groups{type}{"Common code under $design"} += $pct;
 		$groups{design}{$design} += $pct;
 		$groups{module}{$design." common code"} += $pct;
+	    } elsif ($func =~ /^VL_[A-Z0-9_]+/
+		     || $func =~ /^_?vl_[a-zA-Z0-9_]+/
+		     || $func =~ /^verilated/i) {
+		$vfunc = sprintf("VLib      %s", $func);
+		$groups{type}{'VLib'} += $pct;
+		$groups{design}{'VLib'} += $pct;
+		$groups{module}{'VLib'} += $pct;
+	    } elsif ($func =~ /^_mcount_private/) {
+		$vfunc = sprintf("Prof      %s", $func);
+		$groups{type}{'Prof'} += $pct;
+		$groups{design}{'Prof'} += $pct;
+		$groups{module}{'Prof'} += $pct;
 	    } else {
 		$vfunc = sprintf("C++       %s", $func);
 		$groups{type}{'C++'} += $pct;
@@ -129,7 +141,7 @@ sub profcfunc {
     }
 
 
-    foreach my $type qw(type design module) {
+    foreach my $type (qw(type design module)) {
 	my $missing = 100;
 	foreach (sort (keys %{$groups{$type}})) {
 	    $missing -= $groups{$type}{$_};
@@ -150,8 +162,10 @@ sub profcfunc {
     print("Verilog code profile:\n");
     print("   These are split into three categories:\n");
     print("      C++:     Time in non-Verilated C++ code\n");
+    print("      Prof:    Time in profile overhead\n");
     print("      VBlock:  Time attributable to a block in a Verilog file and line\n");
     print("      VCommon: Time in a Verilated module, due to all parts of the design\n");
+    print("      VLib:    Time in Verilated common libraries, called by the Verilated code\n");
     print("\n");
 
     print("  %   cumulative   self              \n");
@@ -208,7 +222,7 @@ Displays this message and program version and exits.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2007-2013 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2007-2015 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

configure.ac

@@ -1,14 +1,16 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2013 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2015 by Wilson Snyder. Verilator is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU Lesser
 # General Public License Version 3 or the Perl Artistic License Version 2.0.
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[3.844 2013-01-09])
+AC_INIT([Verilator],[3.878 2015-11-01])
+# When releasing, also update header of Changes file
+
 AC_CONFIG_HEADER(src/config_build.h)
-AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk)
+AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
 
 AC_MSG_RESULT([configuring for $PACKAGE_STRING])
 
@@ -107,30 +109,51 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
    [# _MY_CXX_CHECK_OPT(flag) -- Check if compiler supports specific options
     ACO_SAVE_CXXFLAGS="$CXXFLAGS"
     # -Werror needed otherwise unknown -Wno-div-by-zero won't report problems
-    CXXFLAGS="$CXXFLAGS $1 -Werror"
-    AC_MSG_CHECKING([whether $CXX accepts $1])
+    CXXFLAGS="$CXXFLAGS $2 -Werror"
+    AC_MSG_CHECKING([whether $CXX accepts $2])
     AC_COMPILE_IFELSE(
          [AC_LANG_PROGRAM([],[])],
-	 [_my_result=yes],
+	 [_my_result=yes
+	  if test -s conftest.err; then
+	    if grep -e "$2" conftest.err >/dev/null; then
+	      _my_result=no
+	    fi
+	  fi],
 	 [_my_result=no])
     AC_MSG_RESULT($_my_result)
     if test "$_my_result" = "yes" ; then
-       CFG_CXXFLAGS_NO_UNUSED="$CFG_CXXFLAGS_NO_UNUSED $1"
+       $1="$$1 $2"
     fi
     CXXFLAGS="$ACO_SAVE_CXXFLAGS"
    ])# _MY_CXX_CHECK_OPT
 
+# Flags for compiling Verilator internals including parser
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
+AC_SUBST(CFG_CXXFLAGS_SRC)
+
+# Flags for compiling Verilator parser
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-unused)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-parentheses-equality)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_PARSER,-Wno-null-conversion)
+AC_SUBST(CFG_CXXFLAGS_PARSER)
+
+# Flags for Verilated makefile
 # For example, -Wno-div-by-zero isn't in 4.1.2
-_MY_CXX_CHECK_OPT(-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
 # Random code often does / 0.  Unfortunately VL_DIV_I(0,0) will warn
 # without this flag, even though there's a conditional to prevent the divide.
 # We still don't add no-div-by-zero as it throws message to stdout, though doesn't die.
 #_MY_CXX_CHECK_OPT(-Wno-div-by-zero)
-_MY_CXX_CHECK_OPT(-Wno-sign-compare)
-_MY_CXX_CHECK_OPT(-Wno-uninitialized)
-_MY_CXX_CHECK_OPT(-Wno-unused-parameter)
-_MY_CXX_CHECK_OPT(-Wno-unused-variable)
-_MY_CXX_CHECK_OPT(-Wno-unused-but-set-variable)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-sign-compare)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-uninitialized)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-but-set-variable)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-unused-variable)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-fbracket-depth=4096)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Qunused-arguments)
 AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 
 # Checks for library functions.
@@ -140,6 +163,8 @@ AC_SUBST(CFG_CXXFLAGS_NO_UNUSED)
 # Other install directories
 pkgdatadir=${datadir}/verilator
 AC_SUBST(pkgdatadir)
+pkgconfigdir=${datadir}/pkgconfig
+AC_SUBST(pkgconfigdir)
 
 AC_OUTPUT
 

doxygen.config

@@ -635,9 +635,7 @@ INPUT                  = doxygen-mainpage \
                          test_c \
                          test_regress \
                          test_sc \
-                         test_sp \
                          test_v \
-                         test_vcs \
                          test_verilated
 
 # This tag can be used to specify the character encoding of the source files

include/.gitignore

@@ -1 +1,2 @@
 verilated.mk
+verilated_config.h

include/verilated.cpp

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 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.
@@ -40,6 +40,7 @@ Verilated::Serialized Verilated::s_s;
 VL_THREAD const VerilatedScope* Verilated::t_dpiScopep = NULL;
 VL_THREAD const char* Verilated::t_dpiFilename = "";
 VL_THREAD int Verilated::t_dpiLineno = 0;
+struct Verilated::CommandArgValues Verilated::s_args = {0, NULL};
 
 VerilatedImp  VerilatedImp::s_s;
 
@@ -73,6 +74,9 @@ void vl_fatal (const char* filename, int linenum, const char* hier, const char*
     Verilated::gotFinish(true);
     VL_PRINTF("%%Error: %s:%d: %s\n", filename, linenum, msg);
     Verilated::flushCall();
+
+    VL_PRINTF("Aborting...\n");
+    Verilated::flushCall();  // Second flush in case VL_PRINTF does something needing a flush
     abort();
 }
 #endif
@@ -86,6 +90,7 @@ Verilated::Serialized::Serialized() {
     s_calcUnusedSigs = false;
     s_gotFinish = false;
     s_assertOn = true;
+    s_fatalOnVpiError = true; // retains old default behaviour
 }
 
 //===========================================================================
@@ -205,7 +210,8 @@ WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, boo
     vluint32_t vn[VL_MULS_MAX_WORDS+1]; // v normalized
 
     // Zero for ease of debugging and to save having to zero for shifts
-    for (int i=0; i<words; i++) { un[i]=vn[i]=0; }
+    // Note +1 as loop will use extra word
+    for (int i=0; i<words+1; i++) { un[i]=vn[i]=0; }
 
     // Algorithm requires divisor MSB to be set
     // Copy and shift to normalize divisor so MSB of vn[vw-1] is set
@@ -337,6 +343,12 @@ void _vl_vsformat(string& output, const char* formatp, va_list ap) {
 		output += cstrp;
 		break;
 	    }
+	    case '@': { // Verilog/C++ string
+		va_arg(ap, int);  // # bits is ignored
+		const string* cstrp = va_arg(ap, const string*);
+		output += *cstrp;
+		break;
+	    }
 	    case 'e':
 	    case 'f':
 	    case 'g': {
@@ -464,7 +476,7 @@ static inline void _vl_vsss_advance(FILE* fp, int& floc) {
     if (fp) fgetc(fp);
     else floc -= 8;
 }
-static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp) {
+static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp, const string& fstr) {
     // Get a character without advancing
     if (fp) {
 	int data = fgetc(fp);
@@ -474,23 +486,26 @@ static inline int  _vl_vsss_peek(FILE* fp, int& floc, WDataInP fromp) {
     } else {
 	if (floc < 0) return EOF;
 	floc = floc & ~7;	// Align to closest character
-	int data = (fromp[VL_BITWORD_I(floc)] >> VL_BITBIT_I(floc)) & 0xff;
-	return data;
+	if (fromp == NULL) {
+	    return fstr[fstr.length()-1 - (floc>>3)];
+	} else {
+	    return (fromp[VL_BITWORD_I(floc)] >> VL_BITBIT_I(floc)) & 0xff;
+	}
     }
 }
-static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp) {
+static inline void _vl_vsss_skipspace(FILE* fp, int& floc, WDataInP fromp, const string& fstr) {
     while (1) {
-	int c = _vl_vsss_peek(fp, floc, fromp);
+	int c = _vl_vsss_peek(fp, floc, fromp, fstr);
 	if (c==EOF || !isspace(c)) return;
 	_vl_vsss_advance(fp, floc);
     }
 }
-static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp,
+static inline void _vl_vsss_read(FILE* fp, int& floc, WDataInP fromp, const string& fstr,
 				 char* tmpp, const char* acceptp) {
     // Read into tmp, consisting of characters from acceptp list
     char* cp = tmpp;
     while (1) {
-	int c = _vl_vsss_peek(fp, floc, fromp);
+	int c = _vl_vsss_peek(fp, floc, fromp, fstr);
 	if (c==EOF || isspace(c)) break;
 	if (acceptp!=NULL // String - allow anything
 	    && NULL==strchr(acceptp, c)) break;
@@ -535,6 +550,7 @@ static inline void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const
 
 IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		  int fbits, WDataInP fromp,  // Else if a sscanf
+		  const string& fstr,  // if a sscanf to string
 		  const char* formatp, va_list ap) {
     // Read a Verilog $sscanf/$fscanf style format into the output list
     // The format must be pre-processed (and lower cased) by Verilator
@@ -545,15 +561,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
     bool inPct = false;
     const char* pos = formatp;
     for (; *pos && !_vl_vsss_eof(fp,floc); ++pos) {
-	//VL_PRINTF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc, _vl_vsss_peek(fp,floc,fromp));
+	//VL_PRINTF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc, _vl_vsss_peek(fp,floc,fromp,fstr));
 	if (!inPct && pos[0]=='%') {
 	    inPct = true;
 	} else if (!inPct && isspace(pos[0])) {   // Format spaces
 	    while (isspace(pos[1])) pos++;
-	    _vl_vsss_skipspace(fp,floc,fromp);
+	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
 	} else if (!inPct) {   // Expected Format
-	    _vl_vsss_skipspace(fp,floc,fromp);
-	    int c = _vl_vsss_peek(fp,floc,fromp);
+	    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+	    int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 	    if (c != pos[0]) goto done;
 	    else _vl_vsss_advance(fp,floc);
 	} else { // Format character
@@ -562,7 +578,7 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 	    char fmt = pos[0];
 	    switch (fmt) {
 	    case '%': {
-		int c = _vl_vsss_peek(fp,floc,fromp);
+		int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 		if (c != '%') goto done;
 		else _vl_vsss_advance(fp,floc);
 		break;
@@ -579,15 +595,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		for (int i=0; i<VL_WORDS_I(obits); i++) owp[i] = 0;
 		switch (fmt) {
 		case 'c': {
-		    int c = _vl_vsss_peek(fp,floc,fromp);
+		    int c = _vl_vsss_peek(fp,floc,fromp,fstr);
 		    if (c==EOF) goto done;
 		    else _vl_vsss_advance(fp,floc);
 		    owp[0] = c;
 		    break;
 		}
 		case 's': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, NULL);
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, NULL);
 		    if (!tmp[0]) goto done;
 		    int pos = ((int)strlen(tmp))-1;
 		    int lsb = 0;
@@ -597,19 +613,19 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		    break;
 		}
 		case 'd': { // Signed decimal
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    vlsint64_t ld;
-		    sscanf(tmp,"%" VL_PRI64 "d",&ld);
+		    sscanf(tmp,"%30" VL_PRI64 "d",&ld);
 		    VL_SET_WQ(owp,ld);
 		    break;
 		}
 		case 'f':
 		case 'e':
 		case 'g': { // Real number
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "+-.0123456789eE");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "+-.0123456789eE");
 		    if (!tmp[0]) goto done;
 		    union { double r; vlsint64_t ld; } u;
 		    u.r = strtod(tmp, NULL);
@@ -618,31 +634,31 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
 		}
 		case 't': // FALLTHRU  // Time
 		case 'u': { // Unsigned decimal
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789+-xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789+-xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    QData ld;
-		    sscanf(tmp,"%" VL_PRI64 "u",&ld);
+		    sscanf(tmp,"%30" VL_PRI64 "u",&ld);
 		    VL_SET_WQ(owp,ld);
 		    break;
 		}
 		case 'b': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "01xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "01xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 1, tmp, 0, (int)strlen(tmp));
 		    break;
 		}
 		case 'o': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "01234567xXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "01234567xXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 3, tmp, 0, (int)strlen(tmp));
 		    break;
 		}
 		case 'x': {
-		    _vl_vsss_skipspace(fp,floc,fromp);
-		    _vl_vsss_read(fp,floc,fromp, tmp, "0123456789abcdefABCDEFxXzZ?_");
+		    _vl_vsss_skipspace(fp,floc,fromp,fstr);
+		    _vl_vsss_read(fp,floc,fromp,fstr, tmp, "0123456789abcdefABCDEFxXzZ?_");
 		    if (!tmp[0]) goto done;
 		    _vl_vsss_based(owp,obits, 4, tmp, 0, (int)strlen(tmp));
 		    break;
@@ -692,8 +708,8 @@ void _VL_VINT_TO_STRING(int obits, char* destoutp, WDataInP sourcep) {
 	    start = false;	// Drop leading 0s
 	}
     }
-    *destp++ = '\0'; // Terminate
-    while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';  // Drop trailing spaces
+    *destp = '\0'; // Terminate
+    if (!start) while (isspace(*(destp-1)) && destp>destoutp) *--destp = '\0';  // Drop trailing spaces
 }
 
 void _VL_STRING_TO_VINT(int obits, void* destp, int srclen, const char* srcp) {
@@ -734,6 +750,11 @@ IData VL_FGETS_IXI(int obits, void* destp, IData fpi) {
     return got;
 }
 
+IData VL_FOPEN_NI(const string& filename, IData mode) {
+    char modez[5];
+    _VL_VINT_TO_STRING(VL_WORDSIZE, modez, &mode);
+    return VL_FOPEN_S(filename.c_str(), modez);
+}
 IData VL_FOPEN_QI(QData filename, IData mode) {
     IData fnw[2];  VL_SET_WQ(fnw, filename);
     return VL_FOPEN_WI(2, fnw, mode);
@@ -756,6 +777,50 @@ void VL_FCLOSE_I(IData fdi) {
     VerilatedImp::fdDelete(fdi);
 }
 
+void VL_SFORMAT_X(int obits, CData& destr, const char* formatp, ...) {
+    VL_STATIC_OR_THREAD string output;  // static only for speed
+    output = "";
+    va_list ap;
+    va_start(ap,formatp);
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    _VL_STRING_TO_VINT(obits, &destr, (int)output.length(), output.c_str());
+}
+
+void VL_SFORMAT_X(int obits, SData& destr, const char* formatp, ...) {
+    VL_STATIC_OR_THREAD string output;  // static only for speed
+    output = "";
+    va_list ap;
+    va_start(ap,formatp);
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    _VL_STRING_TO_VINT(obits, &destr, (int)output.length(), output.c_str());
+}
+
+void VL_SFORMAT_X(int obits, IData& destr, const char* formatp, ...) {
+    VL_STATIC_OR_THREAD string output;  // static only for speed
+    output = "";
+    va_list ap;
+    va_start(ap,formatp);
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    _VL_STRING_TO_VINT(obits, &destr, (int)output.length(), output.c_str());
+}
+
+void VL_SFORMAT_X(int obits, QData& destr, const char* formatp, ...) {
+    VL_STATIC_OR_THREAD string output;  // static only for speed
+    output = "";
+    va_list ap;
+    va_start(ap,formatp);
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+
+    _VL_STRING_TO_VINT(obits, &destr, (int)output.length(), output.c_str());
+}
+
 void VL_SFORMAT_X(int obits, void* destp, const char* formatp, ...) {
     VL_STATIC_OR_THREAD string output;  // static only for speed
     output = "";
@@ -767,6 +832,15 @@ void VL_SFORMAT_X(int obits, void* destp, const char* formatp, ...) {
     _VL_STRING_TO_VINT(obits, destp, (int)output.length(), output.c_str());
 }
 
+void VL_SFORMAT_X(int obits_ignored, string &output, const char* formatp, ...) {
+    if (obits_ignored) {}
+    output = "";
+    va_list ap;
+    va_start(ap,formatp);
+    _vl_vsformat(output, formatp, ap);
+    va_end(ap);
+}
+
 string VL_SFORMATF_NX(const char* formatp, ...) {
     VL_STATIC_OR_THREAD string output;  // static only for speed
     output = "";
@@ -810,7 +884,7 @@ IData VL_FSCANF_IX(IData fpi, const char* formatp, ...) {
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(fp, 0, NULL, formatp, ap);
+    IData got = _vl_vsscanf(fp, 0, NULL, "", formatp, ap);
     va_end(ap);
     return got;
 }
@@ -820,7 +894,7 @@ IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...) {
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, "", formatp, ap);
     va_end(ap);
     return got;
 }
@@ -829,14 +903,21 @@ IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...) {
 
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, fnw, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, fnw, "", formatp, ap);
     va_end(ap);
     return got;
 }
 IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...) {
     va_list ap;
     va_start(ap,formatp);
-    IData got = _vl_vsscanf(NULL, lbits, lwp, formatp, ap);
+    IData got = _vl_vsscanf(NULL, lbits, lwp, "", formatp, ap);
+    va_end(ap);
+    return got;
+}
+IData VL_SSCANF_INX(int, const string& ld, const char* formatp, ...) {
+    va_list ap;
+    va_start(ap,formatp);
+    IData got = _vl_vsscanf(NULL, ld.length()*8, NULL, ld, formatp, ap);
     va_end(ap);
     return got;
 }
@@ -975,7 +1056,7 @@ IData VL_VALUEPLUSARGS_IW(int rbits, const char* prefixp, char fmt, WDataOutP rw
 	break;
     case 'd':
 	vlsint64_t ld;
-	sscanf(dp,"%" VL_PRI64 "d",&ld);
+	sscanf(dp,"%30" VL_PRI64 "d",&ld);
 	VL_SET_WQ(rwp,ld);
 	break;
     case 'b':
@@ -1064,11 +1145,22 @@ void Verilated::flushCb(VerilatedVoidCb cb) {
 }
 
 void Verilated::commandArgs(int argc, const char** argv) {
+    s_args.argc = argc;
+    s_args.argv = argv;
     VerilatedImp::commandArgs(argc,argv);
 }
 
 const char* Verilated::commandArgsPlusMatch(const char* prefixp) {
-    return VerilatedImp::argPlusMatch(prefixp).c_str();
+    const string& match = VerilatedImp::argPlusMatch(prefixp);
+    static VL_THREAD char outstr[VL_VALUE_STRING_MAX_WIDTH];
+    if (match == "") return "";
+    strncpy(outstr, match.c_str(), VL_VALUE_STRING_MAX_WIDTH);
+    outstr[VL_VALUE_STRING_MAX_WIDTH-1] = '\0';
+    return outstr;
+}
+
+void Verilated::internalsDump() {
+    VerilatedImp::internalsDump();
 }
 
 void Verilated::scopesDump() {
@@ -1083,6 +1175,10 @@ int Verilated::exportFuncNum(const char* namep) {
     return VerilatedImp::exportFind(namep);
 }
 
+const VerilatedScopeNameMap* Verilated::scopeNameMap() {
+    return VerilatedImp::scopeNameMap();
+}
+
 //===========================================================================
 // VerilatedModule:: Methods
 
@@ -1097,6 +1193,7 @@ VerilatedModule::~VerilatedModule() {
 //======================================================================
 // VerilatedVar:: Methods
 
+// cppcheck-suppress unusedFunction  // Used by applications
 vluint32_t VerilatedVar::entSize() const {
     vluint32_t size = 1;
     switch (vltype()) {
@@ -1105,7 +1202,7 @@ vluint32_t VerilatedVar::entSize() const {
     case VLVT_UINT16:	size=sizeof(SData); break;
     case VLVT_UINT32:	size=sizeof(IData); break;
     case VLVT_UINT64:	size=sizeof(QData); break;
-    case VLVT_WDATA:	size=VL_WORDS_I(range().bits())*sizeof(IData); break;
+    case VLVT_WDATA:	size=VL_WORDS_I(range().elements())*sizeof(IData); break;
     default:		size=0; break;
     }
     return size;
@@ -1177,11 +1274,11 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap,
 	int msb = va_arg(ap,int);
 	int lsb = va_arg(ap,int);
 	if (i==0) {
-	    var.m_range.m_lhs = msb;
-	    var.m_range.m_rhs = lsb;
+	    var.m_range.m_left = msb;
+	    var.m_range.m_right = lsb;
 	} else if (i==1) {
-	    var.m_array.m_lhs = msb;
-	    var.m_array.m_rhs = lsb;
+	    var.m_array.m_left = msb;
+	    var.m_array.m_right = lsb;
 	} else {
 	    // We could have a linked list of ranges, but really this whole thing needs
 	    // to be generalized to support structs and unions, etc.
@@ -1193,6 +1290,7 @@ void VerilatedScope::varInsert(int finalize, const char* namep, void* datap,
     m_varsp->insert(make_pair(namep,var));
 }
 
+// cppcheck-suppress unusedFunction  // Used by applications
 VerilatedVar* VerilatedScope::varFind(const char* namep) const {
     if (VL_LIKELY(m_varsp)) {
 	VerilatedVarNameMap::iterator it = m_varsp->find(namep);
@@ -1230,9 +1328,9 @@ void VerilatedScope::scopeDump() const {
 		      m_callbacksp[i], VerilatedImp::exportName(i));
 	}
     }
-    if (varsp()) {
-	for (VerilatedVarNameMap::const_iterator it = varsp()->begin();
-	     it != varsp()->end(); ++it) {
+    if (VerilatedVarNameMap* varsp = this->varsp()) {
+	for (VerilatedVarNameMap::const_iterator it = varsp->begin();
+	     it != varsp->end(); ++it) {
 	    VL_PRINTF("       VAR %p: %s\n", &(it->second), it->first);
 	}
     }

include/verilated.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -28,6 +28,7 @@
 #ifndef _VERILATED_H_
 #define _VERILATED_H_ 1 ///< Header Guard
 
+#include "verilated_config.h"
 #include "verilatedos.h"
 
 #include <cassert>
@@ -37,6 +38,7 @@
 #include <cstring>
 #include <cmath>
 // <iostream> avoided to reduce compile time
+// <map> avoided and instead in verilated_heavy.h to reduce compile time
 // <string> avoided and instead in verilated_heavy.h to reduce compile time
 using namespace std;
 
@@ -67,6 +69,7 @@ typedef void (*VerilatedVoidCb)(void);
 
 class SpTraceVcd;
 class SpTraceVcdCFile;
+class VerilatedScopeNameMap;
 class VerilatedVar;
 class VerilatedVarNameMap;
 class VerilatedVcd;
@@ -101,9 +104,9 @@ class VerilatedModule {
 private:
     const char*		m_namep;	///< Module name
     VerilatedModule();				///< N/A, always use named constructor below
-    VerilatedModule(const VerilatedModule& );	///< N/A, no copying modules
+    VerilatedModule(const VerilatedModule& );	///< N/A, no copy constructor
 public:
-    VerilatedModule(const char* namep);	///< Create module with given hierarchy name
+    explicit VerilatedModule(const char* namep);	///< Create module with given hierarchy name
     ~VerilatedModule();
     const char* name() const { return m_namep; }	///< Return name of module
 };
@@ -144,7 +147,7 @@ public:
 # define VL_CELL(instname,type)		///< Declare a cell, ala SP_CELL
 
 /// Declare a module, ala SC_MODULE
-# define VL_MODULE(modname)		struct modname : public VerilatedModule
+# define VL_MODULE(modname)		class modname : public VerilatedModule
 
 /// Constructor, ala SC_CTOR
 # define VL_CTOR(modname)		modname(const char* __VCname="")
@@ -215,9 +218,8 @@ public:  // But internals only - called from VerilatedModule's
 //===========================================================================
 /// Verilator global static information class
 
-struct Verilated {
+class Verilated {
     // MEMBERS
-private:
     // Slow path variables
     static VerilatedVoidCb  s_flushCb;		///< Flush callback function
 
@@ -229,6 +231,7 @@ private:
 	bool		s_calcUnusedSigs;	///< Waves file on, need all signals calculated
 	bool		s_gotFinish;		///< A $finish statement executed
 	bool		s_assertOn;		///< Assertions are enabled
+        bool		s_fatalOnVpiError;	///< Stop on vpi error/unsupported
 	Serialized();
     } s_s;
 
@@ -236,6 +239,13 @@ private:
     static VL_THREAD const char*	t_dpiFilename;	///< DPI context filename
     static VL_THREAD int		t_dpiLineno;	///< DPI context line number
 
+    // no need to be save-restored (serialized) the
+    // assumption is that the restore is allowed to pass different arguments
+    static struct CommandArgValues {
+	int          argc;
+	const char** argv;
+    } s_args;
+
 public:
 
     // METHODS - User called
@@ -268,6 +278,9 @@ public:
     /// Enable/disable assertions
     static void assertOn(bool flag) { s_s.s_assertOn=flag; }
     static bool assertOn() { return s_s.s_assertOn; }
+    /// Enable/disable vpi fatal
+    static void fatalOnVpiError(bool flag) { s_s.s_fatalOnVpiError=flag; }
+    static bool fatalOnVpiError() { return s_s.s_fatalOnVpiError; }
     /// Flush callback for VCD waves
     static void flushCb(VerilatedVoidCb cb);
     static void flushCall() { if (s_flushCb) (*s_flushCb)(); }
@@ -275,8 +288,19 @@ public:
     /// Record command line arguments, for retrieval by $test$plusargs/$value$plusargs
     static void commandArgs(int argc, const char** argv);
     static void commandArgs(int argc, char** argv) { commandArgs(argc,(const char**)argv); }
+    static CommandArgValues* getCommandArgs() {return &s_args;}
+    /// Match plusargs with a given prefix. Returns static char* valid only for a single call
     static const char* commandArgsPlusMatch(const char* prefixp);
 
+    /// Produce name & version for (at least) VPI
+    static const char* productName() { return VERILATOR_PRODUCT; }
+    static const char* productVersion() { return VERILATOR_VERSION; }
+
+    /// For debugging, print much of the Verilator internal state.
+    /// The output of this function may change in future
+    /// releases - contact the authors before production use.
+    static void internalsDump();
+
     /// For debugging, print text list of all scope names with
     /// dpiImport/Export context.  This function may change in future
     /// releases - contact the authors before production use.
@@ -287,6 +311,7 @@ public:
     static const char* catName(const char* n1, const char* n2); // Returns new'ed data
     // Internal: Find scope
     static const VerilatedScope* scopeFind(const char* namep);
+    static const VerilatedScopeNameMap* scopeNameMap();
     // Internal: Get and set DPI context
     static const VerilatedScope* dpiScope() { return t_dpiScopep; }
     static void dpiScope(const VerilatedScope* scopep) { t_dpiScopep=scopep; }
@@ -336,6 +361,7 @@ extern IData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
 extern IData VL_FOPEN_QI(QData ofilename, IData mode);
 inline IData VL_FOPEN_II(IData ofilename, IData mode) { return VL_FOPEN_QI(ofilename,mode); }
 
+
 extern void VL_FCLOSE_I(IData fdi);
 
 extern void VL_READMEM_W(bool hex, int width, int depth, int array_lsb, int fnwords,
@@ -354,6 +380,10 @@ extern IData VL_SSCANF_IIX(int lbits, IData ld, const char* formatp, ...);
 extern IData VL_SSCANF_IQX(int lbits, QData ld, const char* formatp, ...);
 extern IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...);
 
+extern void VL_SFORMAT_X(int obits, CData& destr, const char* formatp, ...);
+extern void VL_SFORMAT_X(int obits, SData& destr, const char* formatp, ...);
+extern void VL_SFORMAT_X(int obits, IData& destr, const char* formatp, ...);
+extern void VL_SFORMAT_X(int obits, QData& destr, const char* formatp, ...);
 extern void VL_SFORMAT_X(int obits, void* destp, const char* formatp, ...);
 
 extern IData VL_SYSTEM_IW(int lhsnwords, WDataInP lhs);
@@ -530,6 +560,7 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
 //===================================================================
 // SYSTEMC OPERATORS
 // Copying verilog format to systemc integers and bit vectors.
+// Get a SystemC variable
 
 #define VL_ASSIGN_ISI(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read()); }
 #define VL_ASSIGN_QSQ(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read()); }
@@ -547,20 +578,34 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
     owp[words-1] &= VL_MASK_I(obits); \
 }
 
+#define VL_ASSIGN_ISU(obits,vvar,svar) { (vvar) = VL_CLEAN_II((obits),(obits),(svar).read().to_uint()); }
+#define VL_ASSIGN_QSU(obits,vvar,svar) { (vvar) = VL_CLEAN_QQ((obits),(obits),(svar).read().to_uint64()); }
+#define VL_ASSIGN_WSB(obits,owp,svar) {                       \
+    int words = VL_WORDS_I(obits);                            \
+    sc_biguint<obits> _butemp = (svar).read();                \
+    for (int i=0; i < words; i++) {                           \
+        int msb = ((i+1)*VL_WORDSIZE) - 1;                    \
+        msb = (msb >= obits) ? (obits-1) : msb;               \
+        owp[i] = _butemp.range(msb,i*VL_WORDSIZE).to_uint();  \
+    }                                                         \
+    owp[words-1] &= VL_MASK_I(obits);                         \
+}
+
 // Copying verilog format from systemc integers and bit vectors.
+// Set a SystemC variable
 
 #define VL_ASSIGN_SII(obits,svar,vvar) { (svar).write(vvar); }
 #define VL_ASSIGN_SQQ(obits,svar,vvar) { (svar).write(vvar); }
 
 #define VL_ASSIGN_SWI(obits,svar,rd) { \
     sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0,rd); \
+    _bvtemp.set_word(0,(rd));			\
     svar.write(_bvtemp); \
 }
 #define VL_ASSIGN_SWQ(obits,svar,rd) { \
     sc_bv<obits> _bvtemp; \
-    _bvtemp.set_word(0,rd); \
-    _bvtemp.set_word(1,rd>>VL_WORDSIZE); \
+    _bvtemp.set_word(0,(IData)(rd));	 \
+    _bvtemp.set_word(1,(IData)((rd)>>VL_WORDSIZE));	\
     svar.write(_bvtemp); \
 }
 #define VL_ASSIGN_SWW(obits,svar,rwp) { \
@@ -569,6 +614,20 @@ static inline void VL_ASSIGNBIT_WO(int, int bit, WDataOutP owp, IData) {
     svar.write(_bvtemp); \
 }
 
+#define VL_ASSIGN_SUI(obits,svar,rd) { (svar).write(rd); }
+#define VL_ASSIGN_SUQ(obits,svar,rd) { (svar).write(rd); }
+#define VL_ASSIGN_SBI(obits,svar,rd) { (svar).write(rd); }
+#define VL_ASSIGN_SBQ(obits,svar,rd) { (svar).write(rd); }
+#define VL_ASSIGN_SBW(obits,svar,rwp) {             \
+    sc_biguint<obits> _butemp;                      \
+    for (int i=0; i < VL_WORDS_I(obits); i++) {     \
+        int msb = ((i+1)*VL_WORDSIZE) - 1;          \
+        msb = (msb >= obits) ? (obits-1) : msb;     \
+        _butemp.range(msb,i*VL_WORDSIZE) = rwp[i];  \
+    }                                               \
+    svar.write(_butemp);                            \
+}
+
 //===================================================================
 // Extending sizes
 
@@ -820,7 +879,7 @@ static inline WDataOutP VL_OR_W(int words, WDataOutP owp,WDataInP lwp,WDataInP r
 }
 // EMIT_RULE: VL_CHANGEXOR:  oclean=1; obits=32; lbits==rbits;
 static inline IData VL_CHANGEXOR_W(int words, WDataInP lwp,WDataInP rwp){
-    IData od;
+    IData od = 0;
     for (int i=0; (i < words); i++) od |= (lwp[i] ^ rwp[i]);
     return(od);
 }
@@ -1078,7 +1137,9 @@ static inline WDataOutP VL_DIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDataI
     int words = VL_WORDS_I(lbits);
     IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
     IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
+    // cppcheck-suppress variableScope
     IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
     IData rwstore[VL_MULS_MAX_WORDS];
     WDataInP ltup = lwp;
     WDataInP rtup = rwp;
@@ -1097,7 +1158,9 @@ static inline WDataOutP VL_MODDIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDa
     int words = VL_WORDS_I(lbits);
     IData lsign = VL_SIGN_I(lbits,lwp[words-1]);
     IData rsign = VL_SIGN_I(lbits,rwp[words-1]);
+    // cppcheck-suppress variableScope
     IData lwstore[VL_MULS_MAX_WORDS]; // Fixed size, as MSVC++ doesn't allow [words] here
+    // cppcheck-suppress variableScope
     IData rwstore[VL_MULS_MAX_WORDS];
     WDataInP ltup = lwp;
     WDataInP rtup = rwp;
@@ -1113,7 +1176,10 @@ static inline WDataOutP VL_MODDIVS_WWW(int lbits, WDataOutP owp,WDataInP lwp,WDa
     }
 }
 
+#define VL_POW_QQI(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs)
+
 static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) {
+    if (VL_UNLIKELY(rhs==0)) return 1;
     if (VL_UNLIKELY(lhs==0)) return 0;
     IData power = lhs;
     IData out = 1;
@@ -1123,10 +1189,8 @@ static inline IData VL_POW_III(int, int, int rbits, IData lhs, IData rhs) {
     }
     return out;
 }
-
-#define VL_POW_QQI(obits,lbits,rbits,lhs,rhs) VL_POW_QQQ(obits,lbits,rbits,lhs,rhs)
-
 static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
+    if (VL_UNLIKELY(rhs==0)) return 1;
     if (VL_UNLIKELY(lhs==0)) return 0;
     QData power = lhs;
     QData out = VL_ULL(1);
@@ -1137,6 +1201,36 @@ static inline QData VL_POW_QQQ(int, int, int rbits, QData lhs, QData rhs) {
     return out;
 }
 
+#define VL_POWSS_QQI(obits,lbits,rbits,lhs,rhs,lsign,rsign) VL_POWSS_QQQ(obits,lbits,rbits,lhs,rhs,lsign,rsign)
+
+static inline IData VL_POWSS_III(int obits, int, int rbits, IData lhs, IData rhs, bool lsign, bool rsign) {
+    if (VL_UNLIKELY(rhs==0)) return 1;
+    if (rsign && VL_SIGN_I(rbits, rhs)) {
+	if (lhs==0) return 0;	// "X"
+	else if (lhs==1) return 1;
+	else if (lsign && lhs==VL_MASK_I(obits)) {  //-1
+	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
+	    else return 1; // -1^even=1
+	}
+	return 0;
+    }
+    return VL_POW_III(obits, obits, rbits, lhs, rhs);
+}
+
+static inline QData VL_POWSS_QQQ(int obits, int, int rbits, QData lhs, QData rhs, bool lsign, bool rsign) {
+    if (VL_UNLIKELY(rhs==0)) return 1;
+    if (rsign && VL_SIGN_I(rbits, rhs)) {
+	if (lhs==0) return 0;	// "X"
+	else if (lhs==1) return 1;
+	else if (lsign && lhs==VL_MASK_I(obits)) {  //-1
+	    if (rhs & 1) return VL_MASK_I(obits);  // -1^odd=-1
+	    else return 1; // -1^even=1
+	}
+	return 0;
+    }
+    return VL_POW_QQQ(obits, obits, rbits, lhs, rhs);
+}
+
 //===================================================================
 // Concat/replication
 
@@ -1277,6 +1371,120 @@ static inline WDataOutP VL_REPLICATE_WWI(int obits, int lbits, int, WDataOutP ow
     return(owp);
 }
 
+// Left stream operator. Output will always be clean. LHS and RHS must be clean.
+// Special "fast" versions for slice sizes that are a power of 2. These use
+// shifts and masks to execute faster than the slower for-loop approach where a
+// subset of bits is copied in during each iteration.
+static inline IData VL_STREAML_FAST_III(int, int lbits, int, IData ld, IData rd_log2) {
+    // Pre-shift bits in most-significant slice:
+    //
+    // If lbits is not a multiple of the slice size (i.e., lbits % rd != 0),
+    // then we end up with a "gap" in our reversed result. For example, if we
+    // have a 5-bit Verlilog signal (lbits=5) in an 8-bit C data type:
+    //
+    //   ld = ---43210
+    //
+    // (where numbers are the Verilog signal bit numbers and '-' is an unused bit).
+    // Executing the switch statement below with a slice size of two (rd=2,
+    // rd_log2=1) produces:
+    //
+    //   ret = 1032-400
+    //
+    // Pre-shifting the bits in the most-significant slice allows us to avoid
+    // this gap in the shuffled data:
+    //
+    //   ld_adjusted = --4-3210
+    //   ret = 10324---
+    IData ret = ld;
+    if (rd_log2) {
+	vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2); // max multiple of rd <= lbits
+	vluint32_t lbitsRem = lbits - lbitsFloor; // number of bits in most-sig slice (MSS)
+	IData msbMask = VL_MASK_I(lbitsRem) << lbitsFloor; // mask to sel only bits in MSS
+	ret = (ret & ~msbMask) | ((ret & msbMask) << ((VL_UL(1) << rd_log2) - lbitsRem));
+    }
+    switch (rd_log2) {
+	case 0:
+	    ret = ((ret >> 1) & VL_UL(0x55555555)) | ((ret & VL_UL(0x55555555)) << 1);    // FALLTHRU
+	case 1:
+	    ret = ((ret >> 2) & VL_UL(0x33333333)) | ((ret & VL_UL(0x33333333)) << 2);    // FALLTHRU
+	case 2:
+	    ret = ((ret >> 4) & VL_UL(0x0f0f0f0f)) | ((ret & VL_UL(0x0f0f0f0f)) << 4);    // FALLTHRU
+	case 3:
+	    ret = ((ret >> 8) & VL_UL(0x00ff00ff)) | ((ret & VL_UL(0x00ff00ff)) << 8);    // FALLTHRU
+	case 4:
+	    ret = ((ret >> 16) | (ret << 16));
+    }
+    return ret >> (VL_WORDSIZE - lbits);
+}
+
+static inline QData VL_STREAML_FAST_QQI(int, int lbits, int, QData ld, IData rd_log2) {
+    // Pre-shift bits in most-significant slice (see comment in VL_STREAML_FAST_III)
+    QData ret = ld;
+    if (rd_log2) {
+        vluint32_t lbitsFloor = lbits & ~VL_MASK_I(rd_log2);
+        vluint32_t lbitsRem = lbits - lbitsFloor;
+        QData msbMask = VL_MASK_Q(lbitsRem) << lbitsFloor;
+        ret = (ret & ~msbMask) | ((ret & msbMask) << ((VL_ULL(1) << rd_log2) - lbitsRem));
+    }
+    switch (rd_log2) {
+	case 0:
+	    ret = ((ret >>  1) & VL_ULL(0x5555555555555555)) | ((ret & VL_ULL(0x5555555555555555)) <<  1);    // FALLTHRU
+	case 1:
+	    ret = ((ret >>  2) & VL_ULL(0x3333333333333333)) | ((ret & VL_ULL(0x3333333333333333)) <<  2);    // FALLTHRU
+	case 2:
+	    ret = ((ret >>  4) & VL_ULL(0x0f0f0f0f0f0f0f0f)) | ((ret & VL_ULL(0x0f0f0f0f0f0f0f0f)) <<  4);    // FALLTHRU
+	case 3:
+	    ret = ((ret >>  8) & VL_ULL(0x00ff00ff00ff00ff)) | ((ret & VL_ULL(0x00ff00ff00ff00ff)) <<  8);    // FALLTHRU
+	case 4:
+	    ret = ((ret >> 16) & VL_ULL(0x0000ffff0000ffff)) | ((ret & VL_ULL(0x0000ffff0000ffff)) << 16);    // FALLTHRU
+	case 5:
+	    ret = ((ret >> 32) | (ret << 32));
+    }
+    return ret >> (VL_QUADSIZE - lbits);
+}
+
+// Regular "slow" streaming operators
+static inline IData VL_STREAML_III(int, int lbits, int, IData ld, IData rd) {
+    IData ret = 0;
+    // Slice size should never exceed the lhs width
+    IData mask = VL_MASK_I(rd);
+    for (int istart=0; istart<lbits; istart+=rd) {
+	int ostart=lbits-rd-istart;
+        ostart = ostart > 0 ? ostart : 0;
+        ret |= ((ld >> istart) & mask) << ostart;
+    }
+    return ret;
+}
+
+static inline QData VL_STREAML_QQI(int, int lbits, int, QData ld, IData rd) {
+    QData ret = 0;
+    // Slice size should never exceed the lhs width
+    QData mask = VL_MASK_Q(rd);
+    for (int istart=0; istart<lbits; istart+=rd) {
+	int ostart=lbits-rd-istart;
+        ostart = ostart > 0 ? ostart : 0;
+        ret |= ((ld >> istart) & mask) << ostart;
+    }
+    return ret;
+}
+
+static inline WDataOutP VL_STREAML_WWI(int, int lbits, int, WDataOutP owp, WDataInP lwp, IData rd) {
+    VL_ZERO_RESET_W(lbits, owp);
+    // Slice size should never exceed the lhs width
+    int ssize = (rd < (IData)lbits) ? rd : ((IData)lbits);
+    for (int istart=0; istart<lbits; istart+=rd) {
+	int ostart=lbits-rd-istart;
+        ostart = ostart > 0 ? ostart : 0;
+	for (int sbit=0; sbit<ssize && sbit<lbits-istart; sbit++) {
+            // Extract a single bit from lwp and shift it to the correct
+            // location for owp.
+            WData bit= ((lwp[VL_BITWORD_I(istart+sbit)] >> VL_BITBIT_I(istart+sbit)) & 1) << VL_BITBIT_I(ostart+sbit);
+            owp[VL_BITWORD_I(ostart+sbit)] |= bit;
+	}
+    }
+    return owp;
+}
+
 // Because concats are common and wide, it's valuable to always have a clean output.
 // Thus we specify inputs must be clean, so we don't need to clean the output.
 // Note the bit shifts are always constants, so the adds in these constify out.
@@ -1363,7 +1571,7 @@ static inline void _VL_SHIFTL_INPLACE_W(int obits,WDataOutP iowp,IData rd/*1 or
 static inline WDataOutP VL_SHIFTL_WWI(int obits,int,int,WDataOutP owp,WDataInP lwp, IData rd) {
     int word_shift = VL_BITWORD_I(rd);
     int bit_shift = VL_BITBIT_I(rd);
-    if ((int)rd >= obits) {
+    if (rd >= (IData)obits) {  // rd may be huge with MSB set
 	for (int i=0; i < VL_WORDS_I(obits); i++) owp[i] = 0;
     } else if (bit_shift==0) {  // Aligned word shift (<<0,<<32,<<64 etc)
 	for (int i=0; i < word_shift; i++) owp[i] = 0;
@@ -1381,7 +1589,7 @@ static inline WDataOutP VL_SHIFTL_WWI(int obits,int,int,WDataOutP owp,WDataInP l
 static inline WDataOutP VL_SHIFTR_WWI(int obits,int,int,WDataOutP owp,WDataInP lwp, IData rd) {
     int word_shift = VL_BITWORD_I(rd);  // Maybe 0
     int bit_shift = VL_BITBIT_I(rd);
-    if ((int)rd >= obits) {
+    if (rd >= (IData)obits) {  // rd may be huge with MSB set
 	for (int i=0; i < VL_WORDS_I(obits); i++) owp[i] = 0;
     } else if (bit_shift==0) {  // Aligned word shift (>>0,>>32,>>64 etc)
 	int copy_words = (VL_WORDS_I(obits)-word_shift);
@@ -1405,29 +1613,37 @@ static inline WDataOutP VL_SHIFTR_WWI(int obits,int,int,WDataOutP owp,WDataInP l
 }
 
 // EMIT_RULE: VL_SHIFTRS:  oclean=false; lclean=clean, rclean==clean;
-static inline IData VL_SHIFTRS_III(int obits, int, int, IData lhs, IData rhs) {
+static inline IData VL_SHIFTRS_III(int obits, int lbits, int, IData lhs, IData rhs) {
     // Note the C standard does not specify the >> operator as a arithmetic shift!
-    IData sign    = -(lhs >> (obits-1)); // ffff_ffff if negative
-    IData signext = ~(VL_MASK_I(obits) >> rhs);   // One with bits where we've shifted "past"
+    // IEEE says signed if output signed, but bit position from lbits;
+    // must use lbits for sign; lbits might != obits,
+    // an EXTEND(SHIFTRS(...)) can became a SHIFTRS(...) within same 32/64 bit word length
+    IData sign    = -(lhs >> (lbits-1)); // ffff_ffff if negative
+    IData signext = ~(VL_MASK_I(lbits) >> rhs);   // One with bits where we've shifted "past"
     return (lhs >> rhs) | (sign & VL_CLEAN_II(obits,obits,signext));
 }
-static inline QData VL_SHIFTRS_QQI(int obits, int, int, QData lhs, IData rhs) {
-    QData sign    = -(lhs >> (obits-1));
-    QData signext = ~(VL_MASK_Q(obits) >> rhs);
+static inline QData VL_SHIFTRS_QQI(int obits, int lbits, int, QData lhs, IData rhs) {
+    QData sign    = -(lhs >> (lbits-1));
+    QData signext = ~(VL_MASK_Q(lbits) >> rhs);
     return (lhs >> rhs) | (sign & VL_CLEAN_QQ(obits,obits,signext));
 }
-static inline WDataOutP VL_SHIFTRS_WWI(int obits,int,int,WDataOutP owp,WDataInP lwp, IData rd) {
+static inline IData VL_SHIFTRS_IQI(int obits, int lbits, int rbits, QData lhs, IData rhs) {
+    return (IData)(VL_SHIFTRS_QQI(obits, lbits, rbits, lhs, rhs));
+}
+static inline WDataOutP VL_SHIFTRS_WWI(int obits,int lbits,int,WDataOutP owp,WDataInP lwp, IData rd) {
     int word_shift = VL_BITWORD_I(rd);
     int bit_shift = VL_BITBIT_I(rd);
     int lmsw = VL_WORDS_I(obits)-1;
-    IData sign = VL_SIGNONES_I(obits,lwp[lmsw]);
-    if ((int)rd >= obits) {
+    IData sign = VL_SIGNONES_I(lbits,lwp[lmsw]);
+    if (rd >= (IData)obits) {  // Shifting past end, sign in all of lbits
 	for (int i=0; i <= lmsw; i++) owp[i] = sign;
+	owp[lmsw] &= VL_MASK_I(lbits);
     } else if (bit_shift==0) {  // Aligned word shift (>>0,>>32,>>64 etc)
 	int copy_words = (VL_WORDS_I(obits)-word_shift);
 	for (int i=0; i < copy_words; i++) owp[i] = lwp[i+word_shift];
 	if (copy_words>=0) owp[copy_words-1] |= ~VL_MASK_I(obits) & sign;
 	for (int i=copy_words; i < VL_WORDS_I(obits); i++) owp[i] = sign;
+	owp[lmsw] &= VL_MASK_I(lbits);
     } else {
 	int loffset = rd & VL_SIZEBITS_I;
 	int nbitsonright = 32-loffset;  // bits that end up in lword (know loffset!=0)
@@ -1442,6 +1658,7 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int,int,WDataOutP owp,WDataInP
 	}
 	if (words) owp[words-1] |= sign & ~VL_MASK_I(obits-loffset);
 	for (int i=words; i<VL_WORDS_I(obits); i++) owp[i] = sign;
+	owp[lmsw] &= VL_MASK_I(lbits);
     }
     return(owp);
 }
@@ -1457,7 +1674,7 @@ static inline WDataOutP VL_SHIFTRS_WWI(int obits,int,int,WDataOutP owp,WDataInP
 
 static inline IData VL_BITSEL_IWII(int, int lbits, int, int, WDataInP lwp, IData rd) {
     int word = VL_BITWORD_I(rd);
-    if (VL_UNLIKELY((int)rd>lbits)) {
+    if (VL_UNLIKELY(rd>(IData)lbits)) {
 	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
 	// We return all 1's as that's more likely to find bugs (?) than 0's.
     } else {

include/verilated.mk.in

@@ -2,7 +2,7 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2013 by Wilson Snyder. Verilator is free software; you can
+# Copyright 2003-2015 by Wilson Snyder. Verilator is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU Lesser
 # General Public License Version 3 or the Perl Artistic License Version 2.0.
 ######################################################################
@@ -23,7 +23,9 @@ CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
 # Programs
 
 SP_PREPROC	= sp_preproc
-SP_INCLUDER     = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
+SP_INCLUDER	= $(VERILATOR_INCLUDER)
+VERILATOR_COVERAGE = $(PERL) $(VERILATOR_ROOT)/bin/verilator_coverage
+VERILATOR_INCLUDER = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
 
 ######################################################################
 # Make checks
@@ -43,14 +45,14 @@ VK_CPPFLAGS_ALWAYS += \
 		-DVL_PRINTF=printf \
 		-DVM_TRACE=$(VM_TRACE) \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
+		$(CFG_CXXFLAGS_NO_UNUSED) \
 
 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
 VK_CPPFLAGS_WALL += -Wall \
-		$(CFG_CXXFLAGS_NO_UNUSED) \
 		-Werror
 endif
 
-CPPFLAGS += -I. $(VK_CPPFLAGS_ALWAYS) $(VK_CPPFLAGS_WALL)
+CPPFLAGS += -I. $(VK_CPPFLAGS_WALL) $(VK_CPPFLAGS_ALWAYS)
 
 VPATH += ..
 VPATH += $(VERILATOR_ROOT)/include
@@ -118,10 +120,6 @@ ifeq ($(VM_SP),1)
 	 $(SP_PREPROC) -M sp_preproc.d --tree $(VM_PREFIX).sp_tree \
 		--preproc $(VK_CLASSES_SP)
 else
- ifeq ($(VM_COVERAGE),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
- endif
   preproc:
 endif
 
@@ -157,9 +155,9 @@ ifneq ($(VM_PARALLEL_BUILDS),1)
   VK_OBJS += $(VM_PREFIX)__ALLcls.o   $(VM_PREFIX)__ALLsup.o
   all_cpp:   $(VM_PREFIX)__ALLcls.cpp $(VM_PREFIX)__ALLsup.cpp
   $(VM_PREFIX)__ALLcls.cpp: $(VK_CLASSES_CPP)
-	$(SP_INCLUDER) $^ > $@
+	$(VERILATOR_INCLUDER) -DVL_INCLUDE_OPT=include $^ > $@
   $(VM_PREFIX)__ALLsup.cpp: $(VK_SUPPORT_CPP)
-	$(SP_INCLUDER) $^ > $@
+	$(VERILATOR_INCLUDER) -DVL_INCLUDE_OPT=include $^ > $@
 else
   #Slow way of building... Each .cpp file by itself
   VK_OBJS += $(addsuffix .o, $(VM_CLASSES) $(VM_SUPPORT))
@@ -195,6 +193,7 @@ debug-make::
 	@echo VM_SUPPORT_SLOW: $(VM_SUPPORT_SLOW)
 	@echo VM_GLOBAL_FAST: $(VM_GLOBAL_FAST)
 	@echo VM_GLOBAL_SLOW: $(VM_GLOBAL_SLOW)
+	@echo CPPFLAGS: $(CPPFLAGS)
 	@echo
 
 ######################################################################

include/verilated.v

@@ -4,7 +4,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.

include/verilated_config.h.in

@@ -0,0 +1,28 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License.
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+///
+/// \file
+/// \brief Verilator: Auto version information include for all Verilated C files
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+///**** Product and Version name
+
+// Autoconf substitutes this with the strings from AC_INIT.
+#define VERILATOR_PRODUCT    "@PACKAGE_NAME@"
+#define VERILATOR_VERSION    "@PACKAGE_VERSION@"

include/verilated_cov.cpp

@@ -0,0 +1,455 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// This is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+//
+//=============================================================================
+///
+/// \file
+/// \brief Verilator coverage analysis
+///
+//=============================================================================
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_cov.h"
+#include "verilated_cov_key.h"
+
+#include <map>
+#include <deque>
+#include <fstream>
+
+//=============================================================================
+// VerilatedCovImpBase
+/// Implementation base class for constants
+
+struct VerilatedCovImpBase {
+    // TYPES
+    enum { MAX_KEYS = 33 };		/// Maximum user arguments + filename+lineno
+    enum { KEY_UNDEF = 0 };		/// Magic key # for unspecified values
+};
+
+//=============================================================================
+// VerilatedCovImpItem
+/// Implementation class for a VerilatedCov item
+
+class VerilatedCovImpItem : VerilatedCovImpBase {
+public:  // But only local to this file
+    // MEMBERS
+    int	m_keys[MAX_KEYS];		///< Key
+    int	m_vals[MAX_KEYS];		///< Value for specified key
+    // CONSTRUCTORS
+    // Derived classes should call zero() in their constructor
+    VerilatedCovImpItem() {
+	for (int i=0; i<MAX_KEYS; i++) {
+	    m_keys[i]=KEY_UNDEF;
+	    m_vals[i]=0;
+	}
+    }
+    virtual ~VerilatedCovImpItem() {}
+    virtual vluint64_t count() const = 0;
+    virtual void zero() const = 0;
+};
+
+//=============================================================================
+/// VerilatedCoverItem templated for a specific class
+/// Creates a new coverage item for the specified type.
+/// This isn't in the header file for auto-magic conversion because it
+/// inlines to too much code and makes compilation too slow.
+
+template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
+private:
+    // MEMBERS
+    T*	m_countp;	///< Count value
+public:
+    // METHODS
+    virtual vluint64_t count() const { return *m_countp; }
+    virtual void zero() const { *m_countp = 0; }
+    // CONSTRUCTORS
+    // cppcheck-suppress noExplicitConstructor
+    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { zero(); }
+    virtual ~VerilatedCoverItemSpec() {}
+};
+
+//=============================================================================
+// VerilatedCovImp
+/// Implementation class for VerilatedCov.  See that class for public method information.
+/// All value and keys are indexed into a unique number.  Thus we can greatly reduce
+/// the storage requirements for otherwise identical keys.
+
+class VerilatedCovImp : VerilatedCovImpBase {
+private:
+    // TYPES
+    typedef map<string,int> ValueIndexMap;
+    typedef map<int,string> IndexValueMap;
+    typedef 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
+
+    VerilatedCovImpItem*	m_insertp;	///< Item about to insert
+    const char*		m_insertFilenamep;	///< Filename about to insert
+    int			m_insertLineno;		///< Line number about to insert
+
+    // CONSTRUCTORS
+    VerilatedCovImp() {
+	m_insertp = NULL;
+	m_insertFilenamep = NULL;
+	m_insertLineno = 0;
+    }
+public:
+    ~VerilatedCovImp() { clear(); }
+    static VerilatedCovImp& imp() {
+	static VerilatedCovImp s_singleton;
+	return s_singleton;
+    }
+
+private:
+    // PRIVATE METHODS
+    int valueIndex(const string& value) {
+	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));
+	return nextIndex;
+    }
+    string dequote(const string& text) {
+	// Quote any special characters
+	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;
+	    } else {
+		rtn += *pos;
+	    }
+	}
+	return rtn;
+    }
+    bool legalKey(const string& key) {
+	// 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...
+	// (Considered using numeric keys, but will remain back compatible.)
+	if (key.length()<2) return false;
+	if (key.length()==2 && isdigit(key[1])) return false;
+	return true;
+    }
+    string keyValueFormatter (const string& key, const string& value) {
+	string name;
+	if (key.length()==1 && isalpha(key[0])) {
+	    name += string("\001")+key;
+	} else {
+	    name += string("\001")+dequote(key);
+	}
+	name += string("\002")+dequote(value);
+	return name;
+    }
+    string combineHier (const string& old, const string& add) {
+	// (foo.a.x, foo.b.x) => foo.*.x
+	// (foo.a.x, foo.b.y) => foo.*
+	// (foo.a.x, foo.b)   => foo.*
+	if (old == add) return add;
+	if (old == "") return add;
+	if (add == "") return old;
+
+	const char* a = old.c_str();
+	const char* b = add.c_str();
+
+	// Scan forward to first mismatch
+	const char* apre = a;
+	const char* bpre = b;
+	while (*apre == *bpre) { apre++; bpre++; }
+
+	// 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);
+
+	// Scan backward to last mismatch
+	const char* apost = a+strlen(a)-1;
+	const char* bpost = b+strlen(b)-1;
+	while (*apost == *bpost
+	       && apost>apre && bpost>bpre) { apost--; bpost--; }
+
+	// Forward to . so we have a whole word
+	string suffix = *bpost ? string(bpost+1) : "";
+
+	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++) {
+	    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
+		    return true;
+		}
+	    }
+	}
+	return false;
+    }
+    void selftest() {
+	// 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");
+    }
+
+public:
+    // PUBLIC METHODS
+    void clear() {
+	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+	    VerilatedCovImpItem* itemp = *(it);
+	    delete itemp;
+	}
+	m_items.clear();
+	m_indexValues.clear();
+	m_valueIndexes.clear();
+    }
+    void clearNonMatch (const char* matchp) {
+	if (matchp && matchp[0]) {
+	    ItemList newlist;
+	    for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+		VerilatedCovImpItem* itemp = *(it);
+		if (!itemMatchesString(itemp, matchp)) {
+		    delete itemp;
+		} else {
+		    newlist.push_back(itemp);
+		}
+	    }
+	    m_items = newlist;
+	}
+    }
+    void zero() {
+	for (ItemList::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) {
+	assert(!m_insertp);
+ 	m_insertp = itemp;
+    }
+    void insertf (const char* filenamep, int lineno) {
+	m_insertFilenamep = filenamep;
+	m_insertLineno = lineno;
+    }
+    void insertp (const char* ckeyps[MAX_KEYS],
+		  const char* valps[MAX_KEYS]) {
+	assert(m_insertp);
+	// First two key/vals are filename
+	ckeyps[0]="filename";	valps[0]=m_insertFilenamep;
+	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);
+	ckeyps[2]="page";	valps[2]=page_default.c_str();
+
+	// Keys -> strings
+	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++) {
+	    if (keys[i]!="") {
+		for (int j=i+1; j<MAX_KEYS; j++) {
+		    if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
+			keys[i] = "";
+			break;
+		    }
+		}
+	    }
+	}
+	// Insert the values
+	int addKeynum=0;
+	for (int i=0; i<MAX_KEYS; i++) {
+	    const string key = keys[i];
+	    if (keys[i]!="") {
+		const 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());
+		}
+	    }
+	}
+	m_items.push_back(m_insertp);
+	// Prepare for next
+	m_insertp = NULL;
+    }
+
+    void write (const char* filename) {
+#ifndef VM_COVERAGE
+	vl_fatal("",0,"","%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
+#endif
+	selftest();
+
+	ofstream os (filename);
+	if (os.fail()) {
+	    string msg = (string)"%Error: Can't write '"+filename+"'";
+	    vl_fatal("",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;
+	for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+	    VerilatedCovImpItem* itemp = *(it);
+	    string name;
+	    string hier;
+	    bool per_instance = false;
+
+	    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]];
+		    if (key == VL_CIK_PER_INSTANCE) {
+			if (val != "0") per_instance = true;
+		    }
+		    if (key == VL_CIK_HIER) {
+			hier = val;
+		    } else {
+			// Print it
+			name += keyValueFormatter(key,val);
+		    }
+		}
+	    }
+	    if (per_instance) {  // Not collapsing hierarchies
+		name += keyValueFormatter(VL_CIK_HIER,hier);
+		hier = "";
+	    }
+
+	    // Group versus point labels don't matter here, downstream
+	    // deals with it.  Seems bad for sizing though and doesn't
+	    // allow easy addition of new group codes (would be
+	    // inefficient)
+
+	    // Find or insert the named event
+	    EventMap::iterator cit = eventCounts.find(name);
+	    if (cit != eventCounts.end()) {
+		const 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())));
+	    }
+	}
+
+	// Output body
+	for (EventMap::iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
+	    os<<"C '"<<dec;
+	    os<<it->first;
+	    if (it->second.first != "") os<<keyValueFormatter(VL_CIK_HIER,it->second.first);
+	    os<<"' "<<it->second.second;
+	    os<<endl;
+	}
+    }
+};
+
+//=============================================================================
+// VerilatedCov
+
+void VerilatedCov::clear() {
+    VerilatedCovImp::imp().clear();
+}
+void VerilatedCov::clearNonMatch (const char* matchp) {
+    VerilatedCovImp::imp().clearNonMatch(matchp);
+}
+void VerilatedCov::zero() {
+    VerilatedCovImp::imp().zero();
+}
+void VerilatedCov::write (const char* filenamep) {
+    VerilatedCovImp::imp().write(filenamep);
+}
+void VerilatedCov::_inserti (vluint32_t* itemp) {
+    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp));
+}
+void VerilatedCov::_inserti (vluint64_t* itemp) {
+    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp));
+}
+void VerilatedCov::_insertf (const char* filename, int lineno) {
+    VerilatedCovImp::imp().insertf(filename,lineno);
+}
+
+#define K(n) const char* key ## n
+#define A(n) const char* key ## n, const char* val ## n		// Argument list
+#define C(n) key ## n, val ## n	// Calling argument list
+#define N(n) "",""	// Null argument list
+void VerilatedCov::_insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
+			     A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19),
+			     A(20),A(21),A(22),A(23),A(24),A(25),A(26),A(27),A(28),A(29)) {
+    const char* keyps[VerilatedCovImpBase::MAX_KEYS]
+	= {NULL,NULL,NULL,	// filename,lineno,page
+	   key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
+	   key10,key11,key12,key13,key14,key15,key16,key17,key18,key19,
+	   key20,key21,key22,key23,key24,key25,key26,key27,key28,key29};
+    const char* valps[VerilatedCovImpBase::MAX_KEYS]
+	= {NULL,NULL,NULL,	// filename,lineno,page
+	   val0,val1,val2,val3,val4,val5,val6,val7,val8,val9,
+	   val10,val11,val12,val13,val14,val15,val16,val17,val18,val19,
+	   val20,val21,val22,val23,val24,val25,val26,val27,val28,val29};
+    VerilatedCovImp::imp().insertp(keyps, valps);
+}
+
+// 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)) {
+    _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)) {
+    _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);
+    _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),
+	     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));
+}
+#undef A
+#undef C
+#undef N
+#undef K

include/verilated_cov.h

@@ -0,0 +1,131 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// This is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+//
+//=============================================================================
+///
+/// \file
+/// \brief Coverage analysis support
+///
+//=============================================================================
+
+#ifndef _VERILATED_COV_H_
+#define _VERILATED_COV_H_ 1
+
+#include "verilatedos.h"
+
+#include <iostream>
+#include <sstream>
+#include <string>
+using namespace std;
+
+//=============================================================================
+/// Conditionally compile coverage code
+
+#ifdef VM_COVERAGE
+# define VL_IF_COVER(stmts) do { stmts ; } while(0)
+#else
+# define VL_IF_COVER(stmts) do { if(0) { stmts ; } } while(0)
+#endif
+
+//=============================================================================
+/// Insert a item for coverage analysis.
+/// The first argument is a pointer to the count to be dumped.
+/// The remaining arguments occur in pairs: A string key, and a value.
+/// The value may be a string, or another type which will be auto-converted to a string.
+///
+/// Some typical keys:
+///	filename	File the recording occurs in.  Defaults to __FILE__
+///	lineno		Line number the recording occurs in.  Defaults to __LINE__
+///	column		Column number (or occurrence# for dup file/lines).  Defaults to undef.
+///	hier		Hierarchical name.  Defaults to name()
+///	type		Type of coverage.  Defaults to "user"
+///			Other types are 'block', 'fsm', 'toggle'.
+///	comment		Description of the coverage event.  Should be set by the user.
+///			Comments for type==block: 'if', 'else', 'elsif', 'case'
+///	thresh		Threshold to consider fully covered.
+///			If unspecified, downstream tools will determine it.
+///
+/// Examples:
+///
+///	vluint32_t m_cases[10];
+///	constructor {
+///	    for (int i=0; i<10; i++) { m_cases[i]=0; }
+///     }
+///	for (int i=0; i<10; i++) {
+///		VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i));
+///	}
+
+#define VL_COVER_INSERT(countp,args...) \
+    VL_IF_COVER(VerilatedCov::_inserti(countp);	\
+		VerilatedCov::_insertf(__FILE__,__LINE__);	\
+		VerilatedCov::_insertp("hier", name(), args))
+
+//=============================================================================
+/// Convert VL_COVER_INSERT value arguments to strings
+
+template< class T> std::string vlCovCvtToStr (const T& t) {
+    ostringstream os; os<<t; return os.str();
+}
+
+//=============================================================================
+//  VerilatedCov
+///  Verilator coverage global class
+////
+/// Global class with methods affecting all coverage data.
+
+class VerilatedCov {
+public:
+    // GLOBAL METHODS
+    /// Return default filename
+    static const char* defaultFilename() { return "coverage.dat"; }
+    /// Write all coverage data to a file
+    static void write (const char* filenamep = defaultFilename());
+    /// 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);
+    // _insert2: Set default filename and line number
+    static void _insertf (const char* filename, int lineno);
+    // _insert3: Set parameters
+    // We could have just the maximum argument version, but this compiles
+    // much slower (nearly 2x) than having smaller versions also.  However
+    // there's not much more gain in having a version for each number of args.
+#define K(n) const char* key ## n
+#define A(n) const char* key ## n, const char* valp ## n	// Argument list
+#define D(n) const char* key ## n = NULL, const char* valp ## n = NULL	// Argument list
+    static void _insertp (D(0),D(1),D(2),D(3),D(4),D(5),D(6),D(7),D(8),D(9));
+    static void _insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
+			  ,A(10),D(11),D(12),D(13),D(14),D(15),D(16),D(17),D(18),D(19));
+    static void _insertp (A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9)
+			  ,A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)
+			  ,A(20),D(21),D(22),D(23),D(24),D(25),D(26),D(27),D(28),D(29));
+    // 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));
+
+#undef K
+#undef A
+#undef D
+    /// Clear coverage points (and call delete on all items)
+    static void clear();
+    /// Clear items not matching the provided string
+    static void clearNonMatch (const char* matchp);
+    /// Zero coverage points
+    static void zero();
+};
+
+#endif // guard

include/verilated_cov_key.h

@@ -0,0 +1,145 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
+// you can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
+//
+// This is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+//
+//=============================================================================
+///
+/// \file
+/// \brief Coverage item keys
+///
+//=============================================================================
+
+#ifndef _VERILATED_COV_KEY_H_
+#define _VERILATED_COV_KEY_H_ 1
+
+#include "verilatedos.h"
+
+#include <string>
+using namespace std;
+
+//=============================================================================
+// Data used to edit below file, using vlcovgen
+
+#define VLCOVGEN_ITEM(string_parsed_by_vlcovgen)
+
+VLCOVGEN_ITEM("name=>'col0_name',   short=>'C0', group=>1, default=>undef, descr=>'The column title for the header line of this column'")
+VLCOVGEN_ITEM("name=>'col1_name',   short=>'C1', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'col2_name',   short=>'C2', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'col3_name',   short=>'C3', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'column',      short=>'n',  group=>1, default=>0,     descr=>'Column number for the item.  Used to disambiguate multiple coverage points on the same line number'")
+VLCOVGEN_ITEM("name=>'filename',    short=>'f',  group=>1, default=>undef, descr=>'Filename of the item'")
+VLCOVGEN_ITEM("name=>'groupdesc',   short=>'d',  group=>1, default=>'',    descr=>'Description of the covergroup this item belongs to'")
+VLCOVGEN_ITEM("name=>'groupname',   short=>'g',  group=>1, default=>'',    descr=>'Group name of the covergroup this item belongs to'")
+VLCOVGEN_ITEM("name=>'groupcmt',    short=>'O',  group=>1, default=>'',    ")
+VLCOVGEN_ITEM("name=>'per_instance',short=>'P',  group=>1, default=>0,     descr=>'True if every hierarchy is independently counted; otherwise all hierarchies will be combined into a single count'")
+VLCOVGEN_ITEM("name=>'row0_name',   short=>'R0', group=>1, default=>undef, descr=>'The row title for the header line of this row'")
+VLCOVGEN_ITEM("name=>'row1_name',   short=>'R1', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'row2_name',   short=>'R2', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'row3_name',   short=>'R3', group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'table',       short=>'T',  group=>1, default=>undef, descr=>'The name of the table for automatically generated tables'")
+VLCOVGEN_ITEM("name=>'thresh',      short=>'s',  group=>1, default=>undef, ")
+VLCOVGEN_ITEM("name=>'type',        short=>'t',  group=>1, default=>'',    descr=>'Type of coverage (block, line, fsm, etc)'")
+// Bin attributes
+VLCOVGEN_ITEM("name=>'col0',        short=>'c0', group=>0, default=>undef, descr=>'The (enumeration) value name for this column in a table cross' ")
+VLCOVGEN_ITEM("name=>'col1',        short=>'c1', group=>0, default=>undef, ")
+VLCOVGEN_ITEM("name=>'col2',        short=>'c2', group=>0, default=>undef, ")
+VLCOVGEN_ITEM("name=>'col3',        short=>'c3', group=>0, default=>undef, ")
+VLCOVGEN_ITEM("name=>'comment',     short=>'o',  group=>0, default=>'',    descr=>'Textual description for the item'")
+VLCOVGEN_ITEM("name=>'hier',        short=>'h',  group=>0, default=>'',    descr=>'Hierarchy path name for the item'")
+VLCOVGEN_ITEM("name=>'limit',       short=>'L',  group=>0, default=>undef, ")
+VLCOVGEN_ITEM("name=>'lineno',      short=>'l',  group=>0, default=>0,     descr=>'Line number for the item'")
+VLCOVGEN_ITEM("name=>'row0',        short=>'r0', group=>0, default=>undef, descr=>'The (enumeration) value name for this row in a table cross'")
+VLCOVGEN_ITEM("name=>'row1',        short=>'r1', group=>0, default=>undef, ")
+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"
+#define VL_CIK_COL1 "c1"
+#define VL_CIK_COL1_NAME "C1"
+#define VL_CIK_COL2 "c2"
+#define VL_CIK_COL2_NAME "C2"
+#define VL_CIK_COL3 "c3"
+#define VL_CIK_COL3_NAME "C3"
+#define VL_CIK_COLUMN "n"
+#define VL_CIK_COMMENT "o"
+#define VL_CIK_FILENAME "f"
+#define VL_CIK_GROUPCMT "O"
+#define VL_CIK_GROUPDESC "d"
+#define VL_CIK_GROUPNAME "g"
+#define VL_CIK_HIER "h"
+#define VL_CIK_LIMIT "L"
+#define VL_CIK_LINENO "l"
+#define VL_CIK_PER_INSTANCE "P"
+#define VL_CIK_ROW0 "r0"
+#define VL_CIK_ROW0_NAME "R0"
+#define VL_CIK_ROW1 "r1"
+#define VL_CIK_ROW1_NAME "R1"
+#define VL_CIK_ROW2 "r2"
+#define VL_CIK_ROW2_NAME "R2"
+#define VL_CIK_ROW3 "r3"
+#define VL_CIK_ROW3_NAME "R3"
+#define VL_CIK_TABLE "T"
+#define VL_CIK_THRESH "s"
+#define VL_CIK_TYPE "t"
+#define VL_CIK_WEIGHT "w"
+// VLCOVGEN_CIK_AUTO_EDIT_END
+
+class VerilatedCovKey {
+public:
+    static string shortKey(const string& key) {
+	// VLCOVGEN_SHORT_AUTO_EDIT_BEGIN
+	if (key == "col0") return VL_CIK_COL0;
+	if (key == "col0_name") return VL_CIK_COL0_NAME;
+	if (key == "col1") return VL_CIK_COL1;
+	if (key == "col1_name") return VL_CIK_COL1_NAME;
+	if (key == "col2") return VL_CIK_COL2;
+	if (key == "col2_name") return VL_CIK_COL2_NAME;
+	if (key == "col3") return VL_CIK_COL3;
+	if (key == "col3_name") return VL_CIK_COL3_NAME;
+	if (key == "column") return VL_CIK_COLUMN;
+	if (key == "comment") return VL_CIK_COMMENT;
+	if (key == "filename") return VL_CIK_FILENAME;
+	if (key == "groupcmt") return VL_CIK_GROUPCMT;
+	if (key == "groupdesc") return VL_CIK_GROUPDESC;
+	if (key == "groupname") return VL_CIK_GROUPNAME;
+	if (key == "hier") return VL_CIK_HIER;
+	if (key == "limit") return VL_CIK_LIMIT;
+	if (key == "lineno") return VL_CIK_LINENO;
+	if (key == "per_instance") return VL_CIK_PER_INSTANCE;
+	if (key == "row0") return VL_CIK_ROW0;
+	if (key == "row0_name") return VL_CIK_ROW0_NAME;
+	if (key == "row1") return VL_CIK_ROW1;
+	if (key == "row1_name") return VL_CIK_ROW1_NAME;
+	if (key == "row2") return VL_CIK_ROW2;
+	if (key == "row2_name") return VL_CIK_ROW2_NAME;
+	if (key == "row3") return VL_CIK_ROW3;
+	if (key == "row3_name") return VL_CIK_ROW3_NAME;
+	if (key == "table") return VL_CIK_TABLE;
+	if (key == "thresh") return VL_CIK_THRESH;
+	if (key == "type") return VL_CIK_TYPE;
+	if (key == "weight") return VL_CIK_WEIGHT;
+	// VLCOVGEN_SHORT_AUTO_EDIT_END
+	return key;
+    }
+};
+
+#endif // guard

include/verilated_dpi.cpp

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -82,7 +82,7 @@ void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
 void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
-void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w) {
+void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
     _VL_SVDPI_UNIMP();
 }
 
@@ -104,9 +104,6 @@ int svHigh(const svOpenArrayHandle h, int d) {
 int svIncrement(const svOpenArrayHandle h, int d) {
     _VL_SVDPI_UNIMP(); return 0;
 }
-int svLength(const svOpenArrayHandle h, int d) {
-    _VL_SVDPI_UNIMP(); return 0;
-}
 int svDimensions(const svOpenArrayHandle h) {
     _VL_SVDPI_UNIMP(); return 0;
 }

include/verilated_dpi.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.

include/verilated_heavy.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2010-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2010-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -41,11 +41,28 @@ inline string VL_CVT_PACK_STR_NQ(QData lhs) {
     IData lw[2];  VL_SET_WQ(lw, lhs);
     return VL_CVT_PACK_STR_NW(2, lw);
 }
+inline string VL_CVT_PACK_STR_NN(const string& lhs) {
+    return lhs;
+}
 inline string VL_CVT_PACK_STR_NI(IData lhs) {
     IData lw[1];  lw[0] = lhs;
     return VL_CVT_PACK_STR_NW(1, lw);
 }
+inline string VL_CONCATN_NNN(const string& lhs, const string& rhs) {
+    return lhs+rhs;
+}
+inline string VL_REPLICATEN_NNQ(int,int,int, const string& lhs, IData rep) {
+    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) {
+    return VL_REPLICATEN_NNQ(obits,lbits,rbits,lhs,rep);
+}
 
+extern IData VL_FOPEN_NI(const string& filename, IData mode);
+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, ...);
 
 #endif // Guard

include/verilated_imp.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -49,7 +49,6 @@ class VerilatedImp {
     // TYPES
     typedef vector<string> ArgVec;
     typedef map<pair<const void*,void*>,void*> UserMap;
-    typedef map<const char*, const VerilatedScope*, VerilatedCStrCmp>  ScopeNameMap;
     typedef map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
 
     // MEMBERS
@@ -60,7 +59,7 @@ class VerilatedImp {
     ArgVec		m_argVec;	///< Argument list (NOT save-restored, may want different results)
     bool		m_argVecLoaded;	///< Ever loaded argument list
     UserMap	 	m_userMap;	///< Map of <(scope,userkey), userData>
-    ScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
+    VerilatedScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
     // Slow - somewhat static:
     ExportNameMap	m_exportMap;	///< Map of <export_func_proto, func number>
     int			m_exportNext;	///< Next export funcnum
@@ -78,6 +77,18 @@ public: // But only for verilated*.cpp
 	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());
+	}
+	VL_PRINTF("\n");
+	VL_PRINTF("  Version: %s %s\n", Verilated::productName(), Verilated::productVersion());
+	scopesDump();
+	exportsDump();
+	userDump();
+    }
 
     // METHODS - arguments
     static void commandArgs(int argc, const char** argv) {
@@ -129,36 +140,46 @@ private:
 	    }
 	}
     }
+    static void userDump() {
+	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",
+		      it->first.first, it->first.second, it->second);
+	}
+    }
 
 public: // But only for verilated*.cpp
     // METHODS - scope name
     static void scopeInsert(const VerilatedScope* scopep) {
 	// Slow ok - called once/scope at construction
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
 	if (it == s_s.m_nameMap.end()) {
 	    s_s.m_nameMap.insert(it, make_pair(scopep->name(),scopep));
 	}
     }
     static inline const VerilatedScope* scopeFind(const char* namep) {
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(namep);
 	if (VL_LIKELY(it != s_s.m_nameMap.end())) return it->second;
 	else return NULL;
     }
     static void scopeErase(const VerilatedScope* scopep) {
 	// Slow ok - called once/scope at destruction
 	userEraseScope(scopep);
-	ScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
 	if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
     }
-
     static void scopesDump() {
-	VL_PRINTF("scopesDump:\n");
-	for (ScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
+	VL_PRINTF("  scopesDump:\n");
+	for (VerilatedScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
 	    const VerilatedScope* scopep = it->second;
 	    scopep->scopeDump();
 	}
 	VL_PRINTF("\n");
     }
+    static const VerilatedScopeNameMap* scopeNameMap() {
+        return &s_s.m_nameMap;
+    }
 
 public: // But only for verilated*.cpp
     // METHODS - export names
@@ -194,6 +215,13 @@ public: // But only for verilated*.cpp
 	}
 	return "*UNKNOWN*";
     }
+    static void exportsDump() {
+	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);
+	}
+    }
     // We don't free up m_exportMap until the end, because we can't be sure
     // what other models are using the assigned funcnum's.
 

include/verilated_save.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2013 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
 // you can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #include "verilatedos.h"
@@ -62,8 +60,9 @@ bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t siz
 
 VerilatedDeserialize& VerilatedDeserialize::readAssert (const void* __restrict datap, size_t size) {
     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(filename().c_str(), 0, "", msg.c_str());
+	vl_fatal(fn.c_str(), 0, "", msg.c_str());
 	close();
     }
     return *this;  // For function chaining
@@ -82,8 +81,9 @@ void VerilatedSerialize::header() {
 void VerilatedDeserialize::header() {
     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(filename().c_str(), 0, "", msg.c_str());
+	vl_fatal(fn.c_str(), 0, "", msg.c_str());
 	close();
     }
     os.read(Verilated::serializedPtr(), Verilated::serializedSize());
@@ -98,8 +98,9 @@ void VerilatedSerialize::trailer() {
 void VerilatedDeserialize::trailer() {
     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(filename().c_str(), 0, "", msg.c_str());
+	vl_fatal(fn.c_str(), 0, "", msg.c_str());
 	close();
     }
 }
@@ -116,6 +117,7 @@ void VerilatedSave::open (const char* filenamep) {
     if (filenamep[0]=='|') {
 	assert(0);	// Not supported yet.
     } else {
+	// cppcheck-suppress duplicateExpression
 	m_fd = ::open (filenamep, O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
 		       , 0666);
 	if (m_fd<0) {
@@ -137,6 +139,7 @@ void VerilatedRestore::open (const char* filenamep) {
     if (filenamep[0]=='|') {
 	assert(0);	// Not supported yet.
     } else {
+	// cppcheck-suppress duplicateExpression
 	m_fd = ::open (filenamep, O_CREAT|O_RDONLY|O_LARGEFILE
 		       , 0666);
 	if (m_fd<0) {

include/verilated_save.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-2013 by Wilson Snyder.  This program is free software;
+// Copyright 2012-2015 by Wilson Snyder.  This program is free software;
 // you can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief Save-restore serialization of verilated modules
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 
 #ifndef _VERILATED_SAVE_C_H_
@@ -50,6 +48,8 @@ protected:
 	m_bufp = new vluint8_t [bufferSize()];
 	m_cp = m_bufp;
     }
+private:
+    VerilatedSerialBase(const VerilatedSerialBase& );	///< N/A, no copy constructor
 public:
     // CREATORS
     virtual ~VerilatedSerialBase() {
@@ -109,7 +109,7 @@ protected:
     void trailer();
 public:
     // CREATORS
-    VerilatedDeserialize() {}
+    VerilatedDeserialize() { m_endp = NULL; }
     virtual ~VerilatedDeserialize() { close(); }
     // METHODS
     inline VerilatedDeserialize& read (void* __restrict datap, size_t size) {
@@ -146,7 +146,7 @@ private:
 
 public:
     // CREATORS
-    VerilatedSave() {}
+    VerilatedSave() { m_fd=-1; }
     virtual ~VerilatedSave() { close(); }
     // METHODS
     void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
@@ -164,7 +164,7 @@ private:
 
 public:
     // CREATORS
-    VerilatedRestore() {}
+    VerilatedRestore() { m_fd=-1; }
     virtual ~VerilatedRestore() { close(); }
 
     // METHODS
@@ -225,7 +225,7 @@ inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   string& rhs) {
     return os.write(rhs.data(), len);
 }
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, string& rhs) {
-    vluint32_t len;
+    vluint32_t len=0;
     os>>len;
     rhs.resize(len);
     return os.read((void*)rhs.data(), len);

include/verilated_sc.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.

include/verilated_syms.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -32,32 +32,23 @@
 
 #include <map>
 
-//======================================================================
-// Types
-
-struct VerilatedCStrCmp {
-    /// Ordering maps keyed by const char*'s
-    bool operator() (const char *a, const char *b) const {
-	return std::strcmp(a, b) < 0;
-    }
-};
-
 //===========================================================================
 /// Verilator range
 
+// See also V3Ast::VNumRange
 class VerilatedRange { 
-    int		m_lhs;
-    int		m_rhs;
+    int		m_left;
+    int		m_right;
 protected:
     friend class VerilatedVar;
     friend class VerilatedScope;
-    VerilatedRange() : m_lhs(0), m_rhs(0) {}
-    void sets(int lhs, int rhs) { m_lhs=lhs; m_rhs=rhs; }
+    VerilatedRange() : m_left(0), m_right(0) {}
+    void sets(int left, int right) { m_left=left; m_right=right; }
 public:
     ~VerilatedRange() {}
-    int lhs() const { return m_lhs; }
-    int rhs() const { return m_rhs; }
-    int bits() const { return (VL_LIKELY(m_lhs>=m_rhs)?(m_lhs-m_rhs+1):(m_rhs-m_lhs+1)); }
+    int left() const { return m_left; }
+    int right() const { return m_right; }
+    int elements() const { return (VL_LIKELY(m_left>=m_right)?(m_left-m_right+1):(m_right-m_left+1)); }
 };
 
 //===========================================================================
@@ -92,7 +83,22 @@ public:
 //======================================================================
 /// Types
 
-struct VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
+struct VerilatedCStrCmp {
+    /// Ordering maps keyed by const char*'s
+    bool operator() (const char *a, const char *b) const {
+	return std::strcmp(a, b) < 0;
+    }
+};
+
+class VerilatedScopeNameMap
+    : public map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
+public:
+    VerilatedScopeNameMap() {}
+    ~VerilatedScopeNameMap() {}
+};
+
+class VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
+public:
     VerilatedVarNameMap() {}
     ~VerilatedVarNameMap() {}
 };

include/verilated_vcd_c.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2013 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
 // you can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 
@@ -57,7 +55,7 @@ vector<VerilatedVcd*>	VerilatedVcd::s_vcdVecp;	///< List of all created traces
 // VerilatedVcdCallInfo
 /// Internal callback routines for each module being traced.
 ////
-/// Each SystemPerl module that wishes to be traced registers a set of
+/// Each module that wishes to be traced registers a set of
 /// callbacks stored in this class.  When the trace file is being
 /// constructed, this class provides the callback routines to be executed.
 
@@ -76,11 +74,48 @@ protected:
 	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
 };
 
+//=============================================================================
+//=============================================================================
+//=============================================================================
+// VerilatedVcdFile
+
+bool VerilatedVcdFile::open(const string& name) {
+    m_fd = ::open(name.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK, 0666);
+    return (m_fd>=0);
+}
+
+void VerilatedVcdFile::close() {
+    ::close(m_fd);
+}
+
+ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) {
+    return ::write(m_fd, bufp, len);
+}
+
 //=============================================================================
 //=============================================================================
 //=============================================================================
 // Opening/Closing
 
+VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
+    : m_isOpen(false), m_rolloverMB(0), m_modDepth(0), m_nextCode(1) {
+    // Not in header to avoid link issue if header is included without this .cpp file
+    m_fileNewed = (filep == NULL);
+    m_filep = m_fileNewed ? new VerilatedVcdFile : filep;
+    m_namemapp = NULL;
+    m_timeRes = m_timeUnit = 1e-9;
+    m_timeLastDump = 0;
+    m_sigs_oldvalp = NULL;
+    m_evcd = false;
+    m_scopeEscape = '.';  // Backward compatibility
+    m_fullDump = true;
+    m_wrChunkSize = 8*1024;
+    m_wrBufp = new char [m_wrChunkSize*8];
+    m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
+    m_writep = m_wrBufp;
+    m_wroteBytes = 0;
+}
+
 void VerilatedVcd::open (const char* filename) {
     if (isOpen()) return;
 
@@ -141,9 +176,8 @@ void VerilatedVcd::openNext (bool incFilename) {
     if (m_filename[0]=='|') {
 	assert(0);	// Not supported yet.
     } else {
-	m_fd = ::open (m_filename.c_str(), O_CREAT|O_WRONLY|O_TRUNC|O_LARGEFILE|O_NONBLOCK
-		       , 0666);
-	if (m_fd<0) {
+	// cppcheck-suppress duplicateExpression
+	if (!m_filep->open(m_filename)) {
 	    // User code can check isOpen()
 	    m_isOpen = false;
 	    return;
@@ -156,6 +190,8 @@ void VerilatedVcd::openNext (bool incFilename) {
 
 void VerilatedVcd::makeNameMap() {
     // Take signal information from each module and build m_namemapp
+    deleteNameMap();
+    m_nextCode = 1;
     m_namemapp = new NameMap;
     for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
 	VerilatedVcdCallInfo *cip = m_callbacks[ent];
@@ -169,8 +205,8 @@ void VerilatedVcd::makeNameMap() {
     // 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 char* hiername = (*it).first.c_str();
-	if (hiername[0] == '\t') nullScope=true;
+	const string& hiername = it->first;
+	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
     }
     if (nullScope) {
 	NameMap* newmapp = new NameMap;
@@ -182,15 +218,21 @@ void VerilatedVcd::makeNameMap() {
 	    newname += hiername;
 	    newmapp->insert(make_pair(newname,decl));
 	}
-	delete m_namemapp; m_namemapp=NULL;
+	deleteNameMap();
 	m_namemapp = newmapp;
     }
 }
 
+void VerilatedVcd::deleteNameMap() {
+    if (m_namemapp) { delete m_namemapp; m_namemapp=NULL; }
+}
+
 VerilatedVcd::~VerilatedVcd() {
     close();
     if (m_wrBufp) { delete[] m_wrBufp; m_wrBufp=NULL; }
     if (m_sigs_oldvalp) { delete[] m_sigs_oldvalp; m_sigs_oldvalp=NULL; }
+    deleteNameMap();
+    if (m_filep && m_fileNewed) { delete m_filep; m_filep = NULL; }
     // Remove from list of traces
     vector<VerilatedVcd*>::iterator pos = find(s_vcdVecp.begin(), s_vcdVecp.end(), this);
     if (pos != s_vcdVecp.end()) { s_vcdVecp.erase(pos); }
@@ -201,7 +243,7 @@ void VerilatedVcd::closePrev () {
 
     bufferFlush();
     m_isOpen = false;
-    ::close(m_fd);
+    m_filep->close();
 }
 
 void VerilatedVcd::closeErr () {
@@ -211,7 +253,7 @@ void VerilatedVcd::closeErr () {
 
     // No buffer flush, just fclose
     m_isOpen = false;
-    ::close(m_fd);  // May get error, just ignore it
+    m_filep->close();  // May get error, just ignore it
 }
 
 void VerilatedVcd::close() {
@@ -253,6 +295,20 @@ void VerilatedVcd::printTime (vluint64_t timeui) {
     printQuad(timeui);
 }
 
+void VerilatedVcd::bufferResize(vluint64_t minsize) {
+    // minsize is size of largest write.  We buffer at least 8 times as much data,
+    // writing when we are 3/4 full (with thus 2*minsize remaining free)
+    if (VL_UNLIKELY(minsize > m_wrChunkSize)) {
+	char* oldbufp = m_wrBufp;
+	m_wrChunkSize = minsize*2;
+	m_wrBufp = new char [m_wrChunkSize * 8];
+	memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
+        m_writep = m_wrBufp + (m_writep - oldbufp);
+	m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
+	delete oldbufp; oldbufp=NULL;
+    }
+}
+
 void VerilatedVcd::bufferFlush () {
     // We add output data to m_writep.
     // When it gets nearly full we dump it using this routine which calls write()
@@ -263,7 +319,7 @@ void VerilatedVcd::bufferFlush () {
 	ssize_t remaining = (m_writep - wp);
 	if (remaining==0) break;
 	errno = 0;
-	ssize_t got = write (m_fd, wp, remaining);
+	ssize_t got = m_filep->write(wp, remaining);
 	if (got>0) {
 	    wp += got;
 	    m_wroteBytes += got;
@@ -286,13 +342,11 @@ void VerilatedVcd::bufferFlush () {
 // Simple methods
 
 void VerilatedVcd::set_time_unit (const char* unitp) {
-    string unitstr (unitp);
     //cout<<" set_time_unit ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeUnit = timescaleToDouble(unitp);
 }
 
 void VerilatedVcd::set_time_resolution (const char* unitp) {
-    string unitstr (unitp);
     //cout<<"set_time_resolution ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
     m_timeRes = timescaleToDouble(unitp);
 }
@@ -324,7 +378,7 @@ string VerilatedVcd::doubleToTimescale (double value) {
     else if (value>=1e-12) { suffixp="ps"; value *= 1e12; }
     else if (value>=1e-15) { suffixp="fs"; value *= 1e15; }
     else if (value>=1e-18) { suffixp="as"; value *= 1e18; }
-    char valuestr[100]; sprintf(valuestr,"%d%s",(int)(value), suffixp);
+    char valuestr[100]; sprintf(valuestr,"%3.0f%s", value, suffixp);
     return valuestr;  // Gets converted to string, so no ref to stack
 }
 
@@ -344,7 +398,8 @@ void VerilatedVcd::dumpHeader () {
     printStr("$date "); printStr(ctime(&time_str)); printStr(" $end\n");
 
     printStr("$timescale ");
-    printStr(doubleToTimescale(m_timeRes).c_str());
+    const string& timeResStr = doubleToTimescale(m_timeRes);
+    printStr(timeResStr.c_str());
     printStr(" $end\n");
 
     makeNameMap();
@@ -362,10 +417,11 @@ void VerilatedVcd::dumpHeader () {
     // Print the signal names
     const char* lastName = "";
     for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
-	const char* hiername = (*it).first.c_str();
-	const char* decl     = (*it).second.c_str();
+	const string& hiernamestr = it->first;
+	const string& decl = it->second;
 
 	// Determine difference between the old and new names
+	const char* hiername = hiernamestr.c_str();
 	const char* lp = lastName;
 	const char* np = hiername;
 	lastName = hiername;
@@ -400,7 +456,7 @@ void VerilatedVcd::dumpHeader () {
 	}
 
 	printIndent(0);
-	printStr(decl);
+	printStr(decl.c_str());
     }
 
     while (m_modDepth>1) {
@@ -413,10 +469,10 @@ void VerilatedVcd::dumpHeader () {
     assert (m_modDepth==0);
 
     // Reclaim storage
-    delete m_namemapp;
+    deleteNameMap();
 }
 
-void VerilatedVcd::module (string name) {
+void VerilatedVcd::module (const string& name) {
     m_modName = name;
 }
 
@@ -434,6 +490,9 @@ void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep
 	m_sigs.reserve(m_nextCode*2);	// Power-of-2 allocation speeds things up
     }
 
+    // Make sure write buffer is large enough (one character per bit), plus header
+    bufferResize(bits+1024);
+
     // Save declaration info
     VerilatedVcdSig sig = VerilatedVcdSig(code, bits);
     m_sigs.push_back(sig);
@@ -512,7 +571,7 @@ 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;
-    // Buffer can't overflow; we have at least bufferInsertSize() bytes (>>>16 bytes)
+    // Buffer can't overflow before sprintf; we sized during declaration
     sprintf(m_writep, "r%.16g", newval);
     m_writep += strlen(m_writep);
     *m_writep++=' '; printCode(code); *m_writep++='\n';
@@ -520,7 +579,7 @@ void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
 }
 void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
     (*((float*)&m_sigs_oldvalp[code])) = newval;
-    // Buffer can't overflow; we have at least bufferInsertSize() bytes (>>>16 bytes)
+    // Buffer can't overflow before sprintf; we sized during declaration
     sprintf(m_writep, "r%.16g", (double)newval);
     m_writep += strlen(m_writep);
     *m_writep++=' '; printCode(code); *m_writep++='\n';
@@ -693,5 +752,5 @@ main() {
 
 //********************************************************************
 // Local Variables:
-// compile-command: "mkdir -p ../test_dir && cd ../test_dir && g++ -DVERILATED_VCD_TEST ../src/verilated_vcd_c.cpp -o verilated_vcd_c && ./verilated_vcd_c && cat test.vcd"
+// compile-command: "mkdir -p ../test_dir && cd ../test_dir && c++ -DVERILATED_VCD_TEST ../src/verilated_vcd_c.cpp -o verilated_vcd_c && ./verilated_vcd_c && cat test.vcd"
 // End:

include/verilated_vcd_c.h

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2013 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2015 by Wilson Snyder.  This program is free software;
 // you can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License Version 2.0.
 //
@@ -17,8 +17,6 @@
 /// \file
 /// \brief C++ Tracing in VCD Format
 ///
-/// AUTHOR:  Wilson Snyder
-///
 //=============================================================================
 // SPDIFF_OFF
 
@@ -36,6 +34,22 @@ class VerilatedVcd;
 class VerilatedVcdCallInfo;
 
 // SPDIFF_ON
+//=============================================================================
+// VerilatedFile
+/// File handling routines, which can be overrode for e.g. socket I/O
+
+class VerilatedVcdFile {
+private:
+    int			m_fd;		///< File descriptor we're writing to
+public:
+    // METHODS
+    VerilatedVcdFile() : m_fd(0) {}
+    virtual ~VerilatedVcdFile() {}
+    virtual bool open(const string& name);
+    virtual void close();
+    virtual ssize_t write(const char* bufp, ssize_t len);
+};
+
 //=============================================================================
 // VerilatedVcdSig
 /// Internal data on one signal being traced.
@@ -57,13 +71,15 @@ typedef void (*VerilatedVcdCallback_t)(VerilatedVcd* vcdp, void* userthis, vluin
 
 //=============================================================================
 // VerilatedVcd
-/// Create a SystemPerl VCD dump
+/// Base class to create a Verilator VCD dump
+/// This is an internally used class - see VerilatedVcdC for what to call from applications
 
 class VerilatedVcd {
 private:
+    VerilatedVcdFile*	m_filep;	///< File we're writing to
+    bool		m_fileNewed;	///< m_filep needs destruction
     bool 		m_isOpen;	///< True indicates open file
     bool		m_evcd;		///< True for evcd format
-    int			m_fd;		///< File descriptor we're writing to
     string		m_filename;	///< Filename we're writing to (if open)
     vluint64_t		m_rolloverMB;	///< MB of file size to rollover at
     char		m_scopeEscape;	///< Character to separate scope components
@@ -76,7 +92,9 @@ private:
     vluint64_t		m_timeLastDump;	///< Last time we did a dump
 
     char*		m_wrBufp;	///< Output buffer
+    char*		m_wrFlushp;	///< Output buffer flush trigger location
     char*		m_writep;	///< Write pointer into output buffer
+    vluint64_t		m_wrChunkSize;	///< Output buffer size
     vluint64_t		m_wroteBytes;	///< Number of bytes written to this file
 
     vluint32_t*			m_sigs_oldvalp;	///< Pointer to old signal values
@@ -86,13 +104,12 @@ private:
     NameMap*			m_namemapp;	///< List of names for the header
     static vector<VerilatedVcd*>	s_vcdVecp;	///< List of all created traces
 
-    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
-    inline static size_t bufferInsertSize() { return 16*1024; }
+    void bufferResize(vluint64_t minsize);
     void bufferFlush();
-    void bufferCheck() {
+    inline void bufferCheck() {
 	// Flush the write buffer if there's not enough space left for new information
 	// We only call this once per vector, so we need enough slop for a very wide "b###" line
-	if (VL_UNLIKELY(m_writep > (m_wrBufp+(bufferSize()-bufferInsertSize())))) {
+	if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
 	    bufferFlush();
 	}
     }
@@ -100,6 +117,7 @@ private:
     void closeErr();
     void openNext();
     void makeNameMap();
+    void deleteNameMap();
     void printIndent (int levelchange);
     void printStr (const char* str);
     void printQuad (vluint64_t n);
@@ -126,25 +144,15 @@ private:
 	return out + ((char)((code)%94+33));
     }
 
+    VerilatedVcd(const VerilatedVcd& );	///< N/A, no copy constructor
+
 protected:
     // METHODS
     void evcd(bool flag) { m_evcd = flag; }
 
 public:
     // CREATORS
-    VerilatedVcd () : m_isOpen(false), m_rolloverMB(0), m_modDepth(0), m_nextCode(1) {
-	m_wrBufp = new char [bufferSize()];
-	m_writep = m_wrBufp;
-	m_namemapp = NULL;
-	m_timeRes = m_timeUnit = 1e-9;
-	m_timeLastDump = 0;
-	m_sigs_oldvalp = NULL;
-	m_evcd = false;
-	m_scopeEscape = '.';  // Backward compatibility
-	m_wroteBytes = 0;
-	m_fd = 0;
-	m_fullDump = true;
-    }
+    explicit VerilatedVcd(VerilatedVcdFile* filep=NULL);
     ~VerilatedVcd();
 
     // ACCESSORS
@@ -186,7 +194,7 @@ public:
 		      void* userthis);
 
     /// Inside dumping routines, declare a module
-    void module (const string name);
+    void module (const string& name);
     /// Inside dumping routines, declare a signal
     void declBit      (vluint32_t code, const char* name, int arraynum);
     void declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
@@ -390,18 +398,22 @@ public:
 /// Create a VCD dump file in C standalone (no SystemC) simulations.
 
 class VerilatedVcdC {
-    VerilatedVcd		m_sptrace;	///< SystemPerl trace file being created
+    VerilatedVcd		m_sptrace;	///< Trace file being created
 public:
     // CONSTRUCTORS
-    VerilatedVcdC() {}
+    explicit VerilatedVcdC(VerilatedVcdFile* filep=NULL) : m_sptrace(filep) {}
     ~VerilatedVcdC() {}
     // ACCESSORS
     /// Is file open?
     bool isOpen() const { return m_sptrace.isOpen(); }
     // METHODS
     /// 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); }
     /// 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); }
     /// Set size in megabytes after which new file should be created
     void rolloverMB(size_t rolloverMB) { m_sptrace.rolloverMB(rolloverMB); };

include/verilated_vcd_sc.cpp

@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2013 by Wilson Snyder.  This program is free software;
+// Copyright 2001-2015 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.
 //
@@ -15,9 +15,7 @@
 //=============================================================================
 ///
 /// \file
-/// \brief SystemPerl Tracing in VCD Format
-///
-/// AUTHOR:  Wilson Snyder
+/// \brief Verilator tracing in VCD Format
 ///
 //=============================================================================
 // SPDIFF_OFF
@@ -32,6 +30,7 @@
 //--------------------------------------------------
 #if (SYSTEMC_VERSION>=20050714)
     // SystemC 2.1.v1
+// cppcheck-suppress unusedFunction
 void VerilatedVcdSc::write_comment (const std::string &) {}
 void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const char **) {}
 
@@ -76,6 +75,7 @@ void VerilatedVcdSc::trace (const unsigned int &, const std::string &, const cha
 //--------------------------------------------------
 #elif (SYSTEMC_VERSION>20011000)
     // SystemC 2.0.1
+// cppcheck-suppress unusedFunction
 void VerilatedVcdSc::write_comment (const sc_string &) {}
 void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
 
@@ -118,6 +118,7 @@ void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char
 //--------------------------------------------------
 #else
     // SystemC 1.2.1beta
+// cppcheck-suppress unusedFunction
 void VerilatedVcdSc::write_comment (const sc_string &) {}
 void VerilatedVcdSc::trace (const unsigned int &, const sc_string &, const char **) {}
 

include/verilated_vcd_sc.h

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

include/verilated_vpi.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2015 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.
@@ -19,37 +19,48 @@
 ///	This file must be compiled and linked against all objects
 ///	created from Verilator or called by Verilator that use the VPI.
 ///
-///	"//-" indicates features that are as yet unimplemented.
-///
 /// Code available from: http://www.veripool.org/verilator
 ///
 //=========================================================================
 
-#ifndef CHPI_VERILATED_VPI_H
-#define CHPI_VERILATED_VPI_H 1
+#ifndef _VERILATED_VPI_H_
+#define _VERILATED_VPI_H_ 1 ///< Header Guard
 
 #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_fatal(__FILE__,__LINE__,"",Verilated::catName("Unsupported VPI function: ",VL_FUNC))
+    _VL_VPI_ERROR(__FILE__,__LINE__,Verilated::catName("Unsupported VPI function: ",VL_FUNC));
 
 //======================================================================
 // Implementation
 
-#include <set>
-
-#define VL_DEBUG_IF_PLI VL_DEBUG_IF
-
 // Base VPI handled object
 class VerilatedVpio {
     // MEM MANGLEMENT
@@ -88,6 +99,9 @@ public:
     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; }
 };
 
@@ -101,11 +115,12 @@ 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_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); }
@@ -115,22 +130,23 @@ public:
 class VerilatedVpioConst : public VerilatedVpio {
     vlsint32_t	m_num;
 public:
-    VerilatedVpioConst(vlsint32_t num) : m_num(num) {}
+    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 {
-    vlsint32_t	m_lhs;	// Ranges can be signed
-    vlsint32_t	m_rhs;
-    bool	m_iteration;
+    const VerilatedRange* m_range;
+    vlsint32_t                  m_iteration;
 public:
-    VerilatedVpioRange(vlsint32_t lhs, vlsint32_t rhs) : m_lhs(lhs), m_rhs(rhs), m_iteration(0) {}
+    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); }
-    vlsint32_t lhs() const { return m_lhs; }
-    vlsint32_t rhs() const { return m_rhs; }
+    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() {
@@ -147,10 +163,11 @@ public:
 class VerilatedVpioScope : public VerilatedVpio {
     const VerilatedScope*	m_scopep;
 public:
-    VerilatedVpioScope(const VerilatedScope* scopep)
+    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(); }
@@ -160,16 +177,23 @@ class VerilatedVpioVar : public VerilatedVpio {
     const VerilatedVar*		m_varp;
     const VerilatedScope*	m_scopep;
     vluint8_t*			m_prevDatap;	// Previous value of data, for cbValueChange
-    vluint32_t			m_mask;		// memoized variable mask
+    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 = VL_MASK_I(varp->range().bits());
+	m_mask.u32 = VL_MASK_I(varp->range().elements());
 	m_entSize = varp->entSize();
 	m_varDatap = varp->datap();
     }
@@ -179,8 +203,16 @@ public:
     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; }
+    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;
@@ -197,16 +229,19 @@ public:
     }
 };
 
-class VerilatedVpioVarIndex : public VerilatedVpioVar {
+class VerilatedVpioMemoryWord : public VerilatedVpioVar {
 public:
-    VerilatedVpioVarIndex(const VerilatedVar* varp, const VerilatedScope* scopep,
+    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 ~VerilatedVpioVarIndex() {}
-    static inline VerilatedVpioVarIndex* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioVarIndex*>((VerilatedVpio*)h); }
+    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);
@@ -220,16 +255,18 @@ class VerilatedVpioVarIter : public VerilatedVpio {
     VerilatedVarNameMap::iterator m_it;
     bool m_started;
 public:
-    VerilatedVpioVarIter(const VerilatedScope* scopep)
+    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())) {
-	    if (VL_UNLIKELY(!m_started)) { m_it = m_scopep->varsp()->begin(); m_started=true; }
-	    else if (VL_UNLIKELY(m_it == m_scopep->varsp()->end())) return 0;
+	    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 == m_scopep->varsp()->end()) return 0;
+	    if (m_it == varsp->end()) return 0;
 	    return ((new VerilatedVpioVar(&(m_it->second), m_scopep))
 		    ->castVpiHandle());
 	} else {
@@ -238,6 +275,28 @@ public:
     }
 };
 
+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 {
@@ -250,18 +309,25 @@ struct VerilatedVpiTimedCbsCmp {
     }
 };
 
+class VerilatedVpiError;
+
 class VerilatedVpi {
     enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime+1 };	// Maxium callback reason
-    typedef set<VerilatedVpioCb*> VpioCbSet;
+    typedef list<VerilatedVpioCb*> VpioCbList;
     typedef set<pair<QData,VerilatedVpioCb*>,VerilatedVpiTimedCbsCmp > VpioTimedCbs;
 
-    VpioCbSet		m_cbObjSets[CB_ENUM_MAX_VALUE];	// Callbacks for each supported reason
+    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() {}
+    VerilatedVpi() { m_errorInfop=NULL; }
     ~VerilatedVpi() {}
     static void cbReasonAdd(VerilatedVpioCb* vop) {
 	if (vop->reason() == cbValueChange) {
@@ -270,16 +336,17 @@ public:
 	    }
 	}
 	if (VL_UNLIKELY(vop->reason() >= CB_ENUM_MAX_VALUE)) vl_fatal(__FILE__,__LINE__,"", "vpi bb reason too large");
-	s_s.m_cbObjSets[vop->reason()].insert(vop);
+	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) {
-	VpioCbSet& cbObjSet = s_s.m_cbObjSets[cbp->reason()];
-	VpioCbSet::iterator it=cbObjSet.find(cbp);
-	if (VL_LIKELY(it != cbObjSet.end())) {
-	    cbObjSet.erase(it);
+	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) {
@@ -309,19 +376,26 @@ public:
 	}
     }
     static void callCbs(vluint32_t reason) {
-	VpioCbSet& cbObjSet = s_s.m_cbObjSets[reason];
-	for (VpioCbSet::iterator it=cbObjSet.begin(); it!=cbObjSet.end();) {
-	    VerilatedVpioCb* vop = *it;
-	    ++it;  // iterator may be deleted by callback
+	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() {
-	VpioCbSet& cbObjSet = s_s.m_cbObjSets[cbValueChange];
-	for (VpioCbSet::iterator it=cbObjSet.begin(); it!=cbObjSet.end();) {
-	    VerilatedVpioCb* vop = *it;
-	    ++it;  // iterator may be deleted by callback
+	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
@@ -331,527 +405,92 @@ public:
 		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)););
-		    memcpy(prevDatap, newDatap, varop->entSize());
+                    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
 };
 
-// callback related
+#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)
 
-vpiHandle vpi_register_cb(p_cb_data cb_data_p) {
-    if (VL_UNLIKELY(!cb_data_p)) return NULL;
-    switch (cb_data_p->reason) {
-    case cbAfterDelay: {
-	QData time = 0;
-	if (cb_data_p->time) time = _VL_SET_QII(cb_data_p->time->high, cb_data_p->time->low);
-	VerilatedVpioCb* vop = new VerilatedVpioCb(cb_data_p, VL_TIME_Q()+time);
-	VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_register_cb %d %p delay=%" VL_PRI64 "d\n",cb_data_p->reason,vop,time););
-	VerilatedVpi::cbTimedAdd(vop);
-	return vop->castVpiHandle();
+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();
     }
-    case cbReadWriteSynch:		// FALLTHRU // Supported via vlt_main.cpp
-    case cbReadOnlySynch:		// FALLTHRU // Supported via vlt_main.cpp
-    case cbNextSimTime:			// FALLTHRU // Supported via vlt_main.cpp
-    case cbStartOfSimulation:		// FALLTHRU // Supported via vlt_main.cpp
-    case cbEndOfSimulation:		// FALLTHRU // Supported via vlt_main.cpp
-    case cbValueChange:			// FALLTHRU // Supported via vlt_main.cpp
-    case cbEnterInteractive:		// FALLTHRU // NOP, but need to return handle, so make object
-    case cbExitInteractive:		// FALLTHRU // NOP, but need to return handle, so make object
-    case cbInteractiveScopeChange: {	// FALLTHRU // NOP, but need to return handle, so make object
-	VerilatedVpioCb* vop = new VerilatedVpioCb(cb_data_p, 0);
-	VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_register_cb %d %p\n",cb_data_p->reason,vop););
-	VerilatedVpi::cbReasonAdd(vop);
-	return vop->castVpiHandle();
-    }
-    default:
-	_VL_VPI_UNIMP(); return NULL;
-    };
-}
-
-PLI_INT32 vpi_remove_cb(vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_remove_cb %p\n",object););
-    VerilatedVpioCb* vop = VerilatedVpioCb::castp(object);
-    if (VL_UNLIKELY(!vop)) return 0;
-    if (vop->cb_datap()->reason == cbAfterDelay) {
-	VerilatedVpi::cbTimedRemove(vop);
-    } else {
-	VerilatedVpi::cbReasonRemove(vop);
-    }
-    return 1;
-}
-
-//-void vpi_get_cb_info(vpiHandle object, p_cb_data cb_data_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-vpiHandle vpi_register_systf(p_vpi_systf_data systf_data_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-void vpi_get_systf_info(vpiHandle object, p_vpi_systf_data systf_data_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-// for obtaining handles
-
-vpiHandle vpi_handle_by_name(PLI_BYTE8* namep, vpiHandle scope) {
-    if (VL_UNLIKELY(!namep)) return NULL;
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_handle_by_name %s %p\n",namep,scope););
-    VerilatedVpioScope* voScopep = VerilatedVpioScope::castp(scope);
-    const VerilatedVar* varp;
-    const VerilatedScope* scopep;
-    string scopeAndName = namep;
-    if (voScopep) {
-	scopeAndName = string(voScopep->fullname()) + "." + namep;
-	namep = (PLI_BYTE8*)scopeAndName.c_str();
-    }
-    {
-	// This doesn't yet follow the hierarchy in the proper way
-	scopep = Verilated::scopeFind(namep);
-	if (scopep) {  // Whole thing found as a scope
-	    return (new VerilatedVpioScope(scopep))->castVpiHandle();
+    void do_callbacks() {
+        if (getError()->level >= vpiError && Verilated::fatalOnVpiError()) {
+          // Stop on vpi error/unsupported
+          vpi_unsupported();
 	}
-	const char* baseNamep = scopeAndName.c_str();
-	string scopename;
-	const char* dotp = strrchr(namep, '.');
-	if (VL_LIKELY(dotp)) {
-	    baseNamep = dotp+1;
-	    scopename = string(namep,dotp-namep);
+        // 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;
 	}
-	scopep = Verilated::scopeFind(scopename.c_str());
-	if (!scopep) return NULL;
-	varp = scopep->varFind(baseNamep);
+        vl_fatal(__FILE__, __LINE__, "", "vpi_unsupported called without error info set");
     }
-    if (!varp) return NULL;
-    return (new VerilatedVpioVar(varp, scopep))->castVpiHandle();
-}
-
-vpiHandle vpi_handle_by_index(vpiHandle object, PLI_INT32 indx) {
-    // Used to get array entries
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_handle_by_index %p %d\n",object, indx););
-    VerilatedVpioVar* varop = VerilatedVpioVar::castp(object);
-    if (VL_LIKELY(varop)) {
-	if (varop->varp()->dims()<2) return 0;
-	if (VL_LIKELY(varop->varp()->array().lhs() >= varop->varp()->array().rhs())) {
-	    if (VL_UNLIKELY(indx > varop->varp()->array().lhs() || indx < varop->varp()->array().rhs())) return 0;
-	    return (new VerilatedVpioVarIndex(varop->varp(), varop->scopep(), indx,
-					      indx - varop->varp()->array().rhs()))
-		->castVpiHandle();
-	} else {
-	    if (VL_UNLIKELY(indx < varop->varp()->array().lhs() || indx > varop->varp()->array().rhs())) return 0;
-	    return (new VerilatedVpioVarIndex(varop->varp(), varop->scopep(), indx,
-					      indx - varop->varp()->array().lhs()))
-		->castVpiHandle();
-	}
-    } else {
-	_VL_VPI_UNIMP(); return 0;
-    }
-}
-
-// for traversing relationships
-
-vpiHandle vpi_handle(PLI_INT32 type, vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_handle %d %p\n",type,object););
-    switch (type) {
-    case vpiLeftRange:  // FALLTHRU
-    case vpiRightRange: {
-	if (VerilatedVpioVar* vop = VerilatedVpioVar::castp(object)) {
-	    vluint32_t num = ((type==vpiLeftRange)
-			      ? vop->varp()->range().lhs()
-			      : vop->varp()->range().rhs());
-	    return (new VerilatedVpioConst(num))->castVpiHandle();
-	} else if (VerilatedVpioRange* vop = VerilatedVpioRange::castp(object)) {
-	    vluint32_t num = ((type==vpiLeftRange)
-			      ? vop->lhs()
-			      : vop->rhs());
-	    return (new VerilatedVpioConst(num))->castVpiHandle();
-	} else {
-	    return 0;
-	}
-    }
-    default:
-	_VL_VPI_UNIMP();
-	return 0;
-    }
-}
-
-//-vpiHandle vpi_handle_multi(PLI_INT32 type, vpiHandle refHandle1, vpiHandle refHandle2, ... ) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_iterate %d %p\n",type,object););
-    switch (type) {
-    case vpiMemoryWord: {
-	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
-	if (VL_UNLIKELY(!vop)) return 0;
-	if (vop->varp()->dims() < 2) return 0;
-	// Unsupported is multidim list
-	return ((new VerilatedVpioRange(vop->varp()->array().lhs(),
-					vop->varp()->array().rhs()))
-		->castVpiHandle());
-    }
-    case vpiReg: {
-	VerilatedVpioScope* vop = VerilatedVpioScope::castp(object);
-	if (VL_UNLIKELY(!vop)) return 0;
-	return ((new VerilatedVpioVarIter(vop->scopep()))
-		->castVpiHandle());
-    }
-    case vpiIODecl: // Skipping - we'll put under reg
-    case vpiNet: // Skipping - we'll put under reg
-	return 0;
-    default:
-	_VL_VPI_UNIMP(); return 0;
-    }
-}
-vpiHandle vpi_scan(vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_scan %p\n",object););
-    VerilatedVpio* vop = VerilatedVpio::castp(object);
-    if (VL_UNLIKELY(!vop)) return NULL;
-    return vop->dovpi_scan();
-}
-
-// for processing properties
-
-PLI_INT32 vpi_get(PLI_INT32 property, vpiHandle object) {
-    // Leave this in the header file - in many cases the compiler can constant propagate "object"
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_get %d %p\n",property,object););
-    switch (property) {
-    case vpiTimePrecision: {
-	return VL_TIME_PRECISION;
-    }
-    case vpiType: {
-	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
-	if (VL_UNLIKELY(!vop)) return 0;
-	return ((vop->varp()->dims()>1) ? vpiMemory : vpiReg);
-    }
-    case vpiDirection: {
-	// By forthought, the directions already are vpi enumerated
-	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
-	if (VL_UNLIKELY(!vop)) return 0;
-	return vop->varp()->vldir();
-    }
-    case vpiVector: {
-	VerilatedVpioVar* vop = VerilatedVpioVar::castp(object);
-	if (VL_UNLIKELY(!vop)) return 0;
-	if (vop->varp()->dims()==0) return 0;
-	else return 1;
-    }
-    default:
-	_VL_VPI_UNIMP();
-	return 0;
-    }
-}
-
-//-PLI_INT64 vpi_get64(PLI_INT32 property, vpiHandle object) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-PLI_BYTE8 *vpi_get_str(PLI_INT32 property, vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_get_str %d %p\n",property,object););
-    VerilatedVpio* vop = VerilatedVpio::castp(object);
-    if (VL_UNLIKELY(!vop)) return NULL;
-    switch (property) {
-    case vpiName: {
-	return (PLI_BYTE8*)vop->name();
-    }
-    case vpiFullName: {
-	return (PLI_BYTE8*)vop->fullname();
-    }
-    case vpiDefName: {
-	return (PLI_BYTE8*)vop->defname();
-    }
-    default:
-	_VL_VPI_UNIMP();
-	return 0;
-    }
-}
-
-// delay processing
-
-//-void vpi_get_delays(vpiHandle object, p_vpi_delay delay_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-void vpi_put_delays(vpiHandle object, p_vpi_delay delay_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-// value processing
-
-void vpi_get_value(vpiHandle object, p_vpi_value value_p) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_get_value %p\n",object););
-    if (VL_UNLIKELY(!value_p)) return;
-    if (VerilatedVpioVar* vop = VerilatedVpioVar::castp(object)) {
-	// We presume vpiValue.format = vpiIntVal or if single bit vpiScalarVal
-	if (value_p->format == vpiVectorVal) {
-	    // Vector pointer must come from our memory pool
-	    // It only needs to persist until the next vpi_get_value
-	    static VL_THREAD t_vpi_vecval out[VL_MULS_MAX_WORDS*2];
-	    value_p->value.vector = out;
-	    switch (vop->varp()->vltype()) {
-	    case VLVT_UINT8:
-		out[0].aval = *((CData*)(vop->varDatap()));
-		out[0].bval = 0;
-		return;
-	    case VLVT_UINT16:
-		out[0].aval = *((SData*)(vop->varDatap()));
-		out[0].bval = 0;
-		return;
-	    case VLVT_UINT32:
-		out[0].aval = *((IData*)(vop->varDatap()));
-		out[0].bval = 0;
-		return;
-	    case VLVT_WDATA: {
-		int words = VL_WORDS_I(vop->varp()->range().bits());
-		if (VL_UNLIKELY(words >= VL_MULS_MAX_WORDS)) {
-		    vl_fatal(__FILE__,__LINE__,"", "vpi_get_value with more than VL_MULS_MAX_WORDS; increase and recompile");
-		}
-		WDataInP datap = ((IData*)(vop->varDatap()));
-		for (int i=0; i<words; i++) {
-		    out[i].aval = datap[i];
-		    out[i].bval = 0;
-		}
-		return;
-	    }
-	    case VLVT_UINT64: {
-		QData data = *((QData*)(vop->varDatap()));
-		out[1].aval = (IData)(data>>VL_ULL(32));
-		out[1].bval = 0;
-		out[0].aval = (IData)(data);
-		out[0].bval = 0;
-		return;
-	    }
-	    default: {
-		_VL_VPI_UNIMP();
-		return;
-	    }
-	    }
-	} else {
-	    switch (vop->varp()->vltype()) {
-	    case VLVT_UINT8:
-		value_p->value.integer = *((CData*)(vop->varDatap()));
-		return;
-	    case VLVT_UINT16:
-		value_p->value.integer = *((SData*)(vop->varDatap()));
-		return;
-	    case VLVT_UINT32:
-		value_p->value.integer = *((IData*)(vop->varDatap()));
-		return;
-	    case VLVT_WDATA:
-	    case VLVT_UINT64:
-		// Not legal
-		value_p->value.integer = 0;
-	    default:
-		_VL_VPI_UNIMP();
-		return;
-	    }
-	}
-    }
-    else if (VerilatedVpioConst* vop = VerilatedVpioConst::castp(object)) {
-	value_p->value.integer = vop->num();
-	return;
-    }
-    _VL_VPI_UNIMP();
-}
-
-vpiHandle vpi_put_value(vpiHandle object, p_vpi_value value_p,
-			p_vpi_time time_p, PLI_INT32 flags) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_put_value %p %p\n",object, value_p););
-    if (VL_UNLIKELY(!value_p)) return 0;
-    if (VerilatedVpioVar* vop = VerilatedVpioVar::castp(object)) {
-	// We presume vpiValue.format = vpiIntVal or if single bit vpiScalarVal
-	VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:    vpi_put_value name=%s fmt=%d vali=%d\n",
-				  vop->fullname(), value_p->format, value_p->value.integer);
-			VL_PRINTF("-vltVpi:    varp=%p  putatp=%p\n",
-				  vop->varp()->datap(), vop->varDatap()););
-	if (VL_UNLIKELY(!vop->varp()->isPublicRW())) {
-	    VL_PRINTF("%%Warning: Ignoring vpi_put_value to signal marked read-only, use public_flat_rw instead: %s\n",
-		      vop->fullname());
-	    return 0;
-	}
-	if (value_p->format == vpiVectorVal) {
-	    if (VL_UNLIKELY(!value_p->value.vector)) return NULL;
-	    switch (vop->varp()->vltype()) {
-	    case VLVT_UINT8:
-		*((CData*)(vop->varDatap())) = value_p->value.vector[0].aval;
-		return object;
-	    case VLVT_UINT16:
-		*((SData*)(vop->varDatap())) = value_p->value.vector[0].aval;
-		return object;
-	    case VLVT_UINT32:
-		*((IData*)(vop->varDatap())) = value_p->value.vector[0].aval;
-		return object;
-	    case VLVT_WDATA: {
-		int words = VL_WORDS_I(vop->varp()->range().bits());
-		WDataOutP datap = ((IData*)(vop->varDatap()));
-		for (int i=0; i<words; i++) {
-		    datap[i] = value_p->value.vector[i].aval;
-		}
-		return object;
-	    }
-	    case VLVT_UINT64: {
-		*((QData*)(vop->varDatap())) = _VL_SET_QII(
-		    value_p->value.vector[1].aval,
-		    value_p->value.vector[0].aval);
-		return object;
-	    }
-	    default: {
-		_VL_VPI_UNIMP();
-		return NULL;
-	    }
-	    }
-	} else {
-	    switch (vop->varp()->vltype()) {
-	    case VLVT_UINT8:
-		*((CData*)(vop->varDatap())) = vop->mask() & value_p->value.integer;
-		return object;
-	    case VLVT_UINT16:
-		*((SData*)(vop->varDatap())) = vop->mask() & value_p->value.integer;
-		return object;
-	    case VLVT_UINT32:
-		*((IData*)(vop->varDatap())) = vop->mask() & value_p->value.integer;
-		return object;
-	    case VLVT_WDATA: // FALLTHRU
-	    case VLVT_UINT64: // FALLTHRU
-	    default:
-		_VL_VPI_UNIMP();
-		return 0;
-	    }
-	}
-    }
-    _VL_VPI_UNIMP(); return NULL;
-}
-
-//-void vpi_get_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p,
-//-			 PLI_INT32 *index_p, PLI_UINT32 num) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-void vpi_put_value_array(vpiHandle object, p_vpi_arrayvalue arrayvalue_p,
-//-			 PLI_INT32 *index_p, PLI_UINT32 num) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-
-// time processing
-
-//-void vpi_get_time(vpiHandle object, p_vpi_time time_p) {
-//-    _VL_VPI_UNIMP();
-//-}
-
-// I/O routines
-
-PLI_UINT32 vpi_mcd_open(PLI_BYTE8 *filenamep) {
-    return VL_FOPEN_S(filenamep,"wb");
-}
-
-PLI_UINT32 vpi_mcd_close(PLI_UINT32 mcd) {
-    VL_FCLOSE_I(mcd); return 0;
-}
-
-//-PLI_BYTE8 *vpi_mcd_name(PLI_UINT32 mcd) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-PLI_INT32 vpi_mcd_printf(PLI_UINT32 mcd, PLI_BYTE8 *formatp, ...) {
-    va_list ap;
-    va_start(ap,formatp);
-    int chars = vpi_mcd_vprintf(mcd, formatp, ap);
-    va_end(ap);
-    return chars;
-}
-
-PLI_INT32 vpi_printf(PLI_BYTE8 *formatp, ...) {
-    va_list ap;
-    va_start(ap,formatp);
-    int chars = vpi_vprintf(formatp, ap);
-    va_end(ap);
-    return chars;
-}
-
-PLI_INT32 vpi_vprintf(PLI_BYTE8* formatp, va_list ap) {
-    return VL_VPRINTF(formatp, ap);
-}
-
-PLI_INT32 vpi_mcd_vprintf(PLI_UINT32 mcd, PLI_BYTE8 *format, va_list ap) {
-    FILE* fp = VL_CVT_I_FP(mcd);
-    if (VL_UNLIKELY(!fp)) return 0;
-    int chars = vfprintf(fp, format, ap);
-    return chars;
-}
-
-PLI_INT32 vpi_flush(void) {
-    Verilated::flushCall();
-    return 0;
-}
-
-PLI_INT32 vpi_mcd_flush(PLI_UINT32 mcd) {
-    FILE* fp = VL_CVT_I_FP(mcd);
-    if (VL_UNLIKELY(!fp)) return 1;
-    fflush(fp);
-    return 0;
-}
-
-// utility routines
-
-//-PLI_INT32 vpi_compare_objects(vpiHandle object1, vpiHandle object2) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-PLI_INT32 vpi_chk_error(p_vpi_error_info error_info_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-PLI_INT32 vpi_free_object(vpiHandle object) {
-    return vpi_release_handle(object);  // Deprecated
-}
-
-PLI_INT32 vpi_release_handle (vpiHandle object) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_release_handle %p\n",object););
-    VerilatedVpio* vop = VerilatedVpio::castp(object);
-    if (VL_UNLIKELY(!vop)) return 0;
-    vpi_remove_cb(object);  // May not be a callback, but that's ok
-    delete vop;
-    return 1;
-}
-
-//-PLI_INT32 vpi_get_vlog_info(p_vpi_vlog_info vlog_info_p) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-// routines added with 1364-2001
-
-//-PLI_INT32 vpi_get_data(PLI_INT32 id, PLI_BYTE8 *dataLoc, PLI_INT32 numOfBytes) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-PLI_INT32 vpi_put_data(PLI_INT32 id, PLI_BYTE8 *dataLoc, PLI_INT32 numOfBytes) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-void *vpi_get_userdata(vpiHandle obj) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-//-PLI_INT32 vpi_put_userdata(vpiHandle obj, void *userdata) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
-
-PLI_INT32 vpi_control(PLI_INT32 operation, ...) {
-    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  vpi_control %d\n",operation););
-    switch (operation) {
-    case vpiFinish: {
-	vl_finish(__FILE__,__LINE__,"*VPI*");
-	return 1;
-    }
-    case vpiStop: {
-	vl_stop(__FILE__,__LINE__,"*VPI*");
-	return 1;
-    }
-    }
-    _VL_VPI_UNIMP(); return 0;
-}
-
-//-vpiHandle vpi_handle_by_multi_index(vpiHandle obj, PLI_INT32 num_index, PLI_INT32 *index_array) {
-//-    _VL_VPI_UNIMP(); return 0;
-//-}
+    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);
+};
 
 //======================================================================
 

include/verilatedos.h

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License.
 // Version 2.0.
@@ -95,6 +95,29 @@
 // This is not necessarily the same as #UL, depending on what the IData typedef is.
 #define VL_UL(c) ((IData)(c##UL))	///< Add appropriate suffix to 32-bit constant
 
+#ifdef VL_CPPCHECK
+# define VL_DANGLING(v)
+#else
+# define VL_DANGLING(v) do { (v) = NULL; } while(0)	///< After e.g. delete, set variable to NULL to indicate must not use later
+#endif
+
+//=========================================================================
+// C++-2011
+
+#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
+# define VL_HAS_UNIQUE_PTR
+# define VL_UNIQUE_PTR unique_ptr
+#else
+# define VL_UNIQUE_PTR auto_ptr
+#endif
+
+//=========================================================================
+// Optimization
+
+#ifndef VL_INLINE_OPT
+# define VL_INLINE_OPT		///< "inline" if compiling all objects in single compiler run
+#endif
+
 //=========================================================================
 // Warning disabled
 
@@ -122,7 +145,7 @@ typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward comp
 typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-# ifdef __uint32_t_defined      		// Newer Cygwin uint32_t in stdint.h as an unsigned int
+# if defined(__uint32_t_defined) || defined(___int32_t_defined)    // Newer Cygwin uint32_t in stdint.h as an unsigned int
 typedef int32_t			vlsint32_t;	///< 32-bit signed type
 typedef uint32_t		vluint32_t;	///< 32-bit unsigned type
 # else				 		// Older Cygwin has long==uint32_t
@@ -161,6 +184,7 @@ typedef signed   __int32        ssize_t;        ///< signed size_t; returned fro
 #else // Linux or compliant Unix flavors, -m64
 
 # include <stdint.h>	// Linux and most flavors
+# include <unistd.h>	// Linux ssize_t
 # include <inttypes.h>	// Solaris
 typedef uint8_t			vluint8_t;	///< 32-bit unsigned type
 typedef uint16_t		vluint16_t;	///< 32-bit unsigned type
@@ -189,6 +213,27 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 # endif
 #endif
 
+#if defined(_WIN32) && defined(_MSC_VER)
+# if (_MSC_VER < 1900)
+#  define VL_SNPRINTF _snprintf
+# else
+#  define VL_SNPRINTF snprintf
+# endif
+# define VL_VSNPRINTF vsnprintf
+#else
+# define VL_SNPRINTF snprintf
+# define VL_VSNPRINTF vsnprintf
+#endif
+
+//=========================================================================
+// File system functions
+
+#ifdef _WIN32
+# define VL_DEV_NULL "nul"
+#else // Linux or compliant Unix flavors
+# define VL_DEV_NULL "/dev/null"
+#endif
+
 //=========================================================================
 // Integer size macros
 

include/vltstd/svdpi.h

@@ -7,7 +7,7 @@
  * This file contains the constant definitions, structure definitions,
  * and routine declarations used by SystemVerilog DPI.
  *
- * This file is from the SystemVerilog IEEE 1800-2009 Annex I.
+ * This file is from the SystemVerilog IEEE 1800-2012 Annex I.
  */
 
 #ifndef INCLUDED_SVDPI
@@ -29,24 +29,24 @@ typedef signed __int8 int8_t;
 #include <stdint.h>
 #elif defined(__APPLE__)
 #include <stdint.h>
-#elif defined(__linux)
+#elif defined(__linux) || (defined(__APPLE__) && defined(__MACH__))
 #include <inttypes.h>
 #else
 #include <sys/types.h>
 #endif
 
-/* Use to export a symbol from application */
+/* Use to import a symbol into dll */
 #ifndef DPI_DLLISPEC
-#if defined (_MSC_VER)
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
 #define DPI_DLLISPEC __declspec(dllimport)
 #else
 #define DPI_DLLISPEC
 #endif
 #endif
 
-/* Use to import a symbol into application */
+/* Use to export a symbol from dll */
 #ifndef DPI_DLLESPEC
-#if defined (_MSC_VER)
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
 #define DPI_DLLESPEC __declspec(dllexport)
 #else
 #define DPI_DLLESPEC
@@ -155,7 +155,7 @@ XXTERN void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w);
 XXTERN void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
 
 XXTERN void svPutPartselBit(svBitVecVal* d, const svBitVecVal s, int i, int w);
-XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal s, int i, int w);
+XXTERN void svPutPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w);
 
 /*
  * Open array querying functions
@@ -427,7 +427,7 @@ XXTERN void svGetPartSelectLogic(svLogicVec32* d, const svLogicPackedArrRef s,
 /* actual <-- canonical */
 XXTERN void svPutPartSelectBit(svBitPackedArrRef d, const svBitVec32 s,
         int i, int w);
-XXTERN void svPutPartSelectLogic(svLogicPackedArrRef d, const svLogicVec32 s,
+XXTERN void svPutPartSelectLogic(svLogicPackedArrRef d, const svLogicVec32* s,
         int i, int w);
 
 /*

include/vltstd/vpi_user.h

@@ -1,7 +1,7 @@
 /*******************************************************************************
  * vpi_user.h
  *
- * IEEE Std 1800 Programming Language Interface (PLI)
+ * IEEE Std 1800-2012 Programming Language Interface (PLI)
  *
  * This file contains the constant definitions, structure definitions, and
  * routine declarations used by the SystemVerilog Verification Procedural
@@ -37,7 +37,7 @@ typedef signed __int32 int32_t;
 typedef signed __int8 int8_t;
 #elif defined(__MINGW32__)
 #include <stdint.h>
-#elif defined(__linux)
+#elif defined(__linux) || (defined(__APPLE__) && defined(__MACH__))
 #include <inttypes.h>
 #else
 #include <sys/types.h>
@@ -61,9 +61,9 @@ typedef char             PLI_BYTE8;
 typedef unsigned char    PLI_UBYTE8;
 #endif
 
-/* Use to export a symbol */
+/* Use to import a symbol */
 
-#if WIN32
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
 #ifndef PLI_DLLISPEC
 #define PLI_DLLISPEC __declspec(dllimport)
 #define VPI_USER_DEFINED_DLLISPEC 1
@@ -74,9 +74,9 @@ typedef unsigned char    PLI_UBYTE8;
 #endif
 #endif
 
-/* Use to import a symbol */
+/* Use to export a symbol */
 
-#if WIN32
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
 #ifndef PLI_DLLESPEC
 #define PLI_DLLESPEC __declspec(dllexport)
 #define VPI_USER_DEFINED_DLLESPEC 1
@@ -438,12 +438,12 @@ typedef PLI_UINT32 *vpiHandle;
 #define vpiPlusOp                  2   /* unary plus */
 #define vpiNotOp                   3   /* unary not */
 #define vpiBitNegOp                4   /* bitwise negation */
-#define vpiUnaryAndOp              5   /* bitwise reduction and */
-#define vpiUnaryNandOp             6   /* bitwise reduction nand */
-#define vpiUnaryOrOp               7   /* bitwise reduction or */
-#define vpiUnaryNorOp              8   /* bitwise reduction nor */
-#define vpiUnaryXorOp              9   /* bitwise reduction xor */
-#define vpiUnaryXNorOp            10   /* bitwise reduction xnor */
+#define vpiUnaryAndOp              5   /* bitwise reduction AND */
+#define vpiUnaryNandOp             6   /* bitwise reduction NAND */
+#define vpiUnaryOrOp               7   /* bitwise reduction OR */
+#define vpiUnaryNorOp              8   /* bitwise reduction NOR */
+#define vpiUnaryXorOp              9   /* bitwise reduction XOR */
+#define vpiUnaryXNorOp            10   /* bitwise reduction XNOR */
 #define vpiSubOp                  11   /* binary subtraction */
 #define vpiDivOp                  12   /* binary division */
 #define vpiModOp                  13   /* binary modulus */
@@ -459,17 +459,17 @@ typedef PLI_UINT32 *vpiHandle;
 #define vpiRShiftOp               23   /* binary right shift */
 #define vpiAddOp                  24   /* binary addition */
 #define vpiMultOp                 25   /* binary multiplication */
-#define vpiLogAndOp               26   /* binary logical and */
-#define vpiLogOrOp                27   /* binary logical or */
-#define vpiBitAndOp               28   /* binary bitwise and */
-#define vpiBitOrOp                29   /* binary bitwise or */
-#define vpiBitXorOp               30   /* binary bitwise xor */
-#define vpiBitXNorOp              31   /* binary bitwise xnor */
+#define vpiLogAndOp               26   /* binary logical AND */
+#define vpiLogOrOp                27   /* binary logical OR */
+#define vpiBitAndOp               28   /* binary bitwise AND */
+#define vpiBitOrOp                29   /* binary bitwise OR */
+#define vpiBitXorOp               30   /* binary bitwise XOR */
+#define vpiBitXNorOp              31   /* binary bitwise XNOR */
 #define vpiBitXnorOp              vpiBitXNorOp /* added with 1364-2001 */
 #define vpiConditionOp            32   /* ternary conditional */
 #define vpiConcatOp               33   /* n-ary concatenation */
 #define vpiMultiConcatOp          34   /* repeated concatenation */
-#define vpiEventOrOp              35   /* event or */
+#define vpiEventOrOp              35   /* event OR */
 #define vpiNullOp                 36   /* null operation */
 #define vpiListOp                 37   /* list of expressions */
 #define vpiMinTypMaxOp            38   /* min:typ:max: delay expression */
@@ -536,7 +536,7 @@ typedef PLI_UINT32 *vpiHandle;
                                          same subtypes as vpiNetType */
 #define vpiSaveRestartID         62   /* unique ID for save/restart data */
 #define vpiSaveRestartLocation   63   /* name of save/restart data file */
-/* vpiValid,vpiValidTrue,vpiValidFalse are deprecated in 1800-2009 */
+/* vpiValid,vpiValidTrue,vpiValidFalse were deprecated in 1800-2009 */
 #define vpiValid                 64   /* reentrant task/func frame or automatic
                                          variable is valid */
 #define vpiValidFalse              0
@@ -661,7 +661,7 @@ typedef struct t_vpi_arrayvalue
    {
        PLI_INT32 *integers;               /* integer values */
        PLI_INT16 *shortints;              /* short integer values */
-       PLI_INT16 *longints;               /* long integer values */
+       PLI_INT64 *longints;               /* long integer values */
        PLI_BYTE8 *rawvals;                /* 2/4-state vector elements */
        struct t_vpi_vecval *vectors;      /* 4-state vector elements */
        struct t_vpi_time *times;          /* time values */
@@ -944,7 +944,7 @@ XXTERN PLI_INT32    vpi_compare_objects PROTO_PARAMS((vpiHandle object1,
                                                       vpiHandle object2));
 XXTERN PLI_INT32    vpi_chk_error       PROTO_PARAMS((p_vpi_error_info
                                                       error_info_p));
-/* vpi_free_object() is deprecated in 1800-2009 */
+/* vpi_free_object() was deprecated in 1800-2009 */
 XXTERN PLI_INT32    vpi_free_object     PROTO_PARAMS((vpiHandle object));
 XXTERN PLI_INT32    vpi_release_handle  PROTO_PARAMS((vpiHandle object));
 XXTERN PLI_INT32    vpi_get_vlog_info   PROTO_PARAMS((p_vpi_vlog_info

internals.pod

@@ -40,7 +40,7 @@ Verilator then performs many additional edits and optimizations on the
 hierarchical design.  This includes coverage, assertions, X elimination,
 inlining, constant propagation, and dead code elimination.
 
-References in the design are then psudo-flattened.  Each module's variables
+References in the design are then pseudo-flattened.  Each module's variables
 and functions get "Scope" references.  A scope reference is an occurrence of
 that un-flattened variable in the flattened hierarchy.  A module that occurs
 only once in the hierarchy will have a single scope and single VarScope for
@@ -49,7 +49,7 @@ occurrence, and two VarScopes for each variable.  This allows optimizations
 to proceed across the flattened design, while still preserving the
 hierarchy.
 
-Additional edits and optimizations proceed on the psudo-flat design.  These
+Additional edits and optimizations proceed on the pseudo-flat design.  These
 include module references, function inlining, loop unrolling, variable
 lifetime analysis, lookup table creation, always splitting, and logic gate
 simplifications (pushing inverters, etc).
@@ -80,8 +80,8 @@ classes).
 Each C<AstNode> has pointers to up to four children, accessed by the
 C<op1p> through C<op4p> methods.  These methods are then abstracted in a
 specific Ast* node class to a more specific name.  For example with the
-C<AstIf> node (for C<if> statements), C<ifsp> calls C<op1p> to give the
-pointer to the AST for the "then" block, while C<elsesp> calls C<op2p> to
+C<AstIf> node (for C<if> statements), C<ifsp> calls C<op2p> to give the
+pointer to the AST for the "then" block, while C<elsesp> calls C<op3p> to
 give the pointer to the AST for the "else" block, or NULL if there is not
 one.
 
@@ -97,7 +97,7 @@ are at the top of the tree.
 By convention, each function/method uses the variable C<nodep> as a pointer
 to the C<AstNode> currently being processed.
 
-=item C<AstNVistor>
+=item C<AstNVisitor>
 
 The passes are implemented by AST visitor classes (see L</Visitor
 Functions>). These are implemented by subclasses of the abstract class,
@@ -119,7 +119,7 @@ C<fanout>, C<color> and C<rank>, which may be used in algorithms for ordering
 the graph. A generic C<user>/C<userp> member variable is also provided.
 
 Virtual methods are provided to specify the name, color, shape and style to be
-used in dot output. Typically users provided derived classes from
+used in dot output. Typically users provide derived classes from
 C<V3GraphVertex> which will reimplement these methods.
 
 Iterators are provided to access in and out edges. Typically these are used in
@@ -219,7 +219,7 @@ and optimization passes. This allows separation of the pass algorithm from
 the AST on which it operates. Wikipedia provides an introduction to the
 concept at L<http://en.wikipedia.org/wiki/Visitor_pattern>.
 
-As noted above, all visitors are derived classes of C<AstNvisitor>. All
+As noted above, all visitors are derived classes of C<AstNVisitor>. All
 derived classes of C<AstNode> implement the C<accept> method, which takes
 as argument a reference to an instance or a C<AstNVisitor> derived class
 and applies the visit method of the C<AstNVisitor> to the invoking AstNode
@@ -262,7 +262,7 @@ exiting the lower for will lose the upper for's setting.
 User attributes.  Each C<AstNode> (B<Note.> The AST node, not the visitor)
 has five user attributes, which may be accessed as an integer using the
 C<user1()> through C<user5()> methods, or as a pointer (of type
-C<AstNuser>) using the C<user1p()> through C<user5p()> methods (a common
+C<AstNUser>) using the C<user1p()> through C<user5p()> methods (a common
 technique lifted from graph traversal packages).
 
 A visitor first clears the one it wants to use by calling
@@ -290,7 +290,7 @@ module.
 
 Parameters can be passed between the visitors in close to the "normal"
 function caller to callee way.  This is the second C<vup> parameter of type
-C<AstNuser> that is ignored on most of the visitor functions.  V3Width does
+C<AstNUser> that is ignored on most of the visitor functions.  V3Width does
 this, but it proved more messy than the above and is deprecated.  (V3Width
 was nearly the first module written.  Someday this scheme may be removed,
 as it slows the program down to have to pass vup everywhere.)
@@ -301,10 +301,10 @@ as it slows the program down to have to pass vup everywhere.)
 
 C<AstNode> provides a set of iterators to facilitate walking over the
 tree. Each takes two arguments, a visitor, C<v>, of type C<AstNVisitor> and
-an optional pointer user data, C<vup>, of type C<AstNuser*>. The second is
+an optional pointer user data, C<vup>, of type C<AstNUser*>. The second is
 one of the ways to pass parameters to visitors described in L</Visitor
-Functions>, but its use is no deprecated and should be used for new visitor
-classes.
+Functions>, but its use is now deprecated and should I<not> be used for new
+visitor classes.
 
 =over 4
 
@@ -341,6 +341,37 @@ C<op4p> in turn.
 
 =back
 
+=head3 Caution on Using Iterators When Child Changes
+
+Visitors often replace one node with another node; V3Width and V3Const are
+major examples.  A visitor which is the parent of such a replacement needs
+to be aware that calling iteration may cause the children to change.  For
+example:
+
+    // nodep->lhsp() is 0x1234000
+    nodep->lhsp()->iterateAndNext(...);  // and under covers nodep->lhsp() changes
+    // nodep->lhsp() is 0x5678400
+    nodep->lhsp()->iterateAndNext(...);
+
+Will work fine, as even if the first iterate causes a new node to take the
+place of the lhsp(), that edit will update nodep->lhsp() and the second
+call will correctly see the change. Alternatively:
+
+    lp = nodep->lhsp();
+    // nodep->lhsp() is 0x1234000, lp is 0x1234000
+    lp->iterateAndNext(...); **lhsp=NULL;** // and under covers nodep->lhsp() changes
+    // nodep->lhsp() is 0x5678400, lp is 0x1234000
+    lp->iterateAndNext(...);
+
+This will cause bugs or a core dump, as lp is a dangling pointer.  Thus it
+is advisable to set lhsp=NULL shown in the *'s above to make sure these
+dangles are avoided.  Another alternative used in special cases mostly in
+V3Width is to use acceptSubtreeReturnEdits, which operates on a single node
+and returns the new pointer if any.  Note acceptSubtreeReturnEdits does not
+follow nextp() links.
+
+    lp = lp->acceptSubtreeReturnEdits()
+
 =head2 Identifying derived classes
 
 A common requirement is to identify the specific C<AstNode> class we are
@@ -366,19 +397,82 @@ AST.
 
 =head1 TESTING
 
-To write a test see the BUGS section of the Verilator primary manual, and
-the documentation in:
-
-  test_regress/t/driver.pl --help
+For an overview of how to write a test see the BUGS section of the
+Verilator primary manual.
 
 It is important to add tests for failures as well as success (for example to
 check that an error message is correctly triggered).
 
-Tests that fail should by convenition have the suffix C<_bad> in their name,
+Tests that fail should by convention have the suffix C<_bad> in their name,
 and include C<fails =E<gt> 1> in either their C<compile> or C<execute> step as
 appropriate.
 
-Developers will also want to configure with two extra flags:
+=head2 Preparing to Run Tests
+
+For all tests to pass you must install the following packages:
+
+* SystemC to compile the SystemC outputs, see http://systemc.org
+
+* Parallel::Forker from CPAN to run tests in parallel, you can install this
+with e.g. "sudo cpan install Parallel::Forker".
+
+* vcddiff to find differences in VCD outputs. See the readme at
+https://github.com/veripool/vcddiff
+
+=head2 Controlling the Test Driver
+
+Test drivers are written in PERL. All invoke the main test driver script,
+which can provide detailed help on all the features available when writing
+a test driver.
+
+  test_regress/t/driver.pl --help
+
+For convenience, a summary of the most commonly used features is provided
+here. All drivers require a call to C<compile> subroutine to compile the
+test. For run-time tests, this is followed by a call to the C<execute>
+subroutine. Both of these functions can optionally be provided with a hash
+table as argument specifying additional options.
+
+The test driver assumes by default that the source Verilog file name
+matches the PERL driver name. So a test whose driver is C<t/t_mytest.pl>
+will expect a Verilog source file C<t/t_mytest.v>. This can be changed
+using the C<top_filename> subroutine, for example
+
+  top_filename("t/t_myothertest.v");
+
+By default all tests will run with major simulators (Icarus Verilog, NC,
+VCS, ModelSim) as well as Verilator, to allow results to be
+compared. However if you wish a test only to be used with Verilator, you
+can use the following:
+
+  $Self->{vlt} or $Self->skip("Verilator only test");
+
+Of the many options that can be set through arguments to C<compiler> and
+C<execute>, the following are particularly useful:
+
+=over 4
+
+=item C<verilator_flags2>
+
+A list of flags to be passed to verilator when compiling.
+
+=item C<fails>
+
+Set to 1 to indicate that the compilation or execution is intended to fail.
+
+=back
+
+For example the following would specify that compilation requires two
+defines and is expected to fail.
+
+  compile (
+      verilator_flags2 => ["-DSMALL_CLOCK -DGATED_COMMENT"],
+      fails => 1,
+      );
+
+=head2 Regression Testing for Developers
+
+Developers will also want to call ./configure with two extra flags:
 
 =over 4
 
@@ -391,10 +485,10 @@ be warning free.
 
 =item --enable-longtests
 
-In addition to the standard C, SystemC and SystemPerl tests also run the
-tests in the C<test_vcs>, C<test_verilated> and C<test_regress> directories
-when using I<make test>.  This is disabled by default as SystemC/SystemPerl
-installation problems would otherwise falsely indicate a Verilator problem.
+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.
 
 =back
 
@@ -409,12 +503,6 @@ There are some traps to avoid when running regression tests
 
 =item *
 
-The regression tests will assume that you have a version of SystemPerl to
-match. Typically if working on Verilator from git, also use SystemPerl from
-git.
-
-=item *
-
 When checking the MANIFEST, the test will barf on unexpected code in the
 Verilator tree. So make sure to keep any such code outside the tree.
 
@@ -557,8 +645,8 @@ Shows the value of the node's user1p...user5p, if non-NULL.
 Many nodes have an explicit data type.  "@dt=0x..." indicates the address
 of the data type (AstNodeDType) this node uses.
 
-If a data type is present and is numberic, it then prints the width of the
-item. This field is a squence of flag characters and width data as follows:
+If a data type is present and is numeric, it then prints the width of the
+item. This field is a sequence of flag characters and width data as follows:
 
 C<s> if the node is signed.
 
@@ -697,7 +785,7 @@ in C<src/Makefile_obj.in> and reconfigure.
 
 The latest version is available from L<http://www.veripool.org/>.
 
-Copyright 2008-2013 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2015 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

nodist/bisondiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2013 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.

nodist/bisonreader

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2013 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.

nodist/dot_importer

@@ -143,7 +143,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2015 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

nodist/dot_pruner

@@ -184,7 +184,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2015 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

nodist/flexdiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2013 by Wilson Snyder.  This package is free software; you
+# Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.

nodist/install_test

@@ -183,7 +183,7 @@ Runs a specific test stage (see the script).
 
 =head1 DISTRIBUTION
 
-Copyright 2009-2013 by Wilson Snyder.  This package is free software; you
+Copyright 2009-2015 by Wilson Snyder.  This package is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.

nodist/invoke_atsim

@@ -28,7 +28,7 @@ invoke_atsim - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2015 by Wilson Snyder.  This package is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.

nodist/invoke_iccr

@@ -28,7 +28,7 @@ invoke_iccr - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2007-2013 by Wilson Snyder.  This package is free software; you
+Copyright 2007-2015 by Wilson Snyder.  This package is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.

nodist/invoke_ncverilog

@@ -28,7 +28,7 @@ invoke_ncverilog - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2015 by Wilson Snyder.  This package is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.

nodist/invoke_vcs

@@ -8,7 +8,7 @@ use strict;
 #======================================================================
 # main
 
-eval `modulecmd perl add synopsys-vcs`;
+eval `modulecmd perl add synopsys-vcs_mx`;
 exec('vcs',@ARGV);
 
 #######################################################################
@@ -28,7 +28,7 @@ invoke_vcs - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  This package is free software; you
+Copyright 2005-2015 by Wilson Snyder.  This package is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.

nodist/spdiff

@@ -1,141 +0,0 @@
-#!/usr/bin/perl -w
-######################################################################
-#
-# Copyright 2010-2013 by Wilson Snyder.  This package is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-######################################################################
-
-# DESCRIPTION: Diff Verilator includes against SystemPerl include files
-
-use Getopt::Long;
-use IO::File;
-use strict;
-
-our $Debug;
-our $Bad;
-
-if (! GetOptions (
-	  #"help"	=> \&usage,
-	  "debug"	=> sub { $Debug = 1; },
-    )) {
-    die "usage();"
-}
-
-diff("$ARGV[0]/include/verilated_vcd_c.h",	"$ARGV[1]/src/SpTraceVcdC.h");
-diff("$ARGV[0]/include/verilated_vcd_sc.h",	"$ARGV[1]/src/SpTraceVcd.h");
-diff("$ARGV[0]/include/verilated_vcd_c.cpp",	"$ARGV[1]/src/SpTraceVcdC.cpp");
-diff("$ARGV[0]/include/verilated_vcd_sc.cpp",	"$ARGV[1]/src/SpTraceVcd.cpp");
-
-exit(10) if $Bad;
-
-sub diff {
-    my $a=shift;
-    my $b=shift;
-
-    my $ta = "/tmp/spdiff.$$.a";
-    my $tb = "/tmp/spdiff.$$.b";
-
-    prep($a,$ta);
-    prep($b,$tb);
-
-    system("diff -u -w $ta $tb");
-}
-
-sub prep {
-    my $filename = shift;
-    my $wfilename = shift;
-
-    my $sp;
-    if ($filename =~ m!src/Sp!) {
-	$sp = "Sp";
-    } elsif ($filename =~ m!include/verilated!) {
-    } else {
-	die "%Error: Not sure if Sp/Verilated: $filename,\n";
-    }
-
-    my $fh = IO::File->new("<$filename") or die "%Error: $! $filename";
-    my $fho = IO::File->new(">$wfilename") or die "%Error: $! writing $wfilename";
-
-    my @wf;
-    my $off;
-    while (defined(my $line = $fh->getline)) {
-	if ($line =~ m!// *SPDIFF_OFF!) {
-	    $off = 1;
-	    next;
-	} elsif ($line =~ m!// *SPDIFF_ON!) {
-	    $off = 0;
-	    next;
-	}
-	next if $off;
-
-	next if $line =~ /compile-command:/;
-	$line =~ s/SP_ABORT.*// if $sp;
-	$line =~ s/SP_NOTICE.*// if $sp;
-	$line =~ s/vl_fatal.*// if !$sp;
-	$line =~ s/VL_PRINT.*// if !$sp;
-	$line =~ s/Copyright \d+-\d+/Copyright #-#/g;
-
-	push @wf, $line;
-
-	my $check = $line;
-	$check =~ s/\bspace//i;
-	$check =~ s/\bsplit//i;
-	$check =~ s/"SP_TRACE"//;
-
-	if ($sp && $check =~ /Verilat/i
-	    && $check !~ /and newer/) {
-	    warn "%Warning: $filename:$.: Verilator text in Sp version: $line";
-	    $Bad = 1;
-	} elsif (!$sp && $check =~ /\b(Sp|SP)/
-		 ) {
-	    warn "%Warning: $filename:$.: Sp text in Verilator version: $line";
-	    $Bad = 1;
-	} elsif (!$sp && $check =~ /\<uint[0-9]+_t/) {
-	    warn "%Warning: $filename:$.: uint in Verilator version: $line";
-	    $Bad = 1;
-	}
-    }
-    !$off or die "%Error: $filename: SPDIFF_OFF block never terminated\n";
-
-    my $wholefile = join('',@wf);
-
-    if ($sp) {
-	$wholefile =~ s/SPTRACEVCDC_VERSION/VERILATED_VCD_VERSION/g;
-	$wholefile =~ s/SPTRACEVCDC_/VERILATED_VCD_C_/g;
-	$wholefile =~ s/SPTRACEVCD_TEST/VERILATED_VCD_TEST/g;
-	$wholefile =~ s/SPTRACEVCD_/VERILATED_VCD_SC_/g;
-
-	#
-	$wholefile =~ s/\bSpTraceFile\b/VerilatedVcdSc/g;
-	$wholefile =~ s/\bSpTraceFileC\b/VerilatedVcdC/g;
-	$wholefile =~ s/\bSpTraceVcd\b/VerilatedVcd/g;
-	$wholefile =~ s/\bSpTraceVcdCFile\b/VerilatedVcdC/g;
-	#
-	$wholefile =~ s/\bSpTraceCallInfo\b/VerilatedVcdCallInfo/g;
-	$wholefile =~ s/\bSpTraceCallback_t/VerilatedVcdCallback_t/g;
-	$wholefile =~ s/\bSpTraceVcd_/VerilatedVcd_/g;
-	$wholefile =~ s/\bSpTraceVcdSig\b/VerilatedVcdSig/g;
-	$wholefile =~ s/\bSpScBvExposer/VlScBvExposer/g;
-	#
-	$wholefile =~ s/\b(uint[0-9]+_t)/vl$1/g;
-	$wholefile =~ s/%ll/%" VL_PRI64 "/g;
-	$wholefile =~ s/\(long long unsigned\)n/ n/g;  # printQuad
-	#
-	$wholefile =~ s/\bSP_SC_BV/VL_SC_BV/g;
-	$wholefile =~ s/\bSP_UNLIKELY/VL_UNLIKELY/g;
-    }
-
-    $fho->print($wholefile);
-}
-
-# Local Variables:
-# compile-command: "./spdiff $SYP $V4"
-# End:

nodist/vtree_importer

@@ -331,7 +331,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2013 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2005-2015 by Wilson Snyder.  Verilator is free software; you can
 redistribute it and/or modify it under the terms of either the GNU Lesser
 General Public License Version 3 or the Perl Artistic License Version 2.0.
 

src/.gdbinit

@@ -1,6 +1,6 @@
 # DESCRIPTION: Verilator: GDB startup file with useful defines
 #
-# Copyright 2012-2013 by Wilson Snyder. This program is free software; you can
+# Copyright 2012-2015 by Wilson Snyder. This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.

src/Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -46,7 +46,7 @@ obj_opt:
 obj_dbg:
 	mkdir $@
 
-.PHONY: ../verilator_bin ../verilator_bin_dbg
+.PHONY: ../verilator_bin ../verilator_bin_dbg ../verilator_coverage_bin_dbg
 
 opt: ../verilator_bin
 ifeq ($(VERILATOR_NO_OPT_BUILD),1)	# Faster laptop development... One build
@@ -59,11 +59,15 @@ else
 	cd obj_opt && $(MAKE)       TGT=../$@ -f ../Makefile_obj
 endif
 
-dbg: ../verilator_bin_dbg
+dbg: ../verilator_bin_dbg ../verilator_coverage_bin_dbg
 ../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
+	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
+
 prefiles::
 prefiles:: config_rev.h
 ifneq ($(UNDER_GIT),)	# If local git tree... Else don't burden users

src/Makefile_obj.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+# Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 # redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -62,6 +62,8 @@ CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CPPFLAGS += @CPPFLAGS@
 LDFLAGS += @LDFLAGS@
 EXEEXT = @EXEEXT@
+CFG_CXXFLAGS_SRC = @CFG_CXXFLAGS_SRC@
+CFG_CXXFLAGS_PARSER = @CFG_CXXFLAGS_PARSER@
 
 #### End of system configuration section. ####
 
@@ -85,7 +87,8 @@ endif
 #CCMALLOC = /usr/local/lib/ccmalloc-gcc.o -lccmalloc -ldl
 
 # -lfl not needed as Flex invoked with %nowrap option
-LIBS = -lm
+# -lstdc++ needed for clang, believed harmless with gcc
+LIBS = -lm -lstdc++
 
 CPPFLAGS += -MMD
 CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir)
@@ -94,11 +97,11 @@ CPPFLAGS += -DYYDEBUG 	# Required to get nice error messages
 CPPFLAGS += $(COPT)
 CPPFLAGS += -MP # Only works on recent GCC versions
 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
-CPPFLAGS += -W -Wall -Wno-unused-parameter -Wno-char-subscripts -Werror
+CPPFLAGS += -W -Wall $(CFG_CXXFLAGS_SRC) -Werror
 #CPPFLAGS += -pedantic-errors
 endif
 CPPFLAGSWALL   = $(CPPFLAGS)
-CPPFLAGSNOWALL = $(CPPFLAGS) -Wno-unused
+CPPFLAGSPARSER = $(CPPFLAGS) $(CFG_CXXFLAGS_PARSER)
 
 ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
  SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
@@ -127,6 +130,7 @@ HEADERS = $(wildcard V*.h v*.h)
 ASTGEN = $(srcdir)/astgen
 BISONPRE = $(srcdir)/bisonpre
 FLEXFIX = $(srcdir)/flexfix
+VLCOVGEN = $(srcdir)/vlcovgen
 
 ######################################################################
 #### Top level
@@ -186,6 +190,7 @@ RAW_OBJS = \
 	V3Error.o \
 	V3Expand.o \
 	V3File.o \
+	V3FileLine.o \
 	V3Gate.o \
 	V3GenClk.o \
 	V3Graph.o \
@@ -210,6 +215,7 @@ RAW_OBJS = \
 	V3Number.o \
 	V3Options.o \
 	V3Order.o \
+	V3Os.o \
 	V3Param.o \
 	V3PreShell.o \
 	V3Premit.o \
@@ -233,26 +239,30 @@ RAW_OBJS = \
 	V3WidthSel.o \
 
 # Non-concatable
-OBJS += \
+NC_OBJS += \
 	V3ParseImp.o \
 	V3ParseGrammar.o \
 	V3ParseLex.o \
 	V3PreProc.o \
 
+# verilator_coverage
+VLCOV_OBJS = \
+	VlcMain.o \
+
 #### Linking
 
-ifeq ($(VL_DEBUG),)
-# Building with fewer objects to better optimize
-#OBJS += V3__CONCAT.o
-OBJS += $(RAW_OBJS)
+ifeq ($(VL_VLCOV),)
+PREDEP_H = V3Ast__gen_classes.h
+OBJS += $(RAW_OBJS) $(NC_OBJS)
 else
-OBJS += $(RAW_OBJS)
+PREDEP_H =
+OBJS += $(VLCOV_OBJS)
 endif
 
 V3__CONCAT.cpp: $(addsuffix .cpp, $(basename $(RAW_OBJS)))
 	$(PERL) $(srcdir)/../bin/verilator_includer $^ > $@
 
-$(TGT): V3Ast__gen_classes.h $(OBJS)
+$(TGT): $(PREDEP_H) $(OBJS)
 	@echo "      Linking $@..."
 	-rm -rf $@ [email protected]
 	${LINK} ${LDFLAGS} -o $@ $(OBJS) $(CCMALLOC) ${LIBS}
@@ -271,22 +281,28 @@ V3Number_test: V3Number_test.o
 	$(OBJCACHE) ${CC}  ${CPPFLAGSWALL} -c $<
 
 V3ParseLex.o:	V3ParseLex.cpp V3Lexer.yy.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3ParseGrammar.o:	V3ParseGrammar.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3ParseImp.o:	V3ParseImp.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 V3PreProc.o:	V3PreProc.cpp V3PreLex.yy.cpp
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
 #### Generated files
 
 # Target rule called before parallel build to make generated files
 serial:: V3Ast__gen_classes.h V3ParseBison.c
 
+serial_vlcov:: vlcovgen.d
+
+vlcovgen.d: $(VLCOVGEN) $(srcdir)/include/verilated_cov_key.h
+	$(PERL) $(VLCOVGEN) --srcdir $(srcdir)
+	touch $@
+
 V3Ast__gen_classes.h : $(ASTGEN) V3Ast.h V3AstNodes.h
 	$(PERL) $(ASTGEN) -I$(srcdir)  --classes
 

src/V3Active.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -83,7 +83,7 @@ private:
     }
     virtual void visit(AstSenTree* nodep, AstNUser*) {
 	// Simplify sensitivity list
-	V3Const::constifyExpensiveEdit(nodep); nodep=NULL;
+	V3Const::constifyExpensiveEdit(nodep); VL_DANGLING(nodep);
     }
     // Empty visitors, speed things up
     virtual void visit(AstNodeStmt* nodep, AstNUser*) { }
@@ -163,7 +163,7 @@ public:
 
 class ActiveDlyVisitor : public ActiveBaseVisitor {
 public:
-    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL };
+    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 private:
     CheckType 	m_check;	// Combo logic or other
     AstNode*	m_alwaysp;	// Always we're under
@@ -175,6 +175,8 @@ private:
 	    UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
 	    if (m_check == CT_INITIAL) {
 		nodep->v3warn(INITIALDLY,"Delayed assignments (<=) in initial or final block; suggest blocking assignments (=).");
+	    } else if (m_check == CT_LATCH) {
+		// Suppress. Shouldn't matter that the interior of the latch races 
 	    } else {
 		nodep->v3warn(COMBDLY,"Delayed assignments (<=) in non-clocked (non flop or latch) block; suggest blocking assignments (=).");
 	    }
@@ -182,7 +184,7 @@ private:
 					   nodep->lhsp()->unlinkFrBack(),
 					   nodep->rhsp()->unlinkFrBack());
 	    nodep->replaceWith(newp);
-	    nodep->deleteTree(); nodep = NULL;
+	    nodep->deleteTree(); VL_DANGLING(nodep);
 	}
     }
     virtual void visit(AstAssign* nodep, AstNUser*) {
@@ -286,12 +288,12 @@ private:
 	// Relink to CFUNC for the final
 	UINFO(4,"    FINAL "<<nodep<<endl);
 	if (!nodep->bodysp()) { // Empty, Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
 	if (!m_scopeFinalp) {
-	    m_scopeFinalp = new AstCFunc(nodep->fileline(), "_final", m_namer.scopep());
+	    m_scopeFinalp = new AstCFunc(nodep->fileline(), "_final_"+m_namer.scopep()->nameDotless(), m_namer.scopep());
 	    m_scopeFinalp->argTypes(EmitCBaseVisitor::symClassVar());
 	    m_scopeFinalp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign()+"\n"));
 	    m_scopeFinalp->dontCombine(true);
@@ -302,11 +304,11 @@ private:
 	nodep->unlinkFrBack();
 	m_scopeFinalp->addStmtsp(new AstComment(nodep->fileline(), nodep->typeName()));
 	m_scopeFinalp->addStmtsp(nodep->bodysp()->unlinkFrBackWithNext());
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     // METHODS
-    void visitAlways(AstNode* nodep, AstSenTree* oldsensesp) {
+    void visitAlways(AstNode* nodep, AstSenTree* oldsensesp, VAlwaysKwd kwd) {
 	// Move always to appropriate ACTIVE based on its sense list
 	if (oldsensesp
 	    && oldsensesp->sensesp()
@@ -314,7 +316,7 @@ private:
 	    && oldsensesp->sensesp()->castSenItem()->isNever()) {
 	    // Never executing.  Kill it.
 	    if (oldsensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 
@@ -326,12 +328,10 @@ private:
 	bool sequent = m_itemSequent;
 
 	if (!combo && !sequent) combo=true;	// If no list, Verilog 2000: always @ (*)
-#ifndef NEW_ORDERING
 	if (combo && sequent) {
 	    nodep->v3error("Unsupported: Mixed edge (pos/negedge) and activity (no edge) sensitive activity list");
 	    sequent = false;
 	}
-#endif
 
 	AstActive* wantactivep = NULL;
 	if (combo && !sequent) {
@@ -351,7 +351,7 @@ private:
 
 	// Delete sensitivity list
 	if (oldsensesp) {
-	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); oldsensesp=NULL;
+	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); VL_DANGLING(oldsensesp);
 	}
 
 	// Move node to new active
@@ -360,7 +360,11 @@ private:
 
 	// Warn and/or convert any delayed assignments
 	if (combo && !sequent) {
-	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+	    if (kwd == VAlwaysKwd::ALWAYS_LATCH) {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_LATCH);
+	    } else {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+	    }
 	}
 	else if (!combo && sequent) {
 	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
@@ -373,16 +377,16 @@ private:
 
 	if (!nodep->bodysp()) {
 	    // Empty always.  Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
-	visitAlways(nodep, nodep->sensesp());
+	visitAlways(nodep, nodep->sensesp(), nodep->keyword());
     }
     virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
 	// Move always to appropriate ACTIVE based on its sense list
 	UINFO(4,"    ALWPub   "<<nodep<<endl);
 	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
-	visitAlways(nodep, nodep->sensesp());
+	visitAlways(nodep, nodep->sensesp(), VAlwaysKwd::ALWAYS);
     }
     virtual void visit(AstSenGate* nodep, AstNUser*) {
 	AstSenItem* subitemp = nodep->sensesp();
@@ -398,7 +402,7 @@ private:
 	    m_itemCombo = true;
 	    // Delete the sensitivity
 	    // We'll add it as a generic COMBO SenItem in a moment.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else if (nodep->varrefp()) {
 	    // V3LinkResolve should have cleaned most of these up
 	    if (!nodep->varrefp()->width1()) nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
@@ -417,7 +421,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    ActiveVisitor(AstNetlist* nodep) {
+    explicit ActiveVisitor(AstNetlist* nodep) {
 	m_scopeFinalp = NULL;
 	m_itemCombo = false;
 	m_itemSequent = false;
@@ -432,4 +436,5 @@ public:
 void V3Active::activeAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ActiveVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("active.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Active.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3ActiveTop.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -87,7 +87,7 @@ private:
 	    && sensesp->sensesp()->castSenItem()->isNever()) {
 	    // Never executing.  Kill it.
 	    if (sensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 	// Copy combo tree to settlement tree with duplicated statements
@@ -147,7 +147,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    ActiveTopVisitor(AstNetlist* nodep) {
+    explicit ActiveTopVisitor(AstNetlist* nodep) {
 	m_topscopep = NULL;
 	nodep->accept(*this);
     }
@@ -160,4 +160,5 @@ public:
 void V3ActiveTop::activeTopAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ActiveTopVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("activetop.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3ActiveTop.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Assert.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -56,14 +56,18 @@ private:
 		+":"+cvtToStr(nodep->fileline()->lineno())
 		+": Assertion failed in %m"
 		+((message != "")?": ":"")+message
-		+"\\n");
+		+"\n");
     }
     void replaceDisplay(AstDisplay* nodep, const string& prefix) {
 	nodep->displayType(AstDisplayType::DT_WRITE);
 	nodep->fmtp()->text(assertDisplayMessage(nodep, prefix, nodep->fmtp()->text()));
-	AstNode* timesp = nodep->fmtp()->exprsp(); if (timesp) timesp->unlinkFrBack();
-	timesp = timesp->addNext(new AstTime(nodep->fileline()));
-	nodep->fmtp()->exprsp(timesp);
+	// cppcheck-suppress nullPointer
+	AstNode* timenewp = new AstTime(nodep->fileline());
+	if (AstNode* timesp = nodep->fmtp()->exprsp()) {
+	    timesp->unlinkFrBackWithNext();
+	    timenewp->addNext(timesp);
+	}
+	nodep->fmtp()->exprsp(timenewp);
 	if (!nodep->fmtp()->scopeNamep() && nodep->fmtp()->formatScopeTracking()) {
 	    nodep->fmtp()->scopeNamep(new AstScopeName(nodep->fileline()));
 	}
@@ -72,25 +76,16 @@ private:
     AstNode* newIfAssertOn(AstNode* nodep) {
 	// Add a internal if to check assertions are on.
 	// Don't make this a AND term, as it's unlikely to need to test this.
-	return new AstIf (nodep->fileline(),
-			  // If assertions are off, have constant propagation rip them out later
-			  // This allows syntax errors and such to be detected normally.
-			  (v3Global.opt.assertOn()
-			   ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
-			   : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
-			  nodep, NULL);
-    }
-
-    AstNode* newIfCoverageOn(AstNode* nodep) {
-	// Add a internal if to check coverage is on
-	// Don't make this a AND term, as it's unlikely to need to test this.
-	return new AstIf (nodep->fileline(),
-			  // If assertions are off, have constant propagation rip them out later
-			  // This allows syntax errors and such to be detected normally.
-			  (v3Global.opt.coverage()
-			   ? (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicTrue()))
-			   : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
-			  nodep, NULL);
+	AstNode* newp
+	    = new AstIf (nodep->fileline(),
+			 // If assertions are off, have constant propagation rip them out later
+			 // This allows syntax errors and such to be detected normally.
+			 (v3Global.opt.assertOn()
+			  ? (AstNode*)(new AstCMath(nodep->fileline(), "Verilated::assertOn()", 1))
+			  : (AstNode*)(new AstConst(nodep->fileline(), AstConst::LogicFalse()))),
+			 nodep, NULL);
+	newp->user1(true); // Don't assert/cover this if
+	return newp;
     }
 
     AstNode* newFireAssert(AstNode* nodep, const string& message) {
@@ -121,21 +116,16 @@ private:
 		if (message!="") covincp->declp()->comment(message);
 		bodysp = covincp;
 	    }
-	} else if (nodep->castPslAssert()) {
-	    bodysp = newFireAssert(nodep,message);
-	    // We assert the property is always true... so report when it fails
-	    // (Note this is opposite the behavior of coverage statements.)
-	    // Need: 'never' operator: not hold in current or any future cycle
-	    propp = new AstLogNot (nodep->fileline(), propp);
 	} else {
 	    nodep->v3fatalSrc("Unknown node type");
 	}
 	if (stmtsp) bodysp = bodysp->addNext(stmtsp);
 	AstIf* ifp = new AstIf (nodep->fileline(), propp, bodysp, NULL);
 	bodysp = ifp;
-	if (nodep->castPslAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
+	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 	//
 	AstNode* newp = new AstAlways (nodep->fileline(),
+				       VAlwaysKwd::ALWAYS,
 				       sentreep,
 				       bodysp);
 	// Install it
@@ -148,7 +138,7 @@ private:
 	    nodep->replaceWith(newp);
 	}
 	// Bye
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     void newVAssertion(AstVAssert* nodep, AstNode* propp) {
@@ -170,7 +160,63 @@ private:
 	// Install it
 	nodep->replaceWith(newp);
 	// Bye
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
+    }
+    
+    virtual void visit(AstIf* nodep, AstNUser*) {
+	if (nodep->user1SetOnce()) return;
+	if (nodep->uniquePragma() || nodep->unique0Pragma()) {
+	    AstNodeIf* ifp = nodep;
+	    AstNode* propp = NULL;
+	    bool hasDefaultElse = false;
+	    do {
+		// If this statement ends with 'else if', then nextIf will point to the
+		// nextIf statement.  Otherwise it will be null.
+		AstNodeIf* nextifp = dynamic_cast<AstNodeIf*>(ifp->elsesp());
+		ifp->condp()->iterateAndNext(*this);
+
+		// 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) {
+		    propp = new AstConcat(nodep->fileline(), predp, propp);
+		} else {
+		    propp = predp;
+		}
+
+		// Record if this ends with an 'else' that does not have an if
+		if (ifp->elsesp() && !nextifp) {
+		    hasDefaultElse = true;
+		}
+		
+		ifp = nextifp;
+	    } while (ifp);
+
+	    AstNode *newifp = nodep->cloneTree(false);
+	    bool allow_none = nodep->unique0Pragma();
+	    
+	    // Note: if this ends with an 'else', then we don't need to validate that one of the
+	    // predicates evaluates to true.
+	    AstNode* ohot = ((allow_none || hasDefaultElse)
+			     ? (new AstOneHot0(nodep->fileline(), propp))->castNode()
+			     : (new AstOneHot (nodep->fileline(), propp))->castNode());
+	    AstIf* checkifp = new AstIf (nodep->fileline(),
+					 new AstLogNot (nodep->fileline(), ohot),
+					 newFireAssert(nodep, "'unique if' statement violated"),
+					 newifp);
+	    checkifp->branchPred(AstBranchPred::BP_UNLIKELY);
+	    nodep->replaceWith(checkifp);
+	    pushDeletep(nodep);
+	} else {
+	    nodep->iterateChildren(*this);
+	}
     }
 
     // VISITORS  //========== Case assertions
@@ -239,18 +285,12 @@ private:
 	nodep->iterateChildren(*this);
 	if (m_beginp && nodep->name() == "") nodep->name(m_beginp->name());
 	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
-			nodep->stmtsp(), nodep->name()); nodep=NULL;
+			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
 	++m_statAsCover;
     }
-    virtual void visit(AstPslAssert* nodep, AstNUser*) {
-	nodep->iterateChildren(*this);
-	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
-			NULL, nodep->name()); nodep=NULL;
-	++m_statAsPsl;
-    }
     virtual void visit(AstVAssert* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	newVAssertion(nodep, nodep->propp()); nodep=NULL;
+	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
 	++m_statAsSV;
     }
 
@@ -272,20 +312,12 @@ private:
 	m_beginp = lastp;
     }
 
-    // VISITORS  //========== Temporal Layer
-
-    // VISITORS  //========== Boolean Layer
-    virtual void visit(AstPslBool* nodep, AstNUser*) {
-	nodep->replaceWith(nodep->exprp()->unlinkFrBack());
-	pushDeletep(nodep); nodep=NULL;
-    }
-
     virtual void visit(AstNode* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTRUCTORS
-    AssertVisitor(AstNetlist* nodep) {
+    explicit AssertVisitor(AstNetlist* nodep) {
 	m_beginp = NULL;
 	m_modp = NULL;
 	// Process
@@ -305,4 +337,5 @@ public:
 void V3Assert::assertAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     AssertVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("assert.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Assert.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3AssertPre.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -73,14 +73,6 @@ private:
     }
 
     // VISITORS  //========== Statements
-    virtual void visit(AstPslDefClock* nodep, AstNUser*) {
-	nodep->iterateChildren(*this);
-	// Store the new default clock, reset on new module
-	m_seniDefaultp = nodep->sensesp();
-	// Trash it
-	nodep->unlinkFrBack();
-	pushDeletep(nodep); nodep=NULL;
-    }
     virtual void visit(AstClocking* nodep, AstNUser*) {
 	UINFO(8,"   CLOCKING"<<nodep<<endl);
 	// Store the new default clock, reset on new module
@@ -91,7 +83,7 @@ private:
 	} else {
 	    nodep->unlinkFrBack();
 	}
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     virtual void visit(AstPslCover* nodep, AstNUser*) {
@@ -101,13 +93,6 @@ private:
 	nodep->sentreep(newSenTree(nodep));
 	clearAssertInfo();
     }
-    virtual void visit(AstPslAssert* nodep, AstNUser*) {
-	if (nodep->sentreep()) return;  // Already processed
-	clearAssertInfo();
-	nodep->iterateChildren(*this);
-	nodep->sentreep(newSenTree(nodep));
-	clearAssertInfo();
-    }
     virtual void visit(AstPslClocked* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	if (m_senip) {
@@ -124,7 +109,7 @@ private:
 	// Unlink and just keep a pointer to it, convert to sentree as needed
 	m_senip = nodep->sensesp();
 	nodep->replaceWith(blockp);
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
@@ -137,7 +122,7 @@ private:
 
 public:
     // CONSTRUCTORS
-    AssertPreVisitor(AstNetlist* nodep) {
+    explicit AssertPreVisitor(AstNetlist* nodep) {
 	m_seniDefaultp = NULL;
 	clearAssertInfo();
 	// Process
@@ -152,4 +137,5 @@ public:
 void V3AssertPre::assertPreAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     AssertPreVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("assertpre.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3AssertPre.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2005-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2005-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Ast.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -28,6 +28,7 @@
 #include "V3File.h"
 #include "V3Global.h"
 #include "V3Broken.h"
+#include "V3String.h"
 
 //======================================================================
 // Statics
@@ -115,6 +116,10 @@ string AstNode::encodeName(const string& namein) {
 	    out += hex;
 	}
     }
+    // Shorten names
+    // TODO long term use VName in place of "string name"
+    VName vname(out);
+    out = vname.hashedName();
     return out;
 }
 
@@ -176,6 +181,10 @@ string AstNode::prettyName(const string& namein) {
 	    pretty += ".";
 	    pos += 7;
 	}
+	else if (0==strncmp(pos,"->",2)) {
+	    pretty += ".";
+	    pos += 2;
+	}
 	else if (0==strncmp(pos,"__PVT__",7)) {
 	    pretty += "";
 	    pos += 7;
@@ -203,31 +212,6 @@ string AstNode::prettyTypeName() const {
     return string(typeName())+" '"+prettyName()+"'";
 }
 
-string AstNode::quoteName(const string& namein) {
-    // Encode control chars into C style escapes
-    // Reverse is V3Parse::deQuote
-    const char* start = namein.c_str();
-    string out;
-    for (const char* pos = start; *pos; pos++) {
-	if (pos[0]=='\\' || pos[0]=='"') {
-	    out += string("\\")+pos[0];
-	} else if (pos[0]=='\n') {
-	    out += "\\n";
-	} else if (pos[0]=='\r') {
-	    out += "\\r";
-	} else if (pos[0]=='\t') {
-	    out += "\\t";
-	} else if (isprint(pos[0])) {
-	    out += pos[0];
-	} else {
-	    // This will also cover \a etc
-	    char octal[10]; sprintf(octal,"\\%03o",pos[0]);
-	    out += octal;
-	}
-    }
-    return out;
-}
-
 //######################################################################
 // Insertion
 
@@ -239,6 +223,9 @@ inline void AstNode::debugTreeChange(const char* prefix, int lineno, bool next)
     //if (debug()) cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<": "<<(void*)this<<" <e"<<AstNode::s_editCntGbl<<">"<<endl;
     //if (debug()) {
     //	cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<endl;
+    //	// Commenting out the section below may crash, as the tree state
+    //	// between edits is not always consistent for printing
+    //	cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<endl;
     //	v3Global.rootp()->dumpTree(cout,"-treeChange: ");
     //	if (next||1) this->dumpTreeAndNext(cout, prefix);
     //	else this->dumpTree(cout, prefix);
@@ -561,7 +548,7 @@ void AstNode::relink(AstNRelinker* linkerp) {
     if (linkerp->m_iterpp) {
 	// If we're iterating over a next() link, we need to follow links off the
 	// NEW node.  Thus we pass iteration information via a pointer in the node.
-	// This adds a unfortunate 4 bytes to every AstNode, but is faster than passing
+	// This adds a unfortunate hot 8 bytes to every AstNode, but is faster than passing
 	// across every function.
 	// If anyone has a cleaner way, I'd be grateful.
 	*(linkerp->m_iterpp) = newp;
@@ -750,6 +737,20 @@ void AstNode::iterateChildren(AstNVisitor& v, AstNUser* vup) {
     if (m_op4p) m_op4p->iterateAndNext(v, vup);
 }
 
+void AstNode::iterateChildrenConst(AstNVisitor& v, AstNUser* vup) {
+    // This is a very hot function
+    if (!this) return;
+    ASTNODE_PREFETCH(m_op1p);
+    ASTNODE_PREFETCH(m_op2p);
+    ASTNODE_PREFETCH(m_op3p);
+    ASTNODE_PREFETCH(m_op4p);
+    // if () not needed since iterateAndNext accepts null this, but faster with it.
+    if (m_op1p) m_op1p->iterateAndNextConst(v, vup);
+    if (m_op2p) m_op2p->iterateAndNextConst(v, vup);
+    if (m_op3p) m_op3p->iterateAndNextConst(v, vup);
+    if (m_op4p) m_op4p->iterateAndNextConst(v, vup);
+}
+
 void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
     // This is a very hot function
     // IMPORTANT: If you replace a node that's the target of this iterator,
@@ -764,15 +765,18 @@ void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
     while (nodep) {
 	AstNode* niterp = nodep;  // This address may get stomped via m_iterpp if the node is edited
 	ASTNODE_PREFETCH(nodep->m_nextp);
+	// Desirable check, but many places where multiple iterations are OK
+	//if (VL_UNLIKELY(niterp->m_iterpp)) niterp->v3fatalSrc("IterateAndNext under iterateAndNext may miss edits");
+	// cppcheck-suppress nullPointer
 	niterp->m_iterpp = &niterp;
 	niterp->accept(v, vup);
 	// accept may do a replaceNode and change niterp on us...
 	//if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<(void*)nodep<<" now into "<<(void*)niterp<<endl);  // niterp maybe NULL, so need cast
-	if (!niterp) return;
+	if (!niterp) return;  // Perhaps node deleted inside accept
 	niterp->m_iterpp = NULL;
-	if (VL_UNLIKELY(niterp!=nodep)) { // Edited it
+	if (VL_UNLIKELY(niterp!=nodep)) { // Edited node inside accept
 	    nodep = niterp;
-	} else {  // Same node, just loop
+	} else {  // Unchanged node, just continue loop
 	    nodep = niterp->m_nextp;
 	}
     }
@@ -798,11 +802,12 @@ void AstNode::iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup) {
     this->op4p()->iterateListBackwards(v,vup);
 }
 
-void AstNode::iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup) {
+void AstNode::iterateAndNextConst(AstNVisitor& v, AstNUser* vup) {
     // Keep following the current list even if edits change it
     if (!this) return;
     for (AstNode* nodep=this; nodep; ) {
 	AstNode* nnextp = nodep->m_nextp;
+	ASTNODE_PREFETCH(nnextp);
 	nodep->accept(v, vup);
 	nodep = nnextp;
     }
@@ -823,10 +828,10 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 	// Calling on standalone tree; insert a shim node so we can keep track, then delete it on completion
 	AstBegin* tempp = new AstBegin(nodep->fileline(),"[EditWrapper]",nodep);
 	{
-	    tempp->stmtsp()->accept(v, vup);  nodep=NULL; // nodep to null as may be replaced
+	    tempp->stmtsp()->accept(v, vup); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = tempp->stmtsp()->unlinkFrBackWithNext();
-	tempp->deleteTree(); tempp=NULL;
+	tempp->deleteTree(); VL_DANGLING(tempp);
     } else {
 	// Use back to determine who's pointing at us (IE assume new node grafts into same place as old one)
 	AstNode** nextnodepp = NULL;
@@ -837,7 +842,7 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 	else if (this->m_backp->m_nextp == this) nextnodepp = &(this->m_backp->m_nextp);
 	if (!nextnodepp) this->v3fatalSrc("Node's back doesn't point to forward to node itself");
 	{
-	    nodep->accept(v, vup); nodep=NULL; // nodep to null as may be replaced
+	    nodep->accept(v, vup); VL_DANGLING(nodep); // nodep to null as may be replaced
 	}
 	nodep = *nextnodepp;  // Grab new node from point where old was connected
     }
@@ -863,24 +868,31 @@ void AstNode::cloneRelinkTree() {
 //======================================================================
 // Comparison
 
-bool AstNode::sameTree(AstNode* node2p) {
-    return sameTreeIter(node2p, true);
+bool AstNode::gateTreeIter() {
+    // Return true if the two trees are identical
+    if (this==NULL) return true;
+    if (!isGateOptimizable()) return false;
+    return (this->op1p()->gateTreeIter()
+	    && this->op2p()->gateTreeIter()
+	    && this->op3p()->gateTreeIter()
+	    && this->op4p()->gateTreeIter());
 }
 
-bool AstNode::sameTreeIter(AstNode* node2p, bool ignNext) {
+bool AstNode::sameTreeIter(AstNode* node2p, bool ignNext, bool gateOnly) {
     // Return true if the two trees are identical
     if (this==NULL && node2p==NULL) return true;
     if (this==NULL || node2p==NULL) return false;
     if (this->type() != node2p->type()
 	|| this->dtypep() != node2p->dtypep()
-	|| !this->same(node2p)) {
+	|| !this->same(node2p)
+	|| (gateOnly && !this->isGateOptimizable())) {
 	return false;
     }
-    return (this->op1p()->sameTreeIter(node2p->op1p(),false)
-	    && this->op2p()->sameTreeIter(node2p->op2p(),false)
-	    && this->op3p()->sameTreeIter(node2p->op3p(),false)
-	    && this->op4p()->sameTreeIter(node2p->op4p(),false)
-	    && (ignNext || this->nextp()->sameTreeIter(node2p->nextp(),false))
+    return (this->op1p()->sameTreeIter(node2p->op1p(),false,gateOnly)
+	    && this->op2p()->sameTreeIter(node2p->op2p(),false,gateOnly)
+	    && this->op3p()->sameTreeIter(node2p->op3p(),false,gateOnly)
+	    && this->op4p()->sameTreeIter(node2p->op4p(),false,gateOnly)
+	    && (ignNext || this->nextp()->sameTreeIter(node2p->nextp(),false,gateOnly))
 	);
 }
 
@@ -894,8 +906,8 @@ ostream& operator<<(ostream& os, V3Hash rhs) {
 
 V3Hash::V3Hash(const string& name) {
     uint32_t val = 0;
-    for (const char* c=name.c_str(); *c; c++) {
-	val = val*31 + *c;
+    for (string::const_iterator it = name.begin(); it!=name.end(); ++it) {
+	val = val*31 + *it;
     }
     setBoth(1,val);
 }
@@ -964,6 +976,14 @@ void AstNode::dumpTreeFileGdb(const char* filenamep) {  // For GDB only
     v3Global.rootp()->dumpTreeFile(filename);
 }
 
+void AstNode::checkIter() const {
+    if (m_iterpp) {
+	dumpPtrs(cout);
+	// Perhaps something forgot to clear m_iterpp?
+	this->v3fatalSrc("Iteration link should be NULL");
+    }
+}
+
 void AstNode::dumpPtrs(ostream& os) const {
     os<<"This="<<typeName()<<" "<<(void*)this;
     os<<" back="<<(void*)backp();
@@ -1007,11 +1027,11 @@ void AstNode::dumpTreeAndNext(ostream& os, const string& indent, int maxDepth) {
     }
 }
 
-void AstNode::dumpTreeFile(const string& filename, bool append) {
-    if (v3Global.opt.dumpTree()) {
+void AstNode::dumpTreeFile(const string& filename, bool append, bool doDump) {
+    if (doDump) {
 	{   // Write log & close
 	    UINFO(2,"Dumping "<<filename<<endl);
-	    const auto_ptr<ofstream> logsp (V3File::new_ofstream(filename, append));
+	    const VL_UNIQUE_PTR<ofstream> logsp (V3File::new_ofstream(filename, append));
 	    if (logsp->fail()) v3fatalSrc("Can't write "<<filename);
 	    *logsp<<"Verilator Tree Dump (format 0x3900) from <e"<<dec<<editCountLast()<<">";
 	    *logsp<<" to <e"<<dec<<editCountGbl()<<">"<<endl;
@@ -1041,7 +1061,7 @@ void AstNode::v3errorEnd(ostringstream& str) const {
 	nsstr<<str.str();
 	if (debug()) {
 	    nsstr<<endl;
-	    nsstr<<"-node: "<<this<<endl;
+	    nsstr<<"-node: "; ((AstNode*)this)->dump(nsstr); nsstr<<endl;
 	}
 	m_fileline->v3errorEnd(nsstr);
     } else {
@@ -1067,8 +1087,7 @@ void AstNode::dtypeChgWidth(int width, int widthMin) {
     dtypeChgWidthSigned(width, widthMin, dtypep()->numeric());
 }
 
-void AstNode::dtypeChgWidthSigned(int width, int widthMin, bool issigned) {
-    AstNumeric numeric = issigned ? AstNumeric::SIGNED : AstNumeric::UNSIGNED;
+void AstNode::dtypeChgWidthSigned(int width, int widthMin, AstNumeric numeric) {
     if (!dtypep()) {
 	// We allow dtypep() to be null, as before/during widthing dtypes are not resolved
 	dtypeSetLogicSized(width, widthMin, numeric);
@@ -1099,6 +1118,10 @@ AstNodeDType* AstNode::findLogicDType(int width, int widthMin, AstNumeric numeri
     return v3Global.rootp()->typeTablep()
 	->findLogicBitDType(fileline(), AstBasicDTypeKwd::LOGIC, width, widthMin, numeric);
 }
+AstNodeDType* AstNode::findLogicRangeDType(VNumRange range, int widthMin, AstNumeric numeric) const {
+    return v3Global.rootp()->typeTablep()
+	->findLogicBitDType(fileline(), AstBasicDTypeKwd::LOGIC, range, widthMin, numeric);
+}
 AstBasicDType* AstNode::findInsertSameDType(AstBasicDType* nodep) {
     return v3Global.rootp()->typeTablep()
 	->findInsertSameDType(nodep);

src/V3Ast.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -23,6 +23,7 @@
 #include "config_build.h"
 #include "verilatedos.h"
 #include "V3Error.h"
+#include "V3FileLine.h"
 #include "V3Number.h"
 #include "V3Global.h"
 #include <vector>
@@ -38,6 +39,9 @@ class VFlagLogicPacked {};
 class VFlagBitPacked {};
 class VFlagChildDType {};  // Used by parser.y to select constructor that sets childDType
 
+// For broken() function, return error string if have a match
+#define BROKEN_RTN(test) do { if (VL_UNLIKELY(test)) return # test; } while(0)
+
 //######################################################################
 
 class AstType {
@@ -47,7 +51,9 @@ public:
     //   enum en {...};
     //   const char* ascii() const {...};
     enum en m_e;
+    // cppcheck-suppress uninitVar  // responsiblity of each subclass
     inline AstType () {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstType (en _e) : m_e(_e) {}
     explicit inline AstType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -82,12 +88,16 @@ public:
 	return names[m_e];
     };
     inline AstNumeric () : m_e(UNSIGNED) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstNumeric (en _e) : m_e(_e) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstNumeric (VSignedState signst) {
 	if (signst==signedst_UNSIGNED) m_e=UNSIGNED;
 	else if (signst==signedst_SIGNED) m_e=SIGNED;
 	else m_e=NOSIGN;
     }
+    static inline AstNumeric fromBool (bool isSigned) {  // Factory method
+	return isSigned ? AstNumeric(SIGNED) : AstNumeric(UNSIGNED); }
     explicit inline AstNumeric (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
     inline bool isSigned() const { return m_e==SIGNED; }
@@ -114,6 +124,7 @@ public:
     };
     enum en m_e;
     inline AstPragmaType () : m_e(ILLEGAL) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstPragmaType (en _e) : m_e(_e) {}
     explicit inline AstPragmaType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -137,6 +148,7 @@ public:
     };
     enum en m_e;
     inline AstCFuncType () : m_e(FT_NORMAL) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstCFuncType (en _e) : m_e(_e) {}
     explicit inline AstCFuncType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -205,6 +217,7 @@ public:
 	return names[m_e];
     };
     inline AstEdgeType () : m_e(ET_ILLEGAL) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstEdgeType (en _e) : m_e(_e) {}
     explicit inline AstEdgeType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -219,7 +232,26 @@ class AstAttrType {
 public:
     enum en {
 	ILLEGAL,
-	EXPR_BITS,			// V3Const converts to constant
+	//
+	DIM_BITS,			// V3Const converts to constant
+	DIM_DIMENSIONS,			// V3Width converts to constant
+	DIM_HIGH,			// V3Width processes
+	DIM_INCREMENT,			// V3Width processes
+	DIM_LEFT,			// V3Width processes
+	DIM_LOW,			// V3Width processes
+	DIM_RIGHT,			// V3Width processes
+	DIM_SIZE,			// V3Width processes
+	DIM_UNPK_DIMENSIONS,		// V3Width converts to constant
+	//
+	DT_PUBLIC,			// V3LinkParse moves to AstTypedef::attrPublic
+	//
+	ENUM_BASE,			// V3LinkResolve creates for AstPreSel, V3LinkParam removes
+	ENUM_FIRST,			// V3Width processes
+	ENUM_LAST,			// V3Width processes
+	ENUM_NUM,			// V3Width processes
+	ENUM_NEXT,			// V3Width processes
+	ENUM_PREV,			// V3Width processes
+	ENUM_NAME,			// V3Width processes
 	//
 	MEMBER_BASE,			// V3LinkResolve creates for AstPreSel, V3LinkParam removes
 	//
@@ -232,19 +264,28 @@ public:
 	VAR_PUBLIC_FLAT_RW,		// V3LinkParse moves to AstVar::sigPublic
 	VAR_ISOLATE_ASSIGNMENTS,	// V3LinkParse moves to AstVar::attrIsolateAssign
 	VAR_SC_BV,			// V3LinkParse moves to AstVar::attrScBv
-	VAR_SFORMAT			// V3LinkParse moves to AstVar::attrSFormat
+	VAR_SFORMAT,			// V3LinkParse moves to AstVar::attrSFormat
+	VAR_CLOCKER,                    // V3LinkParse moves to AstVar::attrClocker
+	VAR_NO_CLOCKER                  // V3LinkParse moves to AstVar::attrClocker
     };
     enum en m_e;
     const char* ascii() const {
 	static const char* names[] = {
-	    "%E-AT", "EXPR_BITS", "MEMBER_BASE",
+	    "%E-AT",
+	    "DIM_BITS", "DIM_DIMENSIONS", "DIM_HIGH", "DIM_INCREMENT", "DIM_LEFT",
+	    "DIM_LOW", "DIM_RIGHT", "DIM_SIZE", "DIM_UNPK_DIMENSIONS",
+	    "DT_PUBLIC",
+	    "ENUM_BASE", "ENUM_FIRST", "ENUM_LAST", "ENUM_NUM", "ENUM_NEXT", "ENUM_PREV", "ENUM_NAME",
+	    "MEMBER_BASE",
 	    "VAR_BASE", "VAR_CLOCK", "VAR_CLOCK_ENABLE", "VAR_PUBLIC",
 	    "VAR_PUBLIC_FLAT", "VAR_PUBLIC_FLAT_RD","VAR_PUBLIC_FLAT_RW",
-	    "VAR_ISOLATE_ASSIGNMENTS", "VAR_SC_BV", "VAR_SFORMAT"
+	    "VAR_ISOLATE_ASSIGNMENTS", "VAR_SC_BV", "VAR_SFORMAT", "VAR_CLOCKER",
+	    "VAR_NO_CLOCKER"
 	};
 	return names[m_e];
     };
     inline AstAttrType () : m_e(ILLEGAL) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstAttrType (en _e) : m_e(_e) {}
     explicit inline AstAttrType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -304,6 +345,7 @@ public:
 	UASSERT(0==strcmp(AstBasicDTypeKwd(_ENUM_MAX).dpiType()," MAX"),"Enum array mismatch");
     }
     inline AstBasicDTypeKwd () : m_e(UNKNOWN) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstBasicDTypeKwd (en _e) : m_e(_e) {}
     explicit inline AstBasicDTypeKwd (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -362,9 +404,8 @@ public:
     bool isOpaque() const {  // IE not a simple number we can bit optimize
 	return (m_e==STRING || m_e==SCOPEPTR || m_e==CHARPTR || m_e==DOUBLE || m_e==FLOAT);
     }
-    bool isDouble() const {
-	return (m_e==DOUBLE);
-    }
+    bool isDouble() const { return m_e==DOUBLE; }
+    bool isString() const { return m_e==STRING; }
   };
   inline bool operator== (AstBasicDTypeKwd lhs, AstBasicDTypeKwd rhs) { return (lhs.m_e == rhs.m_e); }
   inline bool operator== (AstBasicDTypeKwd lhs, AstBasicDTypeKwd::en rhs) { return (lhs.m_e == rhs); }
@@ -394,10 +435,12 @@ public:
 	BLOCKTEMP,
 	MODULETEMP,
 	STMTTEMP,
-	XTEMP
+	XTEMP,
+	IFACEREF	// Used to link Interfaces between modules
     };
     enum en m_e;
     inline AstVarType () : m_e(UNKNOWN) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstVarType (en _e) : m_e(_e) {}
     explicit inline AstVarType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -408,7 +451,8 @@ public:
 	    "SUPPLY0","SUPPLY1","WIRE","IMPLICITWIRE",
 	    "TRIWIRE","TRI0","TRI1",
 	    "PORT",
-	    "BLOCKTEMP","MODULETEMP","STMTTEMP","XTEMP"};
+	    "BLOCKTEMP","MODULETEMP","STMTTEMP","XTEMP",
+	    "IFACEREF"};
 	return names[m_e]; }
     bool isSignal() const  { return (m_e==WIRE || m_e==IMPLICITWIRE
 				     || m_e==TRIWIRE
@@ -434,6 +478,7 @@ public:
     enum en m_e;
     // CONSTRUCTOR - note defaults to *UNKNOWN*
     inline AstBranchPred () : m_e(BP_UNKNOWN) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstBranchPred (en _e) : m_e(_e) {}
     explicit inline AstBranchPred (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -454,22 +499,81 @@ public:
 
 //######################################################################
 
-class AstCaseType {
+class AstVarAttrClocker {
+public:
+    enum en {
+	CLOCKER_UNKNOWN=0,
+	CLOCKER_YES,
+	CLOCKER_NO,
+	_ENUM_END
+    };
+    enum en m_e;
+    // CONSTRUCTOR - note defaults to *UNKNOWN*
+    inline AstVarAttrClocker () : m_e(CLOCKER_UNKNOWN) {}
+    // cppcheck-suppress noExplicitConstructor
+    inline AstVarAttrClocker (en _e) : m_e(_e) {}
+    explicit inline AstVarAttrClocker (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
+    AstVarAttrClocker invert() const {
+	if (m_e==CLOCKER_YES) return CLOCKER_NO;
+	else if (m_e==CLOCKER_NO) return CLOCKER_YES;
+	else return m_e;
+    }
+    const char* ascii() const {
+	static const char* names[] = {
+	    "","clker","non_clker"};
+	return names[m_e]; }
+  };
+  inline bool operator== (AstVarAttrClocker lhs, AstVarAttrClocker rhs) { return (lhs.m_e == rhs.m_e); }
+  inline bool operator== (AstVarAttrClocker lhs, AstVarAttrClocker::en rhs) { return (lhs.m_e == rhs); }
+  inline bool operator== (AstVarAttrClocker::en lhs, AstVarAttrClocker rhs) { return (lhs == rhs.m_e); }
+  inline ostream& operator<<(ostream& os, AstVarAttrClocker rhs) { return os<<rhs.ascii(); }
+
+//######################################################################
+
+class VAlwaysKwd {
+public:
+    enum en {
+	ALWAYS,
+	ALWAYS_FF,
+	ALWAYS_LATCH,
+	ALWAYS_COMB
+    };
+    enum en m_e;
+    inline VAlwaysKwd () : m_e(ALWAYS) {}
+    // cppcheck-suppress noExplicitConstructor
+    inline VAlwaysKwd (en _e) : m_e(_e) {}
+    explicit inline VAlwaysKwd (int _e) : m_e(static_cast<en>(_e)) {}
+    operator en () const { return m_e; }
+    const char* ascii() const {
+	static const char* names[] = {
+	    "always","always_ff","always_latch","always_comb"};
+	return names[m_e]; }
+  };
+  inline bool operator== (VAlwaysKwd lhs, VAlwaysKwd rhs) { return (lhs.m_e == rhs.m_e); }
+  inline bool operator== (VAlwaysKwd lhs, VAlwaysKwd::en rhs) { return (lhs.m_e == rhs); }
+  inline bool operator== (VAlwaysKwd::en lhs, VAlwaysKwd rhs) { return (lhs == rhs.m_e); }
+
+//######################################################################
+
+class VCaseType {
 public:
     enum en {
 	CT_CASE,
 	CT_CASEX,
-	CT_CASEZ
+	CT_CASEZ,
+	CT_CASEINSIDE
     };
     enum en m_e;
-    inline AstCaseType () : m_e(CT_CASE) {}
-    inline AstCaseType (en _e) : m_e(_e) {}
-    explicit inline AstCaseType (int _e) : m_e(static_cast<en>(_e)) {}
+    inline VCaseType () : m_e(CT_CASE) {}
+    // cppcheck-suppress noExplicitConstructor
+    inline VCaseType (en _e) : m_e(_e) {}
+    explicit inline VCaseType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
   };
-  inline bool operator== (AstCaseType lhs, AstCaseType rhs) { return (lhs.m_e == rhs.m_e); }
-  inline bool operator== (AstCaseType lhs, AstCaseType::en rhs) { return (lhs.m_e == rhs); }
-  inline bool operator== (AstCaseType::en lhs, AstCaseType rhs) { return (lhs == rhs.m_e); }
+  inline bool operator== (VCaseType lhs, VCaseType rhs) { return (lhs.m_e == rhs.m_e); }
+  inline bool operator== (VCaseType lhs, VCaseType::en rhs) { return (lhs.m_e == rhs); }
+  inline bool operator== (VCaseType::en lhs, VCaseType rhs) { return (lhs == rhs.m_e); }
 
 //######################################################################
 
@@ -485,6 +589,7 @@ public:
     };
     enum en m_e;
     inline AstDisplayType () : m_e(DT_DISPLAY) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstDisplayType (en _e) : m_e(_e) {}
     explicit inline AstDisplayType (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -509,6 +614,7 @@ public:
     };
     enum en m_e;
     inline AstParseRefExp() : m_e(PX_NONE) {}
+    // cppcheck-suppress noExplicitConstructor
     inline AstParseRefExp (en _e) : m_e(_e) {}
     explicit inline AstParseRefExp (int _e) : m_e(static_cast<en>(_e)) {}
     operator en () const { return m_e; }
@@ -527,8 +633,8 @@ public:
 // See also AstRange, which is a symbolic version of this
 
 struct VNumRange {
-    int		m_msb;		// MSB, MSB always >= LSB
-    int		m_lsb;		// LSB
+    int		m_hi;		// HI part, HI always >= LO
+    int		m_lo;		// LO
     union {
 	int mu_flags;
 	struct {
@@ -537,34 +643,42 @@ struct VNumRange {
 	};
     };
     inline bool operator== (const VNumRange& rhs) const {
-	return m_msb == rhs.m_msb
-	    && m_lsb == rhs.m_lsb
+	return m_hi == rhs.m_hi
+	    && m_lo == rhs.m_lo
 	    && mu_flags == rhs.mu_flags; }
     inline bool operator< (const VNumRange& rhs) const {
-	if ( (m_msb <  rhs.m_msb)) return true;
-	if (!(m_msb == rhs.m_msb)) return false;  // lhs > rhs
-	if ( (m_lsb <  rhs.m_lsb)) return true;
-	if (!(m_lsb == rhs.m_lsb)) return false;  // lhs > rhs
+	if ( (m_hi <  rhs.m_hi)) return true;
+	if (!(m_hi == rhs.m_hi)) return false;  // lhs > rhs
+	if ( (m_lo <  rhs.m_lo)) return true;
+	if (!(m_lo == rhs.m_lo)) return false;  // lhs > rhs
 	if ( (mu_flags <  rhs.mu_flags)) return true;
 	if (!(mu_flags == rhs.mu_flags)) return false;  // lhs > rhs
 	return false;
     }
     //
-    VNumRange() : m_msb(0), m_lsb(0), mu_flags(0) {}
+    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() {}
     // MEMBERS
-    void init(int msb, int lsb, bool littleEndian) {
-	m_msb=msb; m_lsb=lsb; mu_flags=0; m_ranged=true; m_littleEndian=littleEndian;
+    void init(int hi, int lo, bool littleEndian) {
+	m_hi=hi; m_lo=lo; mu_flags=0; m_ranged=true; m_littleEndian=littleEndian;
     }
-    int msb() const { return m_msb; }
-    int lsb() const { return m_lsb; }
-    int left() const { return littleEndian()?lsb():msb(); }  // How to show a declaration
-    int right() const { return littleEndian()?msb():lsb(); }
+    int hi() const { return m_hi; }
+    int lo() const { return m_lo; }
+    int left() const { return littleEndian()?lo():hi(); }  // How to show a declaration
+    int right() const { return littleEndian()?hi():lo(); }
+    int leftToRightInc() const { return littleEndian()?1:-1; }
+    int elements() const { return hi()-lo()+1; }
     bool ranged() const { return m_ranged; }
     bool littleEndian() const { return m_littleEndian; }
+    int hiMaxSelect() const { return (lo()<0 ? hi()-lo() : hi()); } // Maximum value a [] select may index
     bool representableByWidth() const  // Could be represented by just width=1, or [width-1:0]
-	{ return (!m_ranged || (m_lsb==0 && m_msb>=1 && !m_littleEndian)); }
+	{ 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; }
 
 //######################################################################
 
@@ -765,7 +879,7 @@ protected:
     RelinkWhatEn m_chg;
     AstNode** m_iterpp;
 public:
-    AstNRelinker() { m_backp=NULL; m_chg=RELINK_BAD; m_iterpp=NULL;}
+    AstNRelinker() { m_oldp=NULL; m_backp=NULL; m_chg=RELINK_BAD; m_iterpp=NULL;}
     void relink(AstNode* newp);
     AstNode* oldp() const { return m_oldp; }
     void dump(ostream& str=cout) const;
@@ -798,16 +912,19 @@ public:
     // CREATORS
     class Illegal {};		// for creator type-overload selection
     class FullValue {};		// for creator type-overload selection
-    V3Hash(Illegal) { m_both=0; }
+    explicit V3Hash(Illegal) { m_both=0; }
     // Saving and restoring inside a userp
-    V3Hash(AstNUser* up) { m_both=up->castInt(); }
+    explicit V3Hash(AstNUser* up) { m_both=up->castInt(); }
     V3Hash operator+= (const V3Hash& rh) {
 	setBoth(depth()+rh.depth(), (hshval()*31+rh.hshval()));
 	return *this; };
     // Creating from raw data (sameHash functions)
     V3Hash() { setBoth(1,0); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(uint32_t val) { setBoth(1,val); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(const void* vp) { setBoth(1,cvtToHash(vp)); }
+    // cppcheck-suppress noExplicitConstructor
     V3Hash(const string& name);
     V3Hash(V3Hash h1, V3Hash h2) {
 	setBoth(1,h1.hshval()*31+h2.hshval()); }
@@ -875,12 +992,15 @@ class AstNode {
 
     void	init();	// initialize value of AstNode
     void	iterateListBackwards(AstNVisitor& v, AstNUser* vup=NULL);
+private:
     AstNode*	cloneTreeIter();
     AstNode*	cloneTreeIterList();
     void	checkTreeIter(AstNode* backp);
     void	checkTreeIterList(AstNode* backp);
-    bool	sameTreeIter(AstNode* node2p, bool ignNext);
+    bool	gateTreeIter();
+    bool	sameTreeIter(AstNode* node2p, bool ignNext, bool gateOnly);
     void	deleteTreeIter();
+public:
     void	deleteNode();
     static void	relinkOneLink(AstNode*& pointpr, AstNode* newp);
     // cppcheck-suppress functionConst
@@ -889,7 +1009,7 @@ class AstNode {
 protected:
     // CONSTUCTORS
     AstNode() {init(); }
-    AstNode(FileLine* fileline) {init(); m_fileline = fileline; }
+    explicit AstNode(FileLine* fileline) {init(); m_fileline = fileline; }
     virtual AstNode* clone() = 0;	// Generally, cloneTree is what you want instead
     virtual void cloneRelink() {}
     void 	cloneRelinkTree();
@@ -951,6 +1071,7 @@ public:
     static int	instrCountDouble() { return 8; }	///< Instruction cycles to convert or do floats
     static int	instrCountDoubleDiv() { return 40; }	///< Instruction cycles to divide floats
     static int	instrCountDoubleTrig() { return 200; }	///< Instruction cycles to do triganomics
+    static int	instrCountString() { return 100; }	///< Instruction cycles to do string ops
     static int	instrCountCall() { return instrCountBranch()+10; }	///< Instruction cycles to call subroutine
     static int	instrCountTime() { return instrCountCall()+5; }		///< Instruction cycles to determine simulation time
 
@@ -960,13 +1081,13 @@ public:
     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
-    static string quoteName(const string& namein);	// Name with control chars quoted
     static string prettyName(const string& namein);	// Name for printing out to the user
     static string encodeName(const string& namein);	// Encode user name into internal C representation
     static string encodeNumber(vlsint64_t numin);	// Encode number into internal C representation
     static string vcdName(const string& namein); // Name for printing out to vcd files
     string	prettyName() const { return prettyName(name()); }
-    string	prettyTypeName() const;			// "VARREF name" for error messages
+    string 	prettyTypeName() const;			// "VARREF" for error messages
+    virtual string prettyOperatorName() const { return "operator "+prettyTypeName(); }
     FileLine*	fileline() const { return m_fileline; }
     void	fileline(FileLine* fl) { m_fileline=fl; }
     bool	width1() const;
@@ -980,11 +1101,13 @@ public:
     //TODO stomp these width functions out, and call via dtypep() instead
     int		width() const;
     int		widthMin() const;
+    int		widthMinV() const { return v3Global.widthMinUsage()==VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width(); }
     int		widthWords() const { return VL_WORDS_I(width()); }
     bool	isQuad() const { return (width()>VL_WORDSIZE && width()<=VL_QUADSIZE); }
     bool	isWide() const { return (width()>VL_QUADSIZE); }
     bool	isDouble() const;
     bool	isSigned() const;
+    bool	isString() const;
 
     AstNUser*	user1p() const {
 	// Slows things down measurably, so disabled by default
@@ -1057,11 +1180,12 @@ public:
     void	dtypeFrom(AstNode* fromp) { if (fromp) { dtypep(fromp->dtypep()); }}
     void	dtypeChgSigned(bool flag=true);
     void	dtypeChgWidth(int width, int widthMin);
-    void	dtypeChgWidthSigned(int width, int widthMin, bool issigned);
+    void	dtypeChgWidthSigned(int width, int widthMin, AstNumeric numeric);
     void	dtypeSetBitSized(int width, int widthMin, AstNumeric numeric) { dtypep(findBitDType(width,widthMin,numeric)); }
     void	dtypeSetLogicSized(int width, int widthMin, AstNumeric numeric) { dtypep(findLogicDType(width,widthMin,numeric)); }
     void	dtypeSetLogicBool()	{ dtypep(findLogicBoolDType()); }
     void	dtypeSetDouble()	{ dtypep(findDoubleDType()); }
+    void	dtypeSetString()	{ dtypep(findStringDType()); }
     void	dtypeSetSigned32()	{ dtypep(findSigned32DType()); }
     void	dtypeSetUInt32()	{ dtypep(findUInt32DType()); }  // Twostate
     void	dtypeSetUInt64()	{ dtypep(findUInt64DType()); }  // Twostate
@@ -1069,11 +1193,13 @@ public:
     // Data type locators
     AstNodeDType* findLogicBoolDType()	{ return findBasicDType(AstBasicDTypeKwd::LOGIC); }
     AstNodeDType* findDoubleDType()	{ return findBasicDType(AstBasicDTypeKwd::DOUBLE); }
+    AstNodeDType* findStringDType()	{ return findBasicDType(AstBasicDTypeKwd::STRING); }
     AstNodeDType* findSigned32DType()	{ return findBasicDType(AstBasicDTypeKwd::INTEGER); }
     AstNodeDType* findUInt32DType()	{ return findBasicDType(AstBasicDTypeKwd::UINT32); }  // Twostate
     AstNodeDType* findUInt64DType()	{ return findBasicDType(AstBasicDTypeKwd::UINT64); }  // Twostate
     AstNodeDType* findBitDType(int width, int widthMin, AstNumeric numeric) const;
     AstNodeDType* findLogicDType(int width, int widthMin, AstNumeric numeric) const;
+    AstNodeDType* findLogicRangeDType(VNumRange range, int widthMin, AstNumeric numeric) const;
     AstNodeDType* findBasicDType(AstBasicDTypeKwd kwd) const;
     AstBasicDType* findInsertSameDType(AstBasicDType* nodep);
 
@@ -1102,21 +1228,26 @@ public:
 
     // METHODS - Iterate on a tree
     AstNode*	cloneTree(bool cloneNextLink);
+    bool	gateTree() { return gateTreeIter(); }  // Is tree gateOptimizable?
     bool	sameTree(AstNode* node2p);	// Does tree of this == node2p?
+    bool	sameGateTree(AstNode* node2p);	// Does tree of this == node2p?, not allowing non-isGateOptimizable
     void	deleteTree();	// Always deletes the next link
     void	checkTree();  // User Interface version
+    void	checkIter() const;
+    void	clearIter() { m_iterpp=NULL; }
     void	dumpPtrs(ostream& str=cout) const;
     void	dumpTree(ostream& str=cout, const string& indent="    ", int maxDepth=0);
     void	dumpTree(const string& indent, int maxDepth=0) { dumpTree(cout,indent,maxDepth); }
     void	dumpTreeGdb(); // For GDB only
     void	dumpTreeAndNext(ostream& str=cout, const string& indent="    ", int maxDepth=0);
-    void	dumpTreeFile(const string& filename, bool append=false);
+    void	dumpTreeFile(const string& filename, bool append=false, bool doDump=true);
     static void	dumpTreeFileGdb(const char* filenamep=NULL);
 
     // METHODS - queries
     virtual bool isPure() const { return true; }	// Else a $display, etc, that must be ordered with other displays
     virtual bool isBrancher() const { return false; }	// Changes control flow, disable some optimizations
     virtual bool isGateOptimizable() const { return true; }	// Else a AstTime etc that can't be pushed out
+    virtual bool isGateDedupable() const { return isGateOptimizable(); }  // GateDedupable is a slightly larger superset of GateOptimzable (eg, AstNodeIf)
     virtual bool isSubstOptimizable() const { return true; }	// Else a AstTime etc that can't be substituted out
     virtual bool isPredictOptimizable() const { return true; }	// Else a AstTime etc which output can't be predicted from input
     virtual bool isOutputter() const { return false; }	// Else creates output or exits, etc, not unconsumed
@@ -1127,15 +1258,17 @@ public:
     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.
-    virtual bool broken() const { return false; }
+    virtual const char* broken() const { return NULL; }
 
     // INVOKERS
     virtual void accept(AstNVisitor& v, AstNUser* vup=NULL) = 0;
     void	iterate(AstNVisitor& v, AstNUser* vup=NULL) { this->accept(v,vup); } 	  // Does this; excludes following this->next
     void	iterateAndNext(AstNVisitor& v, AstNUser* vup=NULL);
-    void	iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup=NULL);
+    void	iterateAndNextConst(AstNVisitor& v, AstNUser* vup=NULL);
+    void	iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup=NULL) { iterateAndNextConst(v, vup); }
     void	iterateChildren(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
     void	iterateChildrenBackwards(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
+    void	iterateChildrenConst(AstNVisitor& v, AstNUser* vup=NULL);  // Excludes following this->next
     AstNode*	acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup=NULL);  // Return edited nodep; see comments in V3Ast.cpp
 
     // CONVERSION
@@ -1156,9 +1289,10 @@ inline void AstNRelinker::relink(AstNode* newp) { newp->AstNode::relink(this); }
     virtual ~Ast ##name() {} \
     Ast ##name * cloneTree(bool cloneNext) { return AstNode::cloneTree(cloneNext)->cast ##name(); }
 
-struct AstNodeMath : public AstNode {
+class AstNodeMath : public AstNode {
     // Math -- anything that's part of an expression tree
-    AstNodeMath(FileLine* fl)
+public:
+    explicit AstNodeMath(FileLine* fl)
 	: AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeMath)
     // METHODS
@@ -1172,9 +1306,10 @@ struct AstNodeMath : public AstNode {
     bool isOpaque() { return castCvtPackString()!=NULL; }
 };
 
-struct AstNodeTermop : public AstNodeMath {
+class AstNodeTermop : public AstNodeMath {
     // Terminal operator -- a operator with no "inputs"
-    AstNodeTermop(FileLine* fl)
+public:
+    explicit AstNodeTermop(FileLine* fl)
 	: AstNodeMath(fl) {}
     ASTNODE_BASE_FUNCS(NodeTermop)
     // Know no children, and hot function, so skip iterator for speed
@@ -1183,8 +1318,9 @@ struct AstNodeTermop : public AstNodeMath {
     void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
 };
 
-struct AstNodeUniop : public AstNodeMath {
+class AstNodeUniop : public AstNodeMath {
     // Unary math
+public:
     AstNodeUniop(FileLine* fl, AstNode* lhsp)
 	: AstNodeMath(fl) {
 	dtypeFrom(lhsp);
@@ -1196,15 +1332,17 @@ struct AstNodeUniop : public AstNodeMath {
     virtual void numberOperate(V3Number& out, const V3Number& lhs) = 0; // Set out to evaluation of a AstConst'ed lhs
     virtual bool cleanLhs() = 0;
     virtual bool sizeMattersLhs() = 0; // True if output result depends on lhs size
-    virtual bool signedFlavor() const { return false; }	// Signed flavor of nodes with both flavors?
     virtual bool doubleFlavor() const { return false; }	// D flavor of nodes with both flavors?
+    virtual bool signedFlavor() const { return false; }	// Signed flavor of nodes with both flavors?
+    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; }
 };
 
-struct AstNodeBiop : public AstNodeMath {
+class AstNodeBiop : public AstNodeMath {
     // Binary math
+public:
     AstNodeBiop(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); }
@@ -1219,15 +1357,17 @@ struct AstNodeBiop : public AstNodeMath {
     virtual bool cleanRhs() = 0; // True if RHS must have extra upper bits zero
     virtual bool sizeMattersLhs() = 0; // True if output result depends on lhs size
     virtual bool sizeMattersRhs() = 0; // True if output result depends on rhs size
-    virtual bool signedFlavor() const { return false; }	// Signed flavor of nodes with both flavors?
     virtual bool doubleFlavor() const { return false; }	// D flavor of nodes with both flavors?
+    virtual bool signedFlavor() const { return false; }	// Signed flavor of nodes with both flavors?
+    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; }
 };
 
-struct AstNodeTriop : public AstNodeMath {
+class AstNodeTriop : public AstNodeMath {
     // Trinary math
+public:
     AstNodeTriop(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
 	: AstNodeMath(fl) {
 	setOp1p(lhs); setOp2p(rhs); setOp3p(ths); }
@@ -1251,20 +1391,23 @@ struct AstNodeTriop : public AstNodeMath {
     virtual bool same(AstNode*) const { return true; }
 };
 
-struct AstNodeBiCom : public AstNodeBiop {
+class AstNodeBiCom : public AstNodeBiop {
     // Binary math with commutative properties
+public:
     AstNodeBiCom(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeBiop(fl, lhs, rhs) {}
     ASTNODE_BASE_FUNCS(NodeBiCom)
 };
 
-struct AstNodeBiComAsv : public AstNodeBiCom {
+class AstNodeBiComAsv : public AstNodeBiCom {
     // Binary math with commutative & associative properties
+public:
     AstNodeBiComAsv(FileLine* fl, AstNode* lhs, AstNode* rhs)
 	: AstNodeBiCom(fl, lhs, rhs) {}
     ASTNODE_BASE_FUNCS(NodeBiComAsv)
 };
-struct AstNodeCond : public AstNodeTriop {
+class AstNodeCond : public AstNodeTriop {
+public:
     AstNodeCond(FileLine* fl, AstNode* condp, AstNode* expr1p, AstNode* expr2p)
 	: AstNodeTriop(fl, condp, expr1p, expr2p) {
 	if (expr1p) dtypeFrom(expr1p);
@@ -1286,8 +1429,9 @@ struct AstNodeCond : public AstNodeTriop {
     virtual int instrCount()	const { return instrCountBranch(); }
 };
 
-struct AstNodePreSel : public AstNode {
+class AstNodePreSel : public AstNode {
     // Something that becomes an AstSel
+public:
     AstNodePreSel(FileLine* fl, AstNode* lhs, AstNode* rhs, AstNode* ths)
 	: AstNode(fl) {
 	setOp1p(lhs); setOp2p(rhs); setNOp3p(ths); }
@@ -1306,9 +1450,10 @@ struct AstNodePreSel : public AstNode {
     virtual bool same(AstNode*) const { return true; }
 };
 
-struct AstNodeStmt : public AstNode {
+class AstNodeStmt : public AstNode {
     // Statement -- anything that's directly under a function
-    AstNodeStmt(FileLine* fl)
+public:
+    explicit AstNodeStmt(FileLine* fl)
 	: AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeStmt)
     // METHODS
@@ -1316,7 +1461,8 @@ struct AstNodeStmt : public AstNode {
     virtual void addBeforeStmt(AstNode* newp, AstNode* belowp);  // Stop statement searchback here
 };
 
-struct AstNodeAssign : public AstNodeStmt {
+class AstNodeAssign : public AstNodeStmt {
+public:
     AstNodeAssign(FileLine* fl, AstNode* lhsp, AstNode* rhsp)
 	: AstNodeStmt(fl) {
 	setOp1p(rhsp); setOp2p(lhsp);
@@ -1337,7 +1483,8 @@ struct AstNodeAssign : public AstNodeStmt {
     virtual string verilogKwd() const { return "="; }
 };
 
-struct AstNodeFor : public AstNodeStmt {
+class AstNodeFor : public AstNodeStmt {
+public:
     AstNodeFor(FileLine* fileline, AstNode* initsp, AstNode* condp,
 	       AstNode* incsp, AstNode* bodysp)
 	: AstNodeStmt(fileline) {
@@ -1354,7 +1501,7 @@ struct AstNodeFor : public AstNodeStmt {
     virtual bool same(AstNode* samep) const { return true; }
 };
 
-struct AstNodeIf : public AstNodeStmt {
+class AstNodeIf : public AstNodeStmt {
 private:
     AstBranchPred	m_branchPred;	// Branch prediction as taken/untaken?
 public:
@@ -1370,6 +1517,7 @@ public:
     void	addIfsp(AstNode* newp)		{ addOp2p(newp); }
     void	addElsesp(AstNode* newp)	{ addOp3p(newp); }
     virtual bool isGateOptimizable() const { return false; }
+    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; }
@@ -1377,7 +1525,8 @@ public:
     AstBranchPred branchPred() const { return m_branchPred; }
 };
 
-struct AstNodeCase : public AstNodeStmt {
+class AstNodeCase : public AstNodeStmt {
+public:
     AstNodeCase(FileLine* fl, AstNode* exprp, AstNode* casesp)
 	: AstNodeStmt(fl) {
 	setOp1p(exprp); addNOp2p(casesp);
@@ -1391,9 +1540,10 @@ struct AstNodeCase : public AstNodeStmt {
     void addNotParallelp(AstNode* nodep) { setOp3p(nodep); }
 };
 
-struct AstNodeSenItem : public AstNode {
+class AstNodeSenItem : public AstNode {
     // An AstSenItem or AstSenGate
-    AstNodeSenItem(FileLine* fl) : AstNode(fl) {}
+public:
+    explicit AstNodeSenItem(FileLine* fl) : AstNode(fl) {}
     ASTNODE_BASE_FUNCS(NodeSenItem)
     virtual bool isClocked() const = 0;
     virtual bool isCombo() const = 0;
@@ -1427,7 +1577,7 @@ public:
     }
     ASTNODE_BASE_FUNCS(NodeVarRef)
     virtual bool hasDType() const { return true; }
-    virtual bool broken() const;
+    virtual const char* broken() const;
     virtual int instrCount() const { return widthInstrs(); }
     virtual void cloneRelink();
     virtual string name()	const { return m_name; }		// * = Var name
@@ -1450,7 +1600,7 @@ public:
     void iterateChildren(AstNVisitor& v, AstNUser* vup=NULL) { }
 };
 
-struct AstNodeText : public AstNode {
+class AstNodeText : public AstNode {
 private:
     string	m_text;
 public:
@@ -1467,11 +1617,11 @@ public:
     const string& text() const { return m_text; }
 };
 
-struct AstNodeDType : public AstNode {
-private:
+class AstNodeDType : public AstNode {
     // Ideally width() would migrate to BasicDType as that's where it makes sense,
     // but it's currently so prevalent in the code we leave it here.
     // Note the below members are included in AstTypeTable::Key lookups
+private:
     int		m_width;	// (also in AstTypeTable::Key) Bit width of operation
     int		m_widthMin;	// (also in AstTypeTable::Key) If unsized, bitwidth of minimum implementation
     AstNumeric	m_numeric;	// (also in AstTypeTable::Key) Node is signed
@@ -1480,7 +1630,7 @@ private:
     static int	s_uniqueNum;	// Unique number assigned to each dtype during creation for IEEE matching
 public:
     // CONSTRUCTORS
-    AstNodeDType(FileLine* fl) : AstNode(fl) {
+    explicit AstNodeDType(FileLine* fl) : AstNode(fl) {
 	m_width=0; m_widthMin=0; m_generic=false;
     }
     ASTNODE_BASE_FUNCS(NodeDType)
@@ -1489,7 +1639,9 @@ public:
     virtual void dumpSmall(ostream& str);
     virtual bool hasDType() const { return true; }
     virtual AstBasicDType* basicp() const = 0;  // (Slow) recurse down to find basic data type
-    virtual AstNodeDType* skipRefp() const = 0;  // recurses over typedefs to next non-typeref type
+    virtual AstNodeDType* skipRefp() const = 0;  // recurses over typedefs/const/enum to next non-typeref type
+    virtual AstNodeDType* skipRefToConstp() const = 0;  // recurses over typedefs to next non-typeref-or-const type
+    virtual AstNodeDType* skipRefToEnump() const = 0;  // recurses over typedefs/const to next non-typeref-or-enum/struct type
     virtual int widthAlignBytes() const = 0; // (Slow) recurses - Structure alignment 1,2,4 or 8 bytes (arrays affect this)
     virtual int widthTotalBytes() const = 0; // (Slow) recurses - Width in bytes rounding up 1,2,4,8,12,...
     virtual bool maybePointedTo() const { return true; }
@@ -1498,7 +1650,7 @@ public:
     //
     // 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; }
-    // For backward compatibility AstArrayDType and others inherit width and signing from the subDType/base type
+    // For backward compatibility inherit width and signing from the subDType/base type
     void widthFromSub(AstNodeDType* nodep) { m_width=nodep->m_width; m_widthMin=nodep->m_widthMin; m_numeric=nodep->m_numeric; }
     //
     int	width() const { return m_width; }
@@ -1514,12 +1666,12 @@ public:
     bool generic() const { return m_generic; }
     void generic(bool flag) { m_generic = flag; }
     AstNodeDType* dtypeDimensionp(int depth);
-    pair<uint32_t,uint32_t> dimensions();
-    uint32_t	arrayElements();	// 1, or total multiplication of all dimensions
+    pair<uint32_t,uint32_t> dimensions(bool includeBasic);
+    uint32_t	arrayUnpackedElements();	// 1, or total multiplication of all dimensions
     static int uniqueNumInc() { return ++s_uniqueNum; }
 };
 
-struct AstNodeClassDType : public AstNodeDType {
+class AstNodeClassDType : public AstNodeDType {
 private:
     // TYPES
     typedef map<string,AstMemberDType*> MemberNameMap;
@@ -1534,27 +1686,81 @@ public:
 	numeric(numericUnpack.isSigned() ? AstNumeric::SIGNED : AstNumeric::UNSIGNED);
     }
     ASTNODE_BASE_FUNCS(NodeClassDType)
-    virtual bool broken() const;
+    virtual const char* broken() const;
     virtual void dump(ostream& str);
     // For basicp() we reuse the size to indicate a "fake" basic type of same size
     virtual AstBasicDType* basicp() const { return findLogicDType(width(),width(),numeric())->castBasicDType(); }
     virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; }
+    virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; }
+    virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; }
     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
     AstMemberDType* membersp() const { return op1p()->castMemberDType(); } // op1 = AstMember list
     void addMembersp(AstNode* nodep) { addNOp1p(nodep); }
     bool packed() const { return m_packed; }
+    bool packedUnsup() const { return true; }  // packed() but as don't support unpacked, presently all structs
     void clearCache() { m_members.clear(); }
     void repairMemberCache();
     AstMemberDType* findMember(const string& name) const {
 	MemberNameMap::const_iterator it = m_members.find(name);
 	return (it==m_members.end()) ? NULL : it->second;
     }
+    int lsb() const { return 0; }
+    int msb() const { return dtypep()->width()-1; }  // Packed classes look like arrays
+    VNumRange declRange() const { return VNumRange(msb(), lsb(), false); }
 };
 
-struct AstNodeSel : public AstNodeBiop {
+class AstNodeArrayDType : public AstNodeDType {
+    // Array data type, ie "some_dtype var_name [2:0]"
+    // Children: DTYPE (moved to refDTypep() in V3Width)
+    // Children: RANGE (array bounds)
+private:
+    AstNodeDType*	m_refDTypep;	// Elements of this type (after widthing)
+    AstNode*	rangenp() const { return op2p(); }	// op2 = Array(s) of variable
+public:
+    explicit AstNodeArrayDType(FileLine* fl) : AstNodeDType(fl) {
+	m_refDTypep = NULL;
+    }
+    ASTNODE_BASE_FUNCS(NodeArrayDType)
+    virtual void dump(ostream& str);
+    virtual void dumpSmall(ostream& str);
+    virtual const char* broken() const { BROKEN_RTN(!((m_refDTypep && !childDTypep() && m_refDTypep->brokeExists())
+						     || (!m_refDTypep && childDTypep()))); return NULL; }
+    virtual void cloneRelink() { if (m_refDTypep && m_refDTypep->clonep()) {
+	m_refDTypep = m_refDTypep->clonep()->castNodeDType();
+    }}
+    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 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(); }
+    void refDTypep(AstNodeDType* nodep) { m_refDTypep = nodep; }
+    virtual AstNodeDType* virtRefDTypep() const { return m_refDTypep; }
+    virtual void virtRefDTypep(AstNodeDType* nodep) { refDTypep(nodep); }
+    AstRange*	rangep() const { return op2p()->castRange(); }	// op2 = Array(s) of variable
+    void	rangep(AstRange* nodep);
+    // METHODS
+    virtual AstBasicDType* basicp() const { return subDTypep()->basicp(); }  // (Slow) recurse down to find basic data type
+    virtual AstNodeDType* skipRefp() const { return (AstNodeDType*)this; }
+    virtual AstNodeDType* skipRefToConstp() const { return (AstNodeDType*)this; }
+    virtual AstNodeDType* skipRefToEnump() const { return (AstNodeDType*)this; }
+    virtual int widthAlignBytes() const { return subDTypep()->widthAlignBytes(); }
+    virtual int widthTotalBytes() const { return elementsConst() * subDTypep()->widthTotalBytes(); }
+    int		msb() const;
+    int		lsb() const;
+    int		elementsConst() const;
+    VNumRange declRange() const;
+};
+
+class AstNodeSel : public AstNodeBiop {
     // Single bit range extraction, perhaps with non-constant selection or array selection
+public:
     AstNodeSel(FileLine* fl, AstNode* fromp, AstNode* bitp)
 	:AstNodeBiop(fl, fromp, bitp) {}
     ASTNODE_BASE_FUNCS(NodeSel)
@@ -1566,10 +1772,21 @@ struct AstNodeSel : public AstNodeBiop {
     virtual bool hasDType() const { return true; }
 };
 
+class AstNodeStream : public AstNodeBiop {
+    // Verilog {rhs{lhs}} - Note rhsp() is the slice size, not the lhsp()
+public:
+    AstNodeStream(FileLine* fl, AstNode* lhsp, AstNode* rhsp) : AstNodeBiop(fl, lhsp, rhsp) {
+	if (lhsp->dtypep()) {
+	    dtypeSetLogicSized(lhsp->dtypep()->width(), lhsp->dtypep()->width(), AstNumeric::UNSIGNED);
+	}
+    }
+    ASTNODE_BASE_FUNCS(NodeStream)
+};
+
 //######################################################################
 // Tasks/functions common handling
 
-struct AstNodeFTask : public AstNode {
+class AstNodeFTask : public AstNode {
 private:
     string	m_name;		// Name of task
     string	m_cname;	// Name of task if DPI import
@@ -1595,6 +1812,7 @@ public:
     virtual void dump(ostream& str=cout);
     virtual string name()	const { return m_name; }		// * = Var name
     virtual bool maybePointedTo() const { return true; }
+    virtual bool isGateOptimizable() const { return !((m_dpiExport || m_dpiImport) && !m_pure); }
     // {AstFunc only} op1 = Range output variable
     virtual void name(const string& name) 	{ m_name = name; }
     string cname() const { return m_cname; }
@@ -1627,7 +1845,7 @@ public:
     bool	pure() const { return m_pure; }
 };
 
-struct AstNodeFTaskRef : public AstNode {
+class AstNodeFTaskRef : public AstNode {
     // A reference to a task (or function)
 private:
     AstNodeFTask*	m_taskp;	// [AfterLink] Pointer to task referenced
@@ -1647,12 +1865,13 @@ public:
 	addNOp2p(pinsp);
     }
     ASTNODE_BASE_FUNCS(NodeFTaskRef)
-    virtual bool broken() const { return m_taskp && !m_taskp->brokeExists(); }
+    virtual const char* broken() const { BROKEN_RTN(m_taskp && !m_taskp->brokeExists()); return NULL; }
     virtual void cloneRelink() { if (m_taskp && m_taskp->clonep()) {
 	m_taskp = m_taskp->clonep()->castNodeFTask();
     }}
     virtual void dump(ostream& str=cout);
     virtual string name()	const { return m_name; }		// * = Var name
+    virtual bool isGateOptimizable() const { return m_taskp && m_taskp->isGateOptimizable(); }
     string	dotted()	const { return m_dotted; }		// * = Scope name or ""
     string	prettyDotted() const { return prettyName(dotted()); }
     string	inlinedDots() const { return m_inlinedDots; }
@@ -1673,7 +1892,7 @@ public:
     void 	scopeNamep(AstNode* nodep) { setNOp3p(nodep); }
 };
 
-struct AstNodeModule : public AstNode {
+class AstNodeModule : public AstNode {
     // A module, package, program or interface declaration;
     // something that can live directly under the TOP,
     // excluding $unit package stuff
@@ -1684,14 +1903,16 @@ private:
     bool	m_modTrace:1;	// Tracing this module
     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
     int		m_level;	// 1=top module, 2=cell off top module, ...
     int		m_varNum;	// Incrementing variable number
+    int		m_typeNum;	// Incrementing implicit type number
 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_level(0), m_varNum(0) { }
+	,m_modPublic(false), m_modTrace(false), m_inLibrary(false), m_dead(false), m_internal(false)
+	,m_level(0), m_varNum(0), m_typeNum(0) { }
     ASTNODE_BASE_FUNCS(NodeModule)
     virtual void dump(ostream& str);
     virtual bool maybePointedTo() const { return true; }
@@ -1711,12 +1932,15 @@ public:
     int  level() const		{ return m_level; }
     bool isTop() const		{ return level()==1; }
     int  varNumGetInc() 	{ return ++m_varNum; }
+    int  typeNumGetInc() 	{ return ++m_typeNum; }
     void modPublic(bool flag) 	{ m_modPublic = flag; }
     bool modPublic() const 	{ return m_modPublic; }
     void modTrace(bool flag) 	{ m_modTrace = flag; }
     bool modTrace() const 	{ return m_modTrace; }
     void dead(bool flag) 	{ m_dead = flag; }
     bool dead() const	 	{ return m_dead; }
+    void internal(bool flag) 	{ m_internal = flag; }
+    bool internal() const	{ return m_internal; }
 };
 
 //######################################################################
@@ -1735,6 +1959,7 @@ inline int AstNode::widthMin() const { return dtypep() ? dtypep()->widthMin() :
 inline bool AstNode::width1() const  { return dtypep() && dtypep()->width()==1; }  // V3Const uses to know it can optimize
 inline int  AstNode::widthInstrs() const { return (!dtypep() ? 1 : (dtypep()->isWide() ? dtypep()->widthWords() : 1)); }
 inline bool AstNode::isDouble() const { return dtypep() && dtypep()->castBasicDType() && dtypep()->castBasicDType()->isDouble(); }
+inline bool AstNode::isString() const { return dtypep() && dtypep()->basicp() && dtypep()->basicp()->isString(); }
 inline bool AstNode::isSigned() const { return dtypep() && dtypep()->isSigned(); }
 
 inline bool AstNode::isZero()     { return (this->castConst() && this->castConst()->num().isEqZero()); }
@@ -1742,7 +1967,20 @@ inline bool AstNode::isNeqZero()  { return (this->castConst() && this->castConst
 inline bool AstNode::isOne()      { return (this->castConst() && this->castConst()->num().isEqOne()); }
 inline bool AstNode::isAllOnes()  { return (this->castConst() && this->castConst()->isEqAllOnes()); }
 inline bool AstNode::isAllOnesV() { return (this->castConst() && this->castConst()->isEqAllOnesV()); }
+inline bool AstNode::sameTree(AstNode* node2p) { return sameTreeIter(node2p, true, false); }
+inline bool AstNode::sameGateTree(AstNode* node2p) { return sameTreeIter(node2p, true, true); }
 
 inline void AstNodeVarRef::init() { if (m_varp) dtypep(m_varp->dtypep()); }
 
+inline void AstNodeArrayDType::rangep(AstRange* nodep) { setOp2p(nodep); }
+inline int AstNodeArrayDType::msb() const { return rangep()->msbConst(); }
+inline int AstNodeArrayDType::lsb() const { return rangep()->lsbConst(); }
+inline int AstNodeArrayDType::elementsConst() const { return rangep()->elementsConst(); }
+inline VNumRange AstNodeArrayDType::declRange() const { return VNumRange(msb(), lsb(), rangep()->littleEndian()); }
+
+inline void AstIfaceRefDType::cloneRelink() {
+    if (m_cellp && m_cellp->clonep()) m_cellp = m_cellp->clonep()->castCell();
+    if (m_ifacep && m_ifacep->clonep()) m_ifacep = m_ifacep->clonep()->castIface();
+    if (m_modportp && m_modportp->clonep()) m_modportp = m_modportp->clonep()->castModport(); }
+
 #endif // Guard

src/V3AstConstOnly.h

@@ -0,0 +1,33 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Ast node structure
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+
+#ifndef _V3ASTCONSTONLY_H_
+#define _V3ASTCONSTONLY_H_ 1
+
+// Include only in visitors that do not not edit nodes, so should use constant iterators
+#define iterateAndNext   error_use_iterateAndNextConst
+#define iterateChildren  error_use_iterateChildrenConst
+
+#define addNext          error_no_addNext_in_ConstOnlyVisitor
+#define replaceWith      error_no_replaceWith_in_ConstOnlyVisitor
+#define deleteTree       error_no_deleteTree_in_ConstOnlyVisitor
+#define unlinkFrBack     error_no_unlinkFrBack_in_ConstOnlyVisitor
+
+#endif // Guard

src/V3AstNodes.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -35,8 +35,22 @@
 // Special methods
 
 // We need these here, because the classes they point to aren't defined when we declare the class
-bool AstNodeVarRef::broken() const { return ((m_varScopep && !m_varScopep->brokeExists())
-					     || (m_varp && !m_varp->brokeExists())); }
+const char* AstIfaceRefDType::broken() const {
+    BROKEN_RTN(m_ifacep && !m_ifacep->brokeExists());
+    BROKEN_RTN(m_cellp && !m_cellp->brokeExists());
+    BROKEN_RTN(m_modportp && !m_modportp->brokeExists());
+    return NULL;
+}
+
+AstIface* AstIfaceRefDType::ifaceViaCellp() const {
+    return ((m_cellp && m_cellp->modp()) ? m_cellp->modp()->castIface() : m_ifacep);
+}
+
+const char* AstNodeVarRef::broken() const {
+    BROKEN_RTN(m_varScopep && !m_varScopep->brokeExists());
+    BROKEN_RTN(m_varp && !m_varp->brokeExists());
+    return NULL;
+}
 
 void AstNodeVarRef::cloneRelink() {
     if (m_varp && m_varp->clonep()) { m_varp = m_varp->clonep()->castVar(); }
@@ -54,18 +68,18 @@ void AstNodeClassDType::repairMemberCache() {
     }
 }
 
-bool AstNodeClassDType::broken() const {
+const char* AstNodeClassDType::broken() const {
     set<AstMemberDType*> exists;
     for (AstMemberDType* itemp = membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
 	exists.insert(itemp);
     }
     for (MemberNameMap::const_iterator it=m_members.begin(); it!=m_members.end(); ++it) {
-	if (exists.find(it->second) == exists.end()) {
+	if (VL_UNLIKELY(exists.find(it->second) == exists.end())) {
 	    this->v3error("Internal: Structure member broken: "<<it->first);
-	    return true;
+	    return "member broken";
 	}
     }
-    return false;
+    return NULL;
 }
 
 int AstBasicDType::widthAlignBytes() const {
@@ -98,18 +112,55 @@ int AstNodeClassDType::widthAlignBytes() const {
     else return 8;
 }
 
+AstNodeBiop* AstEq::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
+    if (lhsp->isDouble() && rhsp->isDouble()) {
+	return new AstEqD(fl, lhsp, rhsp);
+    } else {
+	return new AstEq(fl, lhsp, rhsp);
+    }
+}
+
+AstNodeBiop* AstGte::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
+    if (lhsp->isDouble() && rhsp->isDouble()) {
+	return new AstGteD(fl, lhsp, rhsp);
+    } else if (lhsp->isSigned() && rhsp->isSigned()) {
+	return new AstGteS(fl, lhsp, rhsp);
+    } else {
+	return new AstGte(fl, lhsp, rhsp);
+    }
+}
+
+AstNodeBiop* AstLte::newTyped(FileLine* fl, AstNode* lhsp, AstNode* rhsp) {
+    if (lhsp->isDouble() && rhsp->isDouble()) {
+	return new AstLteD(fl, lhsp, rhsp);
+    } else if (lhsp->isSigned() && rhsp->isSigned()) {
+	return new AstLteS(fl, lhsp, rhsp);
+    } else {
+	return new AstLte(fl, lhsp, rhsp);
+    }
+}
+
+
 bool AstVar::isSigPublic() const {
     return (m_sigPublic || (v3Global.opt.allPublic() && !isTemp() && !isGenVar()));
 }
 
 bool AstVar::isScQuad() const {
-    return (isSc() && isQuad() && !isScBv());
+    return (isSc() && isQuad() && !isScBv() && !isScBigUint());
 }
 
 bool AstVar::isScBv() const {
     return ((isSc() && width() >= v3Global.opt.pinsBv()) || m_attrScBv);
 }
 
+bool AstVar::isScUint() const {
+    return ((isSc() && v3Global.opt.pinsScUint() && width() >= 2 && width() <= 64) && !isScBv());
+}
+
+bool AstVar::isScBigUint() const {
+    return ((isSc() && v3Global.opt.pinsScBigUint() && width() >= 65 && width() <= 512) && !isScBv());
+}
+
 void AstVar::combineType(AstVarType type) {
     // These flags get combined with the existing settings of the flags.
     // We don't test varType for certain types, instead set flags since
@@ -149,7 +200,7 @@ string AstVar::verilogKwd() const {
     }
 }
 
-string AstVar::vlArgType(bool named, bool forReturn) const {
+string AstVar::vlArgType(bool named, bool forReturn, bool forFunc) const {
     if (forReturn) named=false;
     if (forReturn) v3fatalSrc("verilator internal data is never passed as return, but as first argument");
     string arg;
@@ -182,7 +233,7 @@ string AstVar::vlArgType(bool named, bool forReturn) const {
 	arg += " (& "+name();
 	arg += ")["+cvtToStr(widthWords())+"]";
     } else {
-	if (isOutput() || (strtype && isInput())) arg += "&";
+	if (forFunc && (isOutput() || (strtype && isInput()))) arg += "&";
 	if (named) arg += " "+name();
     }
     return arg;
@@ -278,7 +329,11 @@ string AstVar::dpiArgType(bool named, bool forReturn) const {
 }
 
 string AstVar::scType() const {
-    if (isScBv()) {
+    if (isScBigUint()) {
+	return (string("sc_biguint<")+cvtToStr(widthMin())+"> ");  // Keep the space so don't get >>
+    } else if (isScUint()) {
+	return (string("sc_uint<")+cvtToStr(widthMin())+"> ");  // Keep the space so don't get >>
+    } else if (isScBv()) {
 	return (string("sc_bv<")+cvtToStr(widthMin())+"> ");  // Keep the space so don't get >>
     } else if (widthMin() == 1) {
 	return "bool";
@@ -295,6 +350,27 @@ string AstVar::scType() const {
     }
 }
 
+AstVar* AstVar::scVarRecurse(AstNode* nodep) {
+    // See if this is a SC assignment; if so return that type
+    // Historically sc variables are identified by a variable
+    // attribute. TODO it would better be a data type attribute.
+    if (AstVar* anodep = nodep->castVar()) {
+	if (anodep->isSc()) return anodep;
+	else return NULL;
+    }
+    else if (nodep->castVarRef()) {
+	if (nodep->castVarRef()->varp()->isSc()) return nodep->castVarRef()->varp();
+	else return NULL;
+    }
+    else if (nodep->castArraySel()) {
+	if (nodep->op1p()) if (AstVar* p = scVarRecurse(nodep->op1p())) return p;
+	if (nodep->op2p()) if (AstVar* p = scVarRecurse(nodep->op2p())) return p;
+	if (nodep->op3p()) if (AstVar* p = scVarRecurse(nodep->op3p())) return p;
+	if (nodep->op4p()) if (AstVar* p = scVarRecurse(nodep->op4p())) return p;
+    }
+    return NULL;
+}
+
 AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     // dimension passed from AstArraySel::dimension
     // Dimension 0 means the VAR itself, 1 is the closest SEL to the AstVar,
@@ -307,10 +383,12 @@ AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     //	   DECL:	VAR a (ARRAYSEL0 (ARRAYSEL1 (ARRAYSEL2 (DT RANGE3))))
     //	      *or*	VAR a (ARRAYSEL0 (ARRAYSEL1 (ARRAYSEL2 (ARRAYSEL3 (DT))))
     //	   SEL1 needs to select from entire variable which is a pointer to ARRAYSEL0
+    // TODO this function should be removed in favor of recursing the dtype(),
+    // as that allows for more complicated data types.
     int dim = 0;
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstArrayDType* adtypep = dtypep->castArrayDType()) {
+	if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
 	    if ((dim++)==dimension) {
 		return dtypep;
 	    }
@@ -340,11 +418,11 @@ AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
     return NULL;
 }
 
-uint32_t AstNodeDType::arrayElements() {
+uint32_t AstNodeDType::arrayUnpackedElements() {
     uint32_t entries=1;
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstArrayDType* adtypep = dtypep->castArrayDType()) {
+	if (AstUnpackArrayDType* adtypep = dtypep->castUnpackArrayDType()) {
 	    entries *= adtypep->elementsConst();
 	    dtypep = adtypep->subDTypep();
 	}
@@ -356,21 +434,22 @@ uint32_t AstNodeDType::arrayElements() {
     return entries;
 }
 
-pair<uint32_t,uint32_t> AstNodeDType::dimensions() {
+pair<uint32_t,uint32_t> AstNodeDType::dimensions(bool includeBasic) {
     // How many array dimensions (packed,unpacked) does this Var have?
     uint32_t packed = 0;
     uint32_t unpacked = 0;
     for (AstNodeDType* dtypep=this; dtypep; ) {
 	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
-	if (AstArrayDType* adtypep = dtypep->castArrayDType()) {
-	    if (adtypep->isPacked()) packed += 1;
-	    else unpacked += 1;
+	if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
+	    if (adtypep->castPackArrayDType()) packed++;
+	    else unpacked++;
 	    dtypep = adtypep->subDTypep();
+	    continue;
 	}
-	else {
-	    // AstBasicDType - nothing below, 1
-	    break;
+	else if (AstBasicDType* adtypep = dtypep->castBasicDType()) {
+	    if (includeBasic && adtypep->isRanged()) packed++;
 	}
+	break;
     }
     return make_pair(packed, unpacked);
 }
@@ -384,26 +463,12 @@ int AstNodeDType::widthPow2() const {
     return 1;
 }
 
-// Special operators
-int AstArraySel::dimension(AstNode* nodep) {
-    // How many dimensions is this reference from the base variable?
-    // nodep is typically the fromp() of a select; thus the first select
-    // is selecting from the entire variable type - effectively dimension 0.
-    // Dimension passed to AstVar::dtypeDimensionp; see comments there
-    int dim = 0;
-    while (nodep) {
-	if (nodep->castNodeSel()) { dim++; nodep=nodep->castNodeSel()->fromp(); continue; }
-	if (nodep->castNodePreSel()) { dim++; nodep=nodep->castNodePreSel()->fromp(); continue; }
-	break;
-    }
-    return dim;
-}
 AstNode* AstArraySel::baseFromp(AstNode* nodep) {	///< What is the base variable (or const) this dereferences?
     // Else AstArraySel etc; search for the base
     while (nodep) {
 	if (nodep->castArraySel()) { nodep=nodep->castArraySel()->fromp(); continue; }
 	else if (nodep->castSel()) { nodep=nodep->castSel()->fromp(); continue; }
-	// AstNodeSelPre stashes the associated variable under a ATTROF of AstAttrType::VAR_BASE/MEMBER_BASE so it isn't constified
+	// AstNodeSelPre stashes the associated variable under an ATTROF of AstAttrType::VAR_BASE/MEMBER_BASE so it isn't constified
 	else if (nodep->castAttrOf()) { nodep=nodep->castAttrOf()->fromp(); continue; }
 	else if (nodep->castNodePreSel()) {
 	    if (nodep->castNodePreSel()->attrp()) {
@@ -418,10 +483,12 @@ AstNode* AstArraySel::baseFromp(AstNode* nodep) {	///< What is the base variable
     return nodep;
 }
 
-bool AstScope::broken() const {
-    return ((m_aboveScopep && !m_aboveScopep->brokeExists())
-	    || (m_aboveCellp && !m_aboveCellp->brokeExists())
-	    || !m_modp || !m_modp->brokeExists());
+const char* AstScope::broken() const {
+    BROKEN_RTN(m_aboveScopep && !m_aboveScopep->brokeExists());
+    BROKEN_RTN(m_aboveCellp && !m_aboveCellp->brokeExists());
+    BROKEN_RTN(!m_modp);
+    BROKEN_RTN(m_modp && !m_modp->brokeExists());
+    return NULL;
 }
 
 void AstScope::cloneRelink() {
@@ -439,9 +506,9 @@ string AstScope::nameDotless() const {
     return out;
 }
 
-string AstScopeName::scopePrettyName() const {
+string AstScopeName::scopePrettyNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeAttrp(); textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
 	out += textp->text();
     }
     // TOP will be replaced by top->name()
@@ -451,9 +518,9 @@ string AstScopeName::scopePrettyName() const {
     return AstNode::prettyName(out);
 }
 
-string AstScopeName::scopeSymName() const {
+string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
     string out;
-    for (AstText* textp=scopeAttrp(); textp; textp=textp->nextp()->castText()) {
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
 	out += textp->text();
     }
     if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
@@ -555,7 +622,7 @@ AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kw
     LogicMap::const_iterator it = mapr.find(widths);
     if (it != mapr.end()) return it->second;
     //
-    AstBasicDType* new1p = new AstBasicDType(fl, AstBasicDTypeKwd::BIT, numeric, width, widthMin);
+    AstBasicDType* new1p = new AstBasicDType(fl, kwd, numeric, width, widthMin);
     // Because the detailed map doesn't update this map,
     // check the detailed map for this same node, and if found update this map
     // Also adds this new node to the detailed map
@@ -567,6 +634,15 @@ AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kw
     return newp;
 }
 
+AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kwd,
+					       VNumRange range, int widthMin, AstNumeric numeric) {
+    AstBasicDType* new1p = new AstBasicDType(fl, kwd, numeric, range, widthMin);
+    AstBasicDType* newp = findInsertSameDType(new1p);
+    if (newp != new1p) new1p->deleteTree();
+    else addTypesp(newp);
+    return newp;
+}
+
 AstBasicDType* AstTypeTable::findInsertSameDType(AstBasicDType* nodep) {
     VBasicTypeKey key (nodep->width(), nodep->widthMin(), nodep->numeric(),
 		       nodep->keyword(), nodep->nrange());
@@ -664,13 +740,17 @@ void AstNode::dump(ostream& str) {
     } else { // V3Broken will throw an error
 	if (dtypep()) str<<" %Error-dtype-exp=null,got="<<(void*)dtypep();
     }
-    if (name()!="") str<<"  "<<AstNode::quoteName(name());
+    if (name()!="") {
+	if (castConst()) str<<"  "<<name();  // Already quoted
+	else str<<"  "<<V3Number::quoteNameControls(name());
+    }
 }
 
-void AstArrayDType::dump(ostream& str) {
-    this->AstNodeDType::dump(str);
-    if (isPacked()) str<<" [PACKED]";
+void AstAlways::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (keyword() != VAlwaysKwd::ALWAYS) str<<" ["<<keyword().ascii()<<"]";
 }
+
 void AstArraySel::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" [start:"<<start()<<"] [length:"<<length()<<"]";
@@ -701,24 +781,54 @@ void AstDisplay::dump(ostream& str) {
     this->AstNode::dump(str);
     //str<<" "<<displayType().ascii();
 }
-void AstJumpGo::dump(ostream& str) {
-    this->AstNode::dump(str);
-    str<<" -> ";
-    if (labelp()) { labelp()->dump(str); }
-    else { str<<"%Error:UNLINKED"; }
-}
 void AstEnumItemRef::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" -> ";
     if (itemp()) { itemp()->dump(str); }
     else { str<<"UNLINKED"; }
 }
+void AstIfaceRefDType::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (cellName()!="") { str<<" cell="<<cellName(); }
+    if (ifaceName()!="") { str<<" if="<<ifaceName(); }
+    if (modportName()!="") { str<<" mp="<<modportName(); }
+    if (cellp()) { str<<" -> "; cellp()->dump(str); }
+    else if (ifacep()) { str<<" -> "; ifacep()->dump(str); }
+    else { str<<" -> UNLINKED"; }
+}
+void AstIfaceRefDType::dumpSmall(ostream& str) {
+    this->AstNodeDType::dumpSmall(str);
+    str<<"iface";
+}
+void AstJumpGo::dump(ostream& str) {
+    this->AstNode::dump(str);
+    str<<" -> ";
+    if (labelp()) { labelp()->dump(str); }
+    else { str<<"%Error:UNLINKED"; }
+}
+void AstModportFTaskRef::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (isExport()) str<<" EXPORT";
+    if (isImport()) str<<" IMPORT";
+    if (ftaskp()) { str<<" -> "; ftaskp()->dump(str); }
+    else { str<<" -> UNLINKED"; }
+}
+void AstModportVarRef::dump(ostream& str) {
+    this->AstNode::dump(str);
+    str<<" "<<varType();
+    if (varp()) { str<<" -> "; varp()->dump(str); }
+    else { str<<" -> UNLINKED"; }
+}
 void AstPin::dump(ostream& str) {
     this->AstNode::dump(str);
     if (modVarp()) { str<<" -> "; modVarp()->dump(str); }
     else { str<<" ->UNLINKED"; }
     if (svImplicit()) str<<" [.SV]";
 }
+void AstTypedef::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (attrPublic()) str<<" [PUBLIC]";
+}
 void AstRange::dump(ostream& str) {
     this->AstNode::dump(str);
     if (littleEndian()) str<<" [LITTLE]";
@@ -746,10 +856,22 @@ void AstNodeDType::dumpSmall(ostream& str) {
        <<((isSigned()&&!isDouble())?"s":"")
        <<(isNosign()?"n":"")
        <<(isDouble()?"d":"")
-       <<"w"<<(widthSized()?"":"u")<<width();
+       <<(isString()?"str":"");
+    if (!isDouble() && !isString()) {
+	str<<"w"<<(widthSized()?"":"u")<<width();
+    }
     if (!widthSized()) str<<"/"<<widthMin();
     str<<")";
 }
+void AstNodeArrayDType::dumpSmall(ostream& str) {
+    this->AstNodeDType::dumpSmall(str);
+    if (castPackArrayDType()) str<<"p"; else str<<"u";
+    str<<declRange();
+}
+void AstNodeArrayDType::dump(ostream& str) {
+    this->AstNodeDType::dump(str);
+    str<<" "<<declRange();
+}
 void AstNodeModule::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<"  L"<<level();
@@ -761,6 +883,13 @@ void AstPackageImport::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" -> "<<packagep();
 }
+void AstSel::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (declRange().ranged()) {
+	str<<" decl"<<declRange()<<"]";
+	if (declElWidth()!=1) str<<"/"<<declElWidth();
+    }
+}
 void AstTypeTable::dump(ostream& str) {
     this->AstNode::dump(str);
     for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
@@ -792,7 +921,6 @@ void AstTypeTable::dump(ostream& str) {
 	for (DetailedMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
 	    AstBasicDType* dtypep = it->second;
 	    str<<endl;  // Newline from caller, so newline first
-	    stringstream nsstr;
 	    str<<"\t\tdetailed  ->  ";
 	    dtypep->dump(str);
 	}
@@ -812,7 +940,7 @@ void AstVarXRef::dump(ostream& str) {
     if (lvalue()) str<<" [LV] => ";
     else          str<<" [RV] <- ";
     str<<dotted()<<". - ";
-    if (inlinedDots()!="") str<<" flat.="<<inlinedDots()<<" - ";
+    if (inlinedDots()!="") str<<" inline.="<<inlinedDots()<<" - ";
     if (varScopep()) { varScopep()->dump(str); }
     else if (varp()) { varp()->dump(str); }
     else { str<<"UNLINKED"; }

src/V3Begin.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -153,14 +153,14 @@ private:
 	AstNode* addsp = NULL;
 	if (AstNode* stmtsp = nodep->stmtsp()) {
 	    stmtsp->unlinkFrBackWithNext();
-	    addsp = addsp->addNextNull(stmtsp);
+	    if (addsp) { addsp = addsp->addNextNull(stmtsp); } else { addsp = stmtsp; }
 	}
 	if (addsp) {
 	    nodep->replaceWith(addsp);
 	} else {
 	    nodep->unlinkFrBack();
 	}
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     virtual void visit(AstVar* nodep, AstNUser*) {
 	if (m_unnamedScope != "") {
@@ -271,4 +271,5 @@ void V3Begin::debeginAll(AstNetlist* nodep) {
     if (state.anyFuncInBegin()) {
 	BeginRelinkVisitor brvisitor (nodep,&state);
     }
+    V3Global::dumpCheckGlobalTree("begin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Begin.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Branch.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -21,6 +21,9 @@
 //	At each IF/(IF else).
 //	   Count underneath $display/$stop statements.
 //	   If more on if than else, this branch is unlikely, or vice-versa.
+//	At each FTASKREF,
+//	   Count calls into the function
+//	Then, if FTASK is called only once, add inline attribute
 //
 //*************************************************************************
 
@@ -40,9 +43,18 @@
 
 class BranchVisitor : public AstNVisitor {
 private:
+    // NODE STATE
+    // Entire netlist:
+    //  AstFTask::user1()	-> int.  Number of references
+    AstUser1InUse	m_inuser1;
+
+    // TYPES
+    typedef vector<AstCFunc*> CFuncVec;
+
     // STATE
     int		m_likely;	// Excuses for branch likely taken
     int		m_unlikely;	// Excuses for branch likely not taken
+    CFuncVec	m_cfuncsp;	// List of all tasks
 
     // METHODS
     static int debug() {
@@ -55,6 +67,12 @@ private:
 	m_likely = false;
 	m_unlikely = false;
     }
+    void checkUnlikely(AstNode* nodep) {
+	if (nodep->isUnlikely()) {
+	    UINFO(4,"  UNLIKELY: "<<nodep<<endl);
+	    m_unlikely++;
+	}
+    }
 
     // VISITORS
     virtual void visit(AstNodeIf* nodep, AstNUser*) {
@@ -83,20 +101,37 @@ private:
 	m_likely = lastLikely;
 	m_unlikely = lastUnlikely;
     }
-    virtual void visit(AstNode* nodep, AstNUser*) {
-	// Default: Just iterate
-	if (nodep->isUnlikely()) {
-	    UINFO(4,"  UNLIKELY: "<<nodep<<endl);
-	    m_unlikely++;
-	}
+    virtual void visit(AstCCall* nodep, AstNUser*) {
+	checkUnlikely(nodep);
+	nodep->funcp()->user1Inc();
 	nodep->iterateChildren(*this);
     }
+    virtual void visit(AstCFunc* nodep, AstNUser*) {
+	checkUnlikely(nodep);
+	m_cfuncsp.push_back(nodep);
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	checkUnlikely(nodep);
+	nodep->iterateChildren(*this);
+    }
+
+    // METHODS
+    void calc_tasks() {
+	for (CFuncVec::iterator it=m_cfuncsp.begin(); it!=m_cfuncsp.end(); ++it) {
+	    AstCFunc* nodep = *it;
+	    if (!nodep->dontInline()) {
+		nodep->isInline(true);
+	    }
+	}
+    }
 
 public:
     // CONSTUCTORS
-    BranchVisitor(AstNetlist* rootp) {
+    explicit BranchVisitor(AstNetlist* nodep) {
 	reset();
-	rootp->iterateChildren(*this);
+	nodep->iterateChildren(*this);
+	calc_tasks();
     }
     virtual ~BranchVisitor() {}
 };

src/V3Branch.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Broken.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -37,6 +37,9 @@
 #include "V3Broken.h"
 #include "V3Ast.h"
 
+// This visitor does not edit nodes, and is called at error-exit, so should use constant iterators
+#include "V3AstConstOnly.h"
+
 //######################################################################
 
 class BrokenTable : public AstNVisitor {
@@ -47,11 +50,11 @@ private:
     typedef map<const AstNode*,int> NodeMap;
     static NodeMap s_nodes;	// Set of all nodes that exist
     // BITMASK
-    static const int FLAG_ALLOCATED	= 0x01;		// new() and not delete()ed
-    static const int FLAG_IN_TREE	= 0x02;		// Is in netlist tree
-    static const int FLAG_LINKABLE	= 0x04;		// Is in netlist tree, can be linked to
-    static const int FLAG_LEAKED	= 0x08;		// Known to have been leaked
-    static const int FLAG_UNDER_NOW	= 0x10;		// Is in tree as parent of current node
+    enum { FLAG_ALLOCATED	= 0x01 };	// new() and not delete()ed
+    enum { FLAG_IN_TREE		= 0x02 };	// Is in netlist tree
+    enum { FLAG_LINKABLE	= 0x04 };	// Is in netlist tree, can be linked to
+    enum { FLAG_LEAKED		= 0x08 };	// Known to have been leaked
+    enum { FLAG_UNDER_NOW	= 0x10 };	// Is in tree as parent of current node
 public:
     // METHODS
     static void deleted(const AstNode* nodep) {
@@ -71,7 +74,8 @@ public:
 	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated\n");
 	}
 	if (iter == s_nodes.end()) {
-	    s_nodes.insert(make_pair(nodep,FLAG_ALLOCATED));
+	    int flags = FLAG_ALLOCATED;  // This int needed to appease GCC 4.1.2
+	    s_nodes.insert(make_pair(nodep,flags));
 	}
     }
     static void setUnder(const AstNode* nodep, bool flag) {
@@ -182,14 +186,18 @@ private:
     // NODE STATE
     //  Nothing!	// This may be called deep inside other routines
     //			// so userp and friends may not be used
+    // METHODS
+    void processAndIterate(AstNode* nodep) {
+	BrokenTable::addInTree(nodep, nodep->maybePointedTo());
+	nodep->iterateChildrenConst(*this);
+    }
     // VISITORS
     virtual void visit(AstNode* nodep, AstNUser*) {
-	BrokenTable::addInTree(nodep, nodep->maybePointedTo());
-	nodep->iterateChildren(*this);
+	processAndIterate(nodep);
     }
 public:
     // CONSTUCTORS
-    BrokenMarkVisitor(AstNetlist* nodep) {
+    explicit BrokenMarkVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~BrokenMarkVisitor() {}
@@ -200,10 +208,16 @@ public:
 
 class BrokenCheckVisitor : public AstNVisitor {
 private:
-    virtual void visit(AstNode* nodep, AstNUser*) {
+    void checkWidthMin(AstNode* nodep) {
+	if (nodep->width() != nodep->widthMin()
+	    && v3Global.widthMinUsage()==VWidthMinUsage::MATCHES_WIDTH) {
+	    nodep->v3fatalSrc("Width != WidthMin");
+	}
+    }
+    void processAndIterate(AstNode* nodep) {
 	BrokenTable::setUnder(nodep,true);
-	if (nodep->broken()) {
-	    nodep->v3fatalSrc("Broken link in node (or something without maybePointedTo)");
+	if (const char* whyp=nodep->broken()) {
+	    nodep->v3fatalSrc("Broken link in node (or something without maybePointedTo): "<<whyp);
 	}
 	if (nodep->dtypep()) {
 	    if (!nodep->dtypep()->brokeExists()) { nodep->v3fatalSrc("Broken link in node->dtypep() to "<<(void*)nodep->dtypep()); }
@@ -216,24 +230,18 @@ private:
 		if (nodep->dtypep()) nodep->v3fatalSrc("DType on node without hasDType(): "<<nodep->prettyTypeName());
 	    }
 	    if (nodep->getChildDTypep()) nodep->v3fatalSrc("childDTypep() non-null on node after should have removed");
-	    if (AstNodeDType* dnodep = nodep->castNodeDType()) {
-		if (dnodep->width() != dnodep->widthMin()
-		    && v3Global.assertWidthsMatch()) {
-		    dnodep->v3fatalSrc("Width != WidthMin");
-		}
-	    }
+	    if (AstNodeDType* dnodep = nodep->castNodeDType()) checkWidthMin(dnodep);
 	}
-	if (v3Global.assertWidthsMatch()) {
-	    if (nodep->width() != nodep->widthMin()) {
-		nodep->v3fatalSrc("Width != WidthMin");
-	    }
-	}
-	nodep->iterateChildren(*this);
+	checkWidthMin(nodep);
+	nodep->iterateChildrenConst(*this);
 	BrokenTable::setUnder(nodep,false);
     }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	processAndIterate(nodep);
+    }
 public:
     // CONSTUCTORS
-    BrokenCheckVisitor(AstNetlist* nodep) {
+    explicit BrokenCheckVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~BrokenCheckVisitor() {}

src/V3Broken.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Case.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -97,7 +97,8 @@ private:
 		nodep->v3error("Use of x/? constant in generate case statement, (no such thing as 'generate casez')");
 	    } else if (m_caseExprp->castCase() && m_caseExprp->castCase()->casex()) {
 		// Don't sweat it, we already complained about casex in general
-	    } else if (m_caseExprp->castCase() && m_caseExprp->castCase()->casez()) {
+	    } else if (m_caseExprp->castCase() && (m_caseExprp->castCase()->casez()
+						   || m_caseExprp->castCase()->caseInside())) {
 		if (nodep->num().isUnknown()) {
 		    nodep->v3warn(CASEWITHX, "Use of x constant in casez statement, (perhaps intended ?/z in constant)");
 		}
@@ -111,7 +112,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    CaseLintVisitor(AstNodeCase* nodep) {
+    explicit CaseLintVisitor(AstNodeCase* nodep) {
 	m_caseExprp = NULL;
 	nodep->accept(*this);
     }
@@ -245,7 +246,7 @@ private:
 		if (m_valueItem[a] != m_valueItem[b]) { same=false; break; }
 	    }
 	    if (same) {
-		tree1p->deleteTree(); tree1p=NULL;
+		tree1p->deleteTree(); VL_DANGLING(tree1p);
 		return tree0p;
 	    }
 
@@ -294,8 +295,8 @@ private:
 
 	if (ifrootp) nodep->replaceWith(ifrootp);
 	else nodep->unlinkFrBack();
-	nodep->deleteTree(); nodep=NULL;
-	cexprp->deleteTree(); cexprp=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
+	cexprp->deleteTree(); VL_DANGLING(cexprp);
 	if (debug()>=9) ifrootp->dumpTree(cout,"    _simp: ");
     }
 
@@ -322,36 +323,42 @@ private:
 		    icondNextp = icondp->nextp();
 		    icondp->unlinkFrBack();
 
-		    AstNode* and1p;
-		    AstNode* and2p;
+		    AstNode* condp = NULL;  // Default is to use and1p/and2p
 		    AstConst* iconstp = icondp->castConst();
 		    if (iconstp && neverItem(nodep, iconstp)) {
 			// X in casez can't ever be executed
-			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
+			icondp->deleteTree(); VL_DANGLING(icondp); VL_DANGLING(iconstp);
 			// For simplicity, make expression that is not equal, and let later
 			// optimizations remove it
-			and1p = new AstConst(itemp->fileline(), AstConst::LogicFalse());
-			and2p = new AstConst(itemp->fileline(), AstConst::LogicTrue());
+			condp = new AstConst(itemp->fileline(), AstConst::LogicFalse());
+		    } else if (AstInsideRange* irangep = icondp->castInsideRange()) {
+			// Similar logic in V3Width::visit(AstInside)
+			AstNode* ap = AstGte::newTyped(itemp->fileline(),
+						       cexprp->cloneTree(false),
+						       irangep->lhsp()->unlinkFrBack());
+			AstNode* bp = AstLte::newTyped(itemp->fileline(),
+						       cexprp->cloneTree(false),
+						       irangep->rhsp()->unlinkFrBack());
+			condp = new AstAnd(itemp->fileline(), ap, bp);
 		    } else if (iconstp && iconstp->num().isFourState()
-			       && (nodep->casex() || nodep->casez())) {
+			       && (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());
-			and1p = new AstAnd(itemp->fileline(), cexprp->cloneTree(false),
-					   new AstConst(itemp->fileline(), nummask));
-			and2p = new AstAnd(itemp->fileline(),
-					   new AstConst(itemp->fileline(), numval),
-					   new AstConst(itemp->fileline(), nummask));
-			icondp->deleteTree(); icondp=NULL; iconstp=NULL;
+			AstNode* and1p = new AstAnd(itemp->fileline(), cexprp->cloneTree(false),
+						    new AstConst(itemp->fileline(), nummask));
+			AstNode* and2p = new AstAnd(itemp->fileline(),
+						    new AstConst(itemp->fileline(), numval),
+						    new AstConst(itemp->fileline(), nummask));
+			icondp->deleteTree(); VL_DANGLING(icondp); VL_DANGLING(iconstp);
+			condp = AstEq::newTyped(itemp->fileline(), and1p, and2p);
 		    } else {
 			// Not a caseX mask, we can simply build CASEEQ(cexpr icond)
-			and1p = cexprp->cloneTree(false);
-			and2p = icondp;
+			AstNode* and1p = cexprp->cloneTree(false);
+			AstNode* and2p = icondp;
+			condp = AstEq::newTyped(itemp->fileline(), and1p, and2p);
 		    }
-		    AstNodeBiop* condp = (and1p->isDouble()
-					  ? (new AstEqD(itemp->fileline(), and1p, and2p))->castNodeBiop()
-					  : (new AstEq(itemp->fileline(), and1p, and2p))->castNodeBiop());
 		    if (!ifexprp) {
 			ifexprp = condp;
 		    } else {
@@ -362,7 +369,7 @@ private:
 		itemp->condsp(ifexprp);
 	    }
 	}
-	cexprp->deleteTree(); cexprp=NULL;
+	cexprp->deleteTree(); VL_DANGLING(cexprp);
 	if (!hadDefault) {
 	    // If there was no default, add a empty one, this greatly simplifies below code
 	    // and constant propagation will just eliminate it for us later.
@@ -401,9 +408,9 @@ private:
 		}
 	    }
 	    {   // Make the new lower IF and attach in the tree
-		AstNode* itemexprp = ifexprp;  ifexprp=NULL;
+		AstNode* itemexprp = ifexprp; VL_DANGLING(ifexprp);
 		if (depth == (CASE_ENCODER_GROUP_DEPTH)) { // End of group - can skip the condition
-		    itemexprp->deleteTree(); itemexprp=NULL;
+		    itemexprp->deleteTree(); VL_DANGLING(itemexprp);
 		    itemexprp = new AstConst(itemp->fileline(), AstConst::LogicTrue());
 		}
 		AstIf* newp = new AstIf(itemp->fileline(), itemexprp, istmtsp, NULL);
@@ -419,7 +426,7 @@ private:
 	if (debug()>=9) grouprootp->dumpTree(cout,"     _new: ");
 	if (grouprootp) nodep->replaceWith(grouprootp);
 	else nodep->unlinkFrBack();
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
 
     void replaceCaseParallel(AstCase* nodep, bool noOverlapsAllCovered) {
@@ -435,7 +442,7 @@ private:
     bool neverItem(AstCase* casep, AstConst* itemp) {
 	// Xs in case or casez are impossible due to two state simulations
 	if (casep->casex()) {
-	} else if (casep->casez()) {
+	} else if (casep->casez() || casep->caseInside()) {
 	    if (itemp->num().isUnknown()) return true;
 	} else {
 	    if (itemp->num().isFourState()) return true;
@@ -452,10 +459,10 @@ private:
 	    // It's a simple priority encoder or complete statement
 	    // we can make a tree of statements to avoid extra comparisons
 	    ++m_statCaseFast;
-	    replaceCaseFast(nodep); nodep=NULL;
+	    replaceCaseFast(nodep); VL_DANGLING(nodep);
 	} else {
 	    ++m_statCaseSlow;
-	    replaceCaseComplicated(nodep); nodep=NULL;
+	    replaceCaseComplicated(nodep); VL_DANGLING(nodep);
 	}
     }
     //--------------------
@@ -466,7 +473,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CaseVisitor(AstNetlist* nodep) {
+    explicit CaseVisitor(AstNetlist* nodep) {
 	m_caseNoOverlapsAllCovered = false;
 	nodep->accept(*this);
     }
@@ -482,6 +489,7 @@ public:
 void V3Case::caseAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CaseVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("case.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 void V3Case::caseLint(AstNodeCase* nodep) {
     UINFO(4,__FUNCTION__<<": "<<endl);

src/V3Case.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Cast.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2004-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2015 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.
@@ -149,6 +149,7 @@ private:
 	if (!nodep->lvalue()
 	    && !nodep->backp()->castCCast()
 	    && nodep->backp()->castNodeMath()
+	    && !nodep->backp()->castArraySel()
 	    && nodep->backp()->width()
 	    && castSize(nodep) != castSize(nodep->varp())) {
 	    // Cast vars to IData first, else below has upper bits wrongly set
@@ -175,7 +176,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CastVisitor(AstNetlist* nodep) {
+    explicit CastVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CastVisitor() {}
@@ -187,4 +188,5 @@ public:
 void V3Cast::castAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CastVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("cast.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Cast.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2004-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2004-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Cdc.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -184,7 +184,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    CdcWidthVisitor(AstNode* nodep) {
+    explicit CdcWidthVisitor(AstNode* nodep) {
 	m_maxLineno = 0;
 	m_maxFilenameLen = 0;
 	nodep->accept(*this);
@@ -496,7 +496,7 @@ private:
 	}
 
 	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc_edges.txt";
-	const auto_ptr<ofstream> ofp (V3File::new_ofstream(filename));
+	const VL_UNIQUE_PTR<ofstream> ofp (V3File::new_ofstream(filename));
 	if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
 	*ofp<<"Edge Report for "<<v3Global.opt.prefix()<<endl;
 
@@ -526,7 +526,7 @@ private:
 		}
 	    }
 	}
-	sort(report.begin(), report.end());
+	stable_sort(report.begin(), report.end());
 	for (deque<string>::iterator it = report.begin(); it!=report.end(); ++it) {
 	    *ofp << *it;
 	}
@@ -712,6 +712,7 @@ private:
     virtual void visit(AstInitial* nodep, AstNUser*) { }
     virtual void visit(AstTraceInc* nodep, AstNUser*) { }
     virtual void visit(AstCoverToggle* nodep, AstNUser*) { }
+    virtual void visit(AstNodeDType* nodep, AstNUser*) { }
 
     //--------------------
     // Default
@@ -725,7 +726,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CdcVisitor(AstNode* nodep) {
+    explicit CdcVisitor(AstNode* nodep) {
 	m_logicVertexp = NULL;
 	m_scopep = NULL;
 	m_modp = NULL;

src/V3Cdc.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Changed.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -43,6 +43,130 @@
 #include "V3Changed.h"
 #include "V3EmitCBase.h"
 
+//######################################################################
+
+class ChangedState {
+public:
+    // STATE
+    AstNodeModule*	m_topModp;	// Top module
+    AstScope*		m_scopetopp;	// Scope under TOPSCOPE
+    AstCFunc*		m_chgFuncp;	// Change function we're building
+    ChangedState() {
+	m_topModp = NULL;
+	m_chgFuncp = NULL;
+	m_scopetopp = NULL;
+    }
+    ~ChangedState() {}
+};
+
+//######################################################################
+// Utility visitor to find elements to be compared
+
+class ChangedInsertVisitor : public AstNVisitor {
+private:
+    // STATE
+    ChangedState*	m_statep;	// Shared state across visitors
+    AstVarScope*	m_vscp;		// Original (non-change) variable we're change-detecting
+    AstVarScope*	m_newvscp;	// New (change detect) variable we're change-detecting
+    AstNode*		m_varEqnp;	// Original var's equation to get var value
+    AstNode*		m_newLvEqnp;	// New var's equation to read value 
+    AstNode*		m_newRvEqnp;	// New var's equation to set value 
+    uint32_t		m_detects;	// # detects created
+
+    // CONSTANTS
+    enum MiscConsts {
+	DETECTARRAY_MAX_INDEXES = 256	// How many indexes before error
+	// Ok to increase this, but may result in much slower model
+    };
+
+    void newChangeDet() {
+	if (++m_detects > DETECTARRAY_MAX_INDEXES) {
+	    m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect more than "<<cvtToStr(DETECTARRAY_MAX_INDEXES)
+			   <<" array indexes (probably with UNOPTFLAT warning suppressed): "<<m_vscp->prettyName()<<endl
+			   <<m_vscp->warnMore()
+			   <<"... Could recompile with DETECTARRAY_MAX_INDEXES increased"<<endl);
+	    return;
+	}
+	AstChangeDet* changep = new AstChangeDet (m_vscp->fileline(),
+						  m_varEqnp->cloneTree(true),
+						  m_newRvEqnp->cloneTree(true), false);
+	m_statep->m_chgFuncp->addStmtsp(changep);
+	AstAssign* initp = new AstAssign (m_vscp->fileline(),
+					  m_newLvEqnp->cloneTree(true),
+					  m_varEqnp->cloneTree(true));
+	m_statep->m_chgFuncp->addFinalsp(initp);
+    }
+
+    virtual void visit(AstBasicDType* nodep, AstNUser*) {
+	newChangeDet();
+    }
+    virtual void visit(AstPackArrayDType* nodep, AstNUser*) {
+	newChangeDet();
+    }
+    virtual void visit(AstUnpackArrayDType* nodep, AstNUser*) {
+	for (int index=0; index < nodep->elementsConst(); ++index) {
+	    AstNode* origVEp = m_varEqnp;
+	    AstNode* origNLEp = m_newLvEqnp;
+	    AstNode* origNREp = m_newRvEqnp;
+
+	    m_varEqnp   = new AstArraySel(nodep->fileline(), m_varEqnp->cloneTree(true), index);
+	    m_newLvEqnp = new AstArraySel(nodep->fileline(), m_newLvEqnp->cloneTree(true), index);
+	    m_newRvEqnp = new AstArraySel(nodep->fileline(), m_newRvEqnp->cloneTree(true), index);
+
+	    nodep->subDTypep()->skipRefp()->accept(*this);
+
+	    m_varEqnp->deleteTree();
+	    m_newLvEqnp->deleteTree();
+	    m_newRvEqnp->deleteTree();
+
+	    m_varEqnp   = origVEp;
+	    m_newLvEqnp = origNLEp;
+	    m_newRvEqnp = origNREp;
+	}
+    }
+    virtual void visit(AstNodeClassDType* nodep, AstNUser*) {
+	if (nodep->packedUnsup()) {
+	    newChangeDet();
+	} else {
+	    if (debug()) nodep->dumpTree(cout,"-DETECTARRAY-class-");
+	    m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<m_vscp->varp()->prettyName());
+	}
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	if (debug()) nodep->dumpTree(cout,"-DETECTARRAY-general-");
+	m_vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<m_vscp->varp()->prettyName());
+    }
+public:
+    // CONSTUCTORS
+    ChangedInsertVisitor(AstVarScope* vscp, ChangedState* statep) {
+	m_statep = statep;
+	m_vscp = vscp;
+	m_detects = 0;
+	{
+	    AstVar* varp = m_vscp->varp();
+	    string newvarname = "__Vchglast__"+m_vscp->scopep()->nameDotless()+"__"+varp->shortName();
+	    // Create:  VARREF(_last)
+	    //          ASSIGN(VARREF(_last), VARREF(var))
+	    //          ...
+	    //          CHANGEDET(VARREF(_last), VARREF(var))
+	    AstVar* newvarp = new AstVar (varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
+	    m_statep->m_topModp->addStmtp(newvarp);
+	    m_newvscp = new AstVarScope(m_vscp->fileline(), m_statep->m_scopetopp, newvarp);
+	    m_statep->m_scopetopp->addVarp(m_newvscp);
+
+	    m_varEqnp   = new AstVarRef(m_vscp->fileline(), m_vscp, false);
+	    m_newLvEqnp = new AstVarRef(m_vscp->fileline(), m_newvscp, true);
+	    m_newRvEqnp = new AstVarRef(m_vscp->fileline(), m_newvscp, false);
+	}
+	vscp->dtypep()->skipRefp()->accept(*this);
+	m_varEqnp->deleteTree();
+	m_newLvEqnp->deleteTree();
+	m_newRvEqnp->deleteTree();
+    }
+    virtual ~ChangedInsertVisitor() {}
+};
+
 //######################################################################
 // Changed state, as a visitor of each AstNode
 
@@ -54,15 +178,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // STATE
-    AstNodeModule*	m_topModp;	// Top module
-    AstScope*		m_scopetopp;	// Scope under TOPSCOPE
-    AstCFunc*		m_chgFuncp;	// Change function we're building
-
-    // CONSTANTS
-    enum MiscConsts {
-	DETECTARRAY_MAX_INDEXES = 256	// How many indexes before error
-	// Ok to increase this, but may result in much slower model
-    };
+    ChangedState*	m_statep;	// Shared state across visitors
 
     // METHODS
     static int debug() {
@@ -71,69 +187,16 @@ private:
 	return level;
     }
 
-    AstNode* aselIfNeeded(bool isArray, int index, AstNode* childp) {
-	if (isArray) {
-	    return new AstArraySel(childp->fileline(), childp,
-				   new AstConst(childp->fileline(), index));
-	} else {
-	    return childp;
-	}
-    }
-
     void genChangeDet(AstVarScope* vscp) {
-#ifdef NEW_ORDERING
-	vscp->v3fatalSrc("Not applicable\n");
-#endif
-	AstVar* varp = vscp->varp();
 	vscp->v3warn(IMPERFECTSCH,"Imperfect scheduling of variable: "<<vscp);
-	AstArrayDType* arrayp = varp->dtypeSkipRefp()->castArrayDType();
-	bool isArray = arrayp;
-	int msb = isArray ? arrayp->msb() : 0;
-	int lsb = isArray ? arrayp->lsb() : 0;
-	if (isArray && ((msb - lsb + 1) > DETECTARRAY_MAX_INDEXES)) {
-	    vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect more than "<<cvtToStr(DETECTARRAY_MAX_INDEXES)
-			 <<" array indexes (probably with UNOPTFLAT warning suppressed): "<<varp->prettyName()<<endl
-			 <<vscp->warnMore()
-			 <<"... Could recompile with DETECTARRAY_MAX_INDEXES increased to at least "<<cvtToStr(msb-lsb+1));
-	} else if (!isArray
-		   && !varp->dtypeSkipRefp()->castBasicDType()) {
-	    if (debug()) varp->dumpTree(cout,"-DETECTARRAY-");
-	    vscp->v3warn(E_DETECTARRAY, "Unsupported: Can't detect changes on complex variable (probably with UNOPTFLAT warning suppressed): "<<varp->prettyName());
-	} else {
-	    string newvarname = "__Vchglast__"+vscp->scopep()->nameDotless()+"__"+varp->shortName();
-	    // Create:  VARREF(_last)
-	    //          ASSIGN(VARREF(_last), VARREF(var))
-	    //          ...
-	    //          CHANGEDET(VARREF(_last), VARREF(var))
-	    AstVar* newvarp = new AstVar (varp->fileline(), AstVarType::MODULETEMP, newvarname, varp);
-	    m_topModp->addStmtp(newvarp);
-	    AstVarScope* newvscp = new AstVarScope(vscp->fileline(), m_scopetopp, newvarp);
-	    m_scopetopp->addVarp(newvscp);
-	    for (int index=lsb; index<=msb; ++index) {
-		AstChangeDet* changep
-		    = new AstChangeDet (vscp->fileline(),
-					aselIfNeeded(isArray, index,
-						     new AstVarRef(vscp->fileline(), vscp, false)),
-					aselIfNeeded(isArray, index,
-						     new AstVarRef(vscp->fileline(), newvscp, false)),
-					false);
-		m_chgFuncp->addStmtsp(changep);
-		AstAssign* initp
-		    = new AstAssign (vscp->fileline(),
-				     aselIfNeeded(isArray, index,
-						  new AstVarRef(vscp->fileline(), newvscp, true)),
-				     aselIfNeeded(isArray, index,
-						  new AstVarRef(vscp->fileline(), vscp, false)));
-		m_chgFuncp->addFinalsp(initp);
-	    }
-	}
+	ChangedInsertVisitor visitor (vscp, m_statep);
     }
 
     // VISITORS
     virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	if (nodep->isTop()) {
-	    m_topModp = nodep;
+	    m_statep->m_topModp = nodep;
 	}
 	nodep->iterateChildren(*this);
     }
@@ -144,15 +207,15 @@ private:
 	// Create the change detection function
 	AstScope* scopep = nodep->scopep();
 	if (!scopep) nodep->v3fatalSrc("No scope found on top level, perhaps you have no statements?\n");
-	m_scopetopp = scopep;
+	m_statep->m_scopetopp = scopep;
 	// Create change detection function
-	m_chgFuncp = new AstCFunc(nodep->fileline(), "_change_request", scopep, "IData");
-	m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
-	m_chgFuncp->symProlog(true);
-	m_chgFuncp->declPrivate(true);
-	m_scopetopp->addActivep(m_chgFuncp);
+	m_statep->m_chgFuncp = new AstCFunc(nodep->fileline(), "_change_request", scopep, "QData");
+	m_statep->m_chgFuncp->argTypes(EmitCBaseVisitor::symClassVar());
+	m_statep->m_chgFuncp->symProlog(true);
+	m_statep->m_chgFuncp->declPrivate(true);
+	m_statep->m_scopetopp->addActivep(m_statep->m_chgFuncp);
 	// We need at least one change detect so we know to emit the correct code
-	m_chgFuncp->addStmtsp(new AstChangeDet(nodep->fileline(), NULL, NULL, false));
+	m_statep->m_chgFuncp->addStmtsp(new AstChangeDet(nodep->fileline(), NULL, NULL, false));
 	//
 	nodep->iterateChildren(*this);
     }
@@ -164,6 +227,9 @@ private:
 	    }
 	}
     }
+    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+	// Short-circuit 
+    }
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep, AstNUser*) {
@@ -172,10 +238,8 @@ private:
 
 public:
     // CONSTUCTORS
-    ChangedVisitor(AstNetlist* nodep) {
-	m_topModp = NULL;
-	m_chgFuncp = NULL;
-	m_scopetopp = NULL;
+    ChangedVisitor(AstNetlist* nodep, ChangedState* statep) {
+	m_statep = statep;
 	nodep->accept(*this);
     }
     virtual ~ChangedVisitor() {}
@@ -186,5 +250,7 @@ public:
 
 void V3Changed::changedAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    ChangedVisitor visitor (nodep);
+    ChangedState state;
+    ChangedVisitor visitor (nodep, &state);
+    V3Global::dumpCheckGlobalTree("changed.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Changed.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Clean.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -238,6 +238,10 @@ private:
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->valuep());
     }
+    virtual void visit(AstTypedef* nodep, AstNUser*) {
+	// No cleaning, or would loose pointer to enum
+	nodep->iterateChildren(*this);
+    }
 
     // Control flow operators
     virtual void visit(AstNodeCond* nodep, AstNUser*) {
@@ -276,7 +280,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CleanVisitor(AstNetlist* nodep) {
+    explicit CleanVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CleanVisitor() {}
@@ -288,4 +292,5 @@ public:
 void V3Clean::cleanAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CleanVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clean.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Clean.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3ClkGater.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2008-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2008-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -66,7 +66,7 @@ class GaterVarVertex;
 class GaterVertex : public V3GraphVertex {
     static uint32_t s_rankNum;
 public:
-    GaterVertex(V3Graph* graphp)
+    explicit GaterVertex(V3Graph* graphp)
 	: V3GraphVertex(graphp) {
 	s_rankNum++; rank(s_rankNum);
     }
@@ -79,7 +79,7 @@ uint32_t GaterVertex::s_rankNum = 0;
 
 class GaterHeadVertex : public GaterVertex {
 public:
-    GaterHeadVertex(V3Graph* graphp)
+    explicit GaterHeadVertex(V3Graph* graphp)
 	: GaterVertex(graphp) {}
     virtual ~GaterHeadVertex() {}
     virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
@@ -89,7 +89,7 @@ public:
 
 class GaterPliVertex : public GaterVertex {
 public:
-    GaterPliVertex(V3Graph* graphp)
+    explicit GaterPliVertex(V3Graph* graphp)
 	: GaterVertex(graphp) {}
     virtual ~GaterPliVertex() {}
     virtual int typeNum() const { return __LINE__; }  // C++ typeof() equivelent
@@ -217,7 +217,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    GaterCondVisitor(AstNode* nodep) {
+    explicit GaterCondVisitor(AstNode* nodep) {
 	m_isSimple = true;
 	nodep->accept(*this);
     }
@@ -296,7 +296,7 @@ class GaterBodyVisitor : public GaterBaseVisitor {
 	}
 
 	if ((childstate & STATE_DELETE) && !(childstate & STATE_KEEP)) {
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    // Pass upwards we did delete
 	    m_state |= STATE_DELETE;
 	} else {
@@ -427,7 +427,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    for (V3GraphEdge* nextp,* edgep = m_pliVertexp->outBeginp(); edgep; edgep = nextp) {
 		nextp = edgep->outNextp();  // We may edit the list
 		if (GaterVarVertex* vVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
-		    vVxp->unlinkDelete(&m_graph); vVxp=NULL; edgep=NULL;
+		    vVxp->unlinkDelete(&m_graph); VL_DANGLING(vVxp); VL_DANGLING(edgep);
 		} else {
 		    m_graph.dump();
 		    v3fatalSrc("PLI vertex points to non-signal");
@@ -463,7 +463,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		V3GraphVertex* toVxp = edgep->top();
 		//UINFO(9," to "<<toVxp->user()<<" "<<toVxp<<endl);
 		if ((toVxp->user() & VU_IF) && (toVxp->user() & VU_ELSE)) {
-		    edgep->unlinkDelete(); edgep = NULL;
+		    edgep->unlinkDelete(); VL_DANGLING(edgep);
 		    if (!(toVxp->user() & VU_MADE)) {   // Make an edge only once
 			toVxp->user(toVxp->user() | VU_MADE);
 			GaterEdge* inedgep = static_cast<GaterEdge*>(vertexp->inBeginp());
@@ -487,7 +487,7 @@ class GaterVisitor : public GaterBaseVisitor {
 		if (toVxp->user() && toVxp->user() < depth) {
 		    // A recursion "above" us marked it,
 		    // Remove this edge, it's redundant with the upper edge
-		    edgep->unlinkDelete(); edgep=NULL;
+		    edgep->unlinkDelete(); VL_DANGLING(edgep);
 		} else {
 		    GaterEdge* cedgep = static_cast<GaterEdge*>(edgep);
 		    if (cedgep->ifelseBoth()) {
@@ -515,7 +515,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    if (GaterIfVertex* toVxp = dynamic_cast<GaterIfVertex*>(edgep->top())) {
 		if (!toVxp->outBeginp()) {
 		    if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
-			toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+			toVxp->unlinkDelete(&m_graph); VL_DANGLING(toVxp); VL_DANGLING(edgep);
 		    }
 		}
 	    }
@@ -529,7 +529,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	    nextp = edgep->outNextp();  // We may edit the list
 	    if (GaterVarVertex* toVxp = dynamic_cast<GaterVarVertex*>(edgep->top())) {
 		if (!nextp || nextp->top() != edgep->top()) {  // Else next would disappear; we'll do it next loop
-		    toVxp->unlinkDelete(&m_graph); toVxp=NULL; edgep=NULL;
+		    toVxp->unlinkDelete(&m_graph); VL_DANGLING(toVxp); VL_DANGLING(edgep);
 		}
 	    }
 	}
@@ -684,6 +684,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	AstNode* bodyp = nodep->bodysp()->cloneTree(true);
 
 	AstAlways* alwp = new AstAlways(nodep->fileline(),
+					nodep->keyword(),
 					sensesp,
 					bodyp);
 
@@ -877,7 +878,7 @@ class GaterVisitor : public GaterBaseVisitor {
 
 public:
     // CONSTUCTORS
-    GaterVisitor(AstNode* nodep) {
+    explicit GaterVisitor(AstNode* nodep) {
 	// AstAlways visitor does the real work, so most zeroing needs to be in clear()
 	clear();
 	nodep->accept(*this);
@@ -913,4 +914,5 @@ void V3ClkGater::clkGaterAll(AstNetlist* nodep) {
     // While the gater does well at some modules, it seems to slow down many others
     UINFO(5,"ClkGater is disabled due to performance issues\n");
     //GaterVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clkgater.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3ClkGater.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Clock.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -99,18 +99,6 @@ private:
 	UINFO(4,"New Last: "<<newvscp<<endl);
 	return newvscp;
     }
-    AstVarScope* getCreateLocalVar(FileLine* fl, const string& name, AstVar* examplep, int width) {
-	AstVar* newvarp;
-	if (width) {
-	    newvarp = new AstVar (fl, AstVarType::BLOCKTEMP, name, VFlagLogicPacked(), width);
-	} else {
-	    newvarp = new AstVar (fl, AstVarType::BLOCKTEMP, name, examplep); // No range; 1 bit.
-	}
-	m_modp->addStmtp(newvarp);
-	AstVarScope* newvscp = new AstVarScope(fl, m_scopep, newvarp);
-	m_scopep->addVarp(newvscp);
-	return newvscp;
-    }
     AstNode* createSenItemEquation(AstSenItem* nodep) {
 	// We know the var is clean, and one bit, so we use binary ops
 	// for speed instead of logical ops.
@@ -280,7 +268,7 @@ private:
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
     virtual void visit(AstAlwaysPost* nodep, AstNUser*) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
@@ -289,7 +277,7 @@ private:
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
     virtual void visit(AstCoverToggle* nodep, AstNUser*) {
 	//nodep->dumpTree(cout,"ct:");
@@ -309,7 +297,7 @@ private:
 	newp->addIfsp(new AstAssign(nodep->fileline(),
 				    changep->cloneTree(false),
 				    origp->cloneTree(false)));
-	nodep->replaceWith(newp); nodep->deleteTree(); nodep=NULL;
+	nodep->replaceWith(newp); nodep->deleteTree(); VL_DANGLING(nodep);
     }
     virtual void visit(AstInitial* nodep, AstNUser*) {
 	AstNode* cmtp = new AstComment(nodep->fileline(), nodep->typeName());
@@ -318,42 +306,16 @@ private:
 	    stmtsp->unlinkFrBackWithNext();
 	    cmtp->addNextHere(stmtsp);
 	}
-	nodep->deleteTree(); nodep = NULL;
-    }
-    void moveInitial(AstActive* nodep) {
-	// Change to CFunc
-	AstNode* stmtsp = nodep->stmtsp();
-	if (stmtsp) {
-	    if (!m_scopep) nodep->v3fatalSrc("Initial Active not under scope\n");
-	    AstCFunc* funcp = new AstCFunc(nodep->fileline(), "_initial__"+m_scopep->nameDotless(),
-					   m_scopep);
-	    funcp->argTypes(EmitCBaseVisitor::symClassVar());
-	    funcp->symProlog(true);
-	    funcp->slow(true);
-	    stmtsp->unlinkFrBackWithNext();
-	    funcp->addStmtsp(stmtsp);
-	    nodep->replaceWith(funcp);
-	    // Add top level call to it
-	    AstCCall* callp = new AstCCall(nodep->fileline(), funcp);
-	    callp->argTypes("vlSymsp");
-	    m_initFuncp->addStmtsp(callp);
-	} else {
-	    nodep->unlinkFrBack();
-	}
-	nodep->deleteTree(); nodep=NULL;
+	nodep->deleteTree(); VL_DANGLING(nodep);
     }
     virtual void visit(AstCFunc* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	// Link to global function
 	if (nodep->formCallTree()) {
-	    if (nodep->name() == "_final") {
-		UINFO(4, "    formCallTree "<<nodep<<endl);
-		AstCCall* callp = new AstCCall(nodep->fileline(), nodep);
-		callp->argTypes("vlSymsp");
-		m_finalFuncp->addStmtsp(callp);
-	    } else {
-		nodep->v3fatalSrc("Unknown CFunc name.  Make code more generic, with a map of func names");
-	    }
+	    UINFO(4, "    formCallTree "<<nodep<<endl);
+	    AstCCall* callp = new AstCCall(nodep->fileline(), nodep);
+	    callp->argTypes("vlSymsp");
+	    m_finalFuncp->addStmtsp(callp);
 	}
     }
     virtual void visit(AstSenTree* nodep, AstNUser*) {
@@ -369,22 +331,24 @@ private:
 	if (m_untilp) m_untilp->addBodysp(stmtsp);  // In a until loop, add to body
 	else m_settleFuncp->addStmtsp(stmtsp);  // else add to top level function
     }
+    void addToInitial(AstNode* stmtsp) {
+	if (m_untilp) m_untilp->addBodysp(stmtsp);  // In a until loop, add to body
+	else m_initFuncp->addStmtsp(stmtsp);  // else add to top level function
+    }
     virtual void visit(AstActive* nodep, AstNUser*) {
 	// Careful if adding variables here, ACTIVES can be under other ACTIVES
 	// Need to save and restore any member state in AstUntilStable block
-	if (nodep->hasInitial()) {
-	    moveInitial(nodep);
-	}
-	else if (!m_topScopep || !nodep->stmtsp()) {
+	if (!m_topScopep || !nodep->stmtsp()) {
 	    // Not at the top or empty block...
 	    // Only empty blocks should be leftover on the non-top.  Killem.
 	    if (nodep->stmtsp()) nodep->v3fatalSrc("Non-empty lower active");
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
 	    UINFO(4,"  ACTIVE  "<<nodep<<endl);
 	    AstNode* stmtsp = nodep->stmtsp()->unlinkFrBackWithNext();
 	    if (nodep->hasClocked()) {
 		// Remember the latest sensitivity so we can compare it next time
+		if (nodep->hasInitial()) nodep->v3fatalSrc("Initial block should not have clock sensitivity");
 		if (m_lastSenp && nodep->sensesp()->sameTree(m_lastSenp)) {
 		    UINFO(4,"    sameSenseTree\n");
 		} else {
@@ -396,6 +360,10 @@ private:
 		}
 		// Move statements to if
 		m_lastIfp->addIfsp(stmtsp);
+	    } else if (nodep->hasInitial()) {
+		// Don't need to: clearLastSen();, as we're adding it to different cfunc
+		// Move statements to function
+		addToInitial(stmtsp);
 	    } else if (nodep->hasSettle()) {
 		// Don't need to: clearLastSen();, as we're adding it to different cfunc
 		// Move statements to function
@@ -406,119 +374,10 @@ private:
 		// Move statements to function
 		addToEvalLoop(stmtsp);
 	    }
-	    nodep->unlinkFrBack()->deleteTree(); nodep = NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	}
     }
 
-#ifdef NEW_ORDERING
-    virtual void visit(AstUntilStable* nodep, AstNUser*) {
-	// Process any sub ACTIVE statements first
-	UINFO(4,"  UNTILSTABLE  "<<nodep<<endl);
-	{
-	    // Keep vars if in middle of other stable
-	    AstUntilStable* 	lastUntilp = m_untilp;
-	    AstSenTree*		lastSenp = m_lastSenp;
-	    AstIf*		lastIfp = m_lastIfp;
-	    m_untilp = nodep;
-	    m_lastSenp = NULL;
-	    m_lastIfp = NULL;
-	    nodep->iterateChildren(*this);
-	    m_untilp = lastUntilp;
-	    m_lastSenp = lastSenp;
-	    m_lastIfp = lastIfp;
-	}
-	// Set "unstable" to 100. (non-stabilization count)
-	//  int __VclockLoop = 0
-	//  IData __Vchange = 1
-	//  while (__Vchange) {
-	//     Save old values of each until stable variable
-	//     Evaluate the body
-	//     __Vchange = {change_detect} contribution
-	//     if (++__VclockLoop > 100) converge_error
-	if (debug()>4) nodep->dumpTree(cout, " UntilSt-old: ");
-	FileLine* fl = nodep->fileline();
-	if (nodep->bodysp()) fl = nodep->bodysp()->fileline(); // Point to applicable code...
-	m_stableNum++;
-	AstNode* origBodysp = nodep->bodysp(); if (origBodysp) origBodysp->unlinkFrBackWithNext();
-	AstVarScope* changeVarp = getCreateLocalVar(fl, "__Vchange"+cvtToStr(m_stableNum), NULL, 32);
-	AstVarScope* countVarp = getCreateLocalVar(fl, "__VloopCount"+cvtToStr(m_stableNum), NULL, 32);
-	AstWhile* untilp = new AstWhile(fl, new AstVarRef(fl, changeVarp, false), NULL);
-	AstNode* preUntilp = new AstComment(fl, "Change loop "+cvtToStr(m_stableNum));
-	preUntilp->addNext(new AstAssign(fl, new AstVarRef(fl, changeVarp, true),
-					 new AstConst(fl, 1)));
-        preUntilp->addNext(new AstAssign(fl, new AstVarRef(fl, countVarp, true),
-					 new AstConst(fl, 0)));
-
-	// Add stable variables & preinits
-	AstNode* setChglastp = NULL;
-	for (AstVarRef* varrefp = nodep->stablesp(); varrefp; varrefp=varrefp->nextp()->castVarRef()) {
-	    AstVarScope* cmpvscp = getCreateLocalVar(varrefp->varp()->fileline(),
-						     "__Vchglast"+cvtToStr(m_stableNum)+"__"+varrefp->name(),
-						     varrefp->varp(), 0);
-	    varrefp->varScopep()->user2p(cmpvscp);
-	    setChglastp = setChglastp->addNext(
-		new AstAssign(fl, new AstVarRef(fl, cmpvscp, true),
-			      new AstVarRef(fl, varrefp->varScopep(), false)));
-	}
-	if (!setChglastp) nodep->v3fatalSrc("UntilStable without any variables");
-	untilp->addBodysp(setChglastp);
-	untilp->addBodysp(new AstComment(fl, "Change Loop body begin"));
-	if (origBodysp) untilp->addBodysp(origBodysp);
-	untilp->addBodysp(new AstComment(fl, "Change Loop body end"));
-	// Add stable checks
-	// The order of the variables doesn't matter, but it's more expensive to test
-	// wide variables, and more so 64 bit wide ones.  Someday it might be faster to
-	// set the changed variable in a "distributed" fashion over the code, IE,
-	// logic... logic.... a=....;  Changed |= (a ^ old_a); more logic...  Changed |=...
-	// But then, one hopes users don't have much unoptimized logic
-	AstNode* changeExprp = NULL;
-	int doublecount = 0;
-	for (int wide=0; wide<3; wide++) {  // Adding backwards; wide, quad, then normal
-	    for (AstVarRef* varrefp = nodep->stablesp(); varrefp; varrefp=varrefp->nextp()->castVarRef()) {
-		if (wide== ( varrefp->isQuad()?0:(varrefp->isWide() ? 1:2))) {
-		    AstVarScope* cmpvscp = (AstVarScope*)(varrefp->varScopep()->user2p());
-		    if (!cmpvscp) varrefp->v3fatalSrc("should have created above");
-		    AstChangeXor* changep
-			= new AstChangeXor (fl,
-					    new AstVarRef(fl, varrefp->varScopep(), false),
-					    new AstVarRef(fl, cmpvscp, false));
-		    if (!changeExprp) changeExprp = changep;
-		    else if (doublecount++ > DOUBLE_OR_RATE) {
-			doublecount = 0;
-			changeExprp = new AstLogOr (fl, changep, changeExprp);
-		    } else {
-			changeExprp = new AstOr (fl, changep, changeExprp);
-		    }
-		}
-	    }
-	}
-	if (!changeExprp) nodep->v3fatalSrc("UntilStable without any variables");
-	changeExprp = new AstAssign(fl, new AstVarRef(fl, changeVarp, true),
-				    changeExprp);
-	untilp->addBodysp(changeExprp);
-	//
-	// Final body
-	AstNode* ifstmtp = new AstAssign(fl, new AstVarRef(fl, countVarp, true),
-					 new AstAdd(fl, new AstConst(fl, 1),
-						    new AstVarRef(fl, countVarp, false)));
-	ifstmtp->addNext(new AstIf(fl,
-				   new AstLt (fl, new AstConst(fl, 100),
-					      new AstVarRef(fl, countVarp, false)),
-				   (new AstDisplay (fl, AstDisplayType::DT_DISPLAY,
-						    "%%Error: Verilated model didn't converge", NULL, NULL))
-				   ->addNext(new AstStop (fl)),
-				   NULL));
-	untilp->addBodysp(new AstIf(fl, new AstNeq(fl, new AstConst(fl, 0),
-						   new AstVarRef(fl, changeVarp, false)),
-				    ifstmtp, NULL));
-	//
-	// Replace it
-	preUntilp->addNext(untilp);
-	if (debug()>4) preUntilp->dumpTreeAndNext(cout, " UntilSt-new: ");
-	nodep->replaceWith(preUntilp); nodep->deleteTree(); nodep=NULL;
-    }
-#endif
-
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep, AstNUser*) {
@@ -527,7 +386,7 @@ private:
 
 public:
     // CONSTUCTORS
-    ClockVisitor(AstNetlist* nodep) {
+    explicit ClockVisitor(AstNetlist* nodep) {
 	m_modp=NULL; m_activep=NULL;
 	m_evalFuncp = NULL;
 	m_topScopep=NULL;
@@ -548,4 +407,5 @@ public:
 void V3Clock::clockAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     ClockVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("clock.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Clock.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Combine.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -111,7 +111,7 @@ public:
 		    callp->unlinkFrBack();
 		}
 		callp->user3(true);	// Dead now
-		pushDeletep(callp); callp=NULL;
+		pushDeletep(callp); VL_DANGLING(callp);
 		m_callMmap.erase(eqit);	// Fix the table
 	    }
 	}
@@ -169,7 +169,7 @@ private:
     }
 public:
     // CONSTRUCTORS
-    CombMarkVisitor(AstNode* nodep) {
+    explicit CombMarkVisitor(AstNode* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CombMarkVisitor() {}
@@ -230,7 +230,7 @@ private:
 		CombMarkVisitor visitor(oldfuncp);
 		m_call.replaceFunc(oldfuncp, NULL);
 		oldfuncp->unlinkFrBack();
-		pushDeletep(oldfuncp); oldfuncp=NULL;
+		pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
 	    }
 	}
     }
@@ -262,7 +262,7 @@ private:
 	CombMarkVisitor visitor(oldfuncp);
 	m_call.replaceFunc(oldfuncp, newfuncp);
 	oldfuncp->unlinkFrBack();
-	pushDeletep(oldfuncp); oldfuncp=NULL;
+	pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
     }
     void replaceOnlyCallFunc(AstCCall* nodep) {
 	if (AstCFunc* oldfuncp = nodep->backp()->castCFunc()) {
@@ -274,7 +274,7 @@ private:
 		UINFO(9,"     Function only has call "<<oldfuncp<<endl);
 		m_call.deleteCall(nodep);
 		CombMarkVisitor visitor(oldfuncp);
-		replaceFuncWFunc(oldfuncp, nodep->funcp());  nodep=NULL;
+		replaceFuncWFunc(oldfuncp, nodep->funcp()); VL_DANGLING(nodep);
 	    }
 	}
     }
@@ -384,8 +384,8 @@ private:
 	m_call.addCall(call2p);
 	// If either new statement makes a func with only a single call, replace
 	// the above callers to call it directly
-	replaceOnlyCallFunc(call1p); call1p=NULL;
-	replaceOnlyCallFunc(call2p); call2p=NULL;
+	replaceOnlyCallFunc(call1p); VL_DANGLING(call1p);
+	replaceOnlyCallFunc(call2p); VL_DANGLING(call2p);
     }
 
     // VISITORS
@@ -457,7 +457,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CombineVisitor(AstNetlist* nodep) {
+    explicit CombineVisitor(AstNetlist* nodep) {
 	m_modp=NULL;
 	m_funcp = NULL;
 	m_state = STATE_IDLE;
@@ -474,4 +474,5 @@ public:
 void V3Combine::combineAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CombineVisitor visitor (nodep);
+    V3Global::dumpCheckGlobalTree("combine.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Combine.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Config.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2010-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2010-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -144,12 +144,12 @@ V3ConfigIgnores V3ConfigIgnores::s_singleton;
 //######################################################################
 // V3Config
 
-void V3Config::addIgnore(V3ErrorCode code, string filename, int min, int max) {
+void V3Config::addIgnore(V3ErrorCode code, bool on, string filename, int min, int max) {
     if (filename=="*") {
-	FileLine::globalWarnOff(code,true);
+	FileLine::globalWarnOff(code,!on);
     } else {
-	V3ConfigIgnores::singleton().addIgnore(code, filename, min, false);
-	if (max) V3ConfigIgnores::singleton().addIgnore(code, filename, max, true);
+	V3ConfigIgnores::singleton().addIgnore(code, filename, min, on);
+	if (max) V3ConfigIgnores::singleton().addIgnore(code, filename, max, !on);
     }
 }
 

src/V3Config.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2010-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2010-2015 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.
@@ -24,12 +24,13 @@
 #include "verilatedos.h"
 #include <string>
 #include "V3Error.h"
+#include "V3FileLine.h"
 
 //######################################################################
 
 class V3Config {
 public:
-    static void addIgnore(V3ErrorCode code, string filename, int min, int max);
+    static void addIgnore(V3ErrorCode code, bool on, string filename, int min, int max);
     static void applyIgnores(FileLine* filelinep);
 };
 

src/V3Const.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Coverage.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 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.
@@ -60,10 +60,16 @@ private:
 	}
     };
 
+    // NODE STATE
+    // Entire netlist:
+    //  AstIf::user1()			-> bool.  True indicates ifelse processed
+    AstUser1InUse	m_inuser1;
+
     // STATE
-    bool	m_checkBlock;	// Should this block get covered?
-    AstNodeModule*	m_modp;	// Current module to add statement to
+    bool		m_checkBlock;	// Should this block get covered?
+    AstNodeModule*	m_modp;		// Current module to add statement to
     bool	m_inToggleOff;	// In function/task etc
+    bool	m_inModOff;	// In module with no coverage
     FileMap	m_fileps;	// Column counts for each fileline
     string	m_beginHier;	// AstBegin hier name for user coverage points
 
@@ -81,12 +87,12 @@ private:
 	if (!nodep->isToggleCoverable())
 	    return "Not relevant signal type";
 	if (!v3Global.opt.coverageUnderscore()) {
-	    if (prettyName.c_str()[0] == '_')
+	    if (prettyName[0] == '_')
 	        return "Leading underscore";
 	    if (prettyName.find("._") != string::npos)
 	        return "Inlined leading underscore";
 	}
-	if ((nodep->width()*nodep->dtypep()->arrayElements()) > 256) return "Wide bus/array > 256 bits";
+	if ((nodep->width()*nodep->dtypep()->arrayUnpackedElements()) > 256) return "Wide bus/array > 256 bits";
 	// We allow this, though tracing doesn't
 	// if (nodep->arrayp(1)) return "Unsupported: Multi-dimensional array";
 	return NULL;
@@ -124,9 +130,11 @@ private:
     // VISITORS - BOTH
     virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	m_modp = nodep;
+	m_inModOff = nodep->isTop();   // Ignore coverage on top module; it's a shell we created
 	m_fileps.clear();
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
+	m_inModOff = true;
     }
 
     // VISITORS - TOGGLE COVERAGE
@@ -140,7 +148,7 @@ private:
     }
     virtual void visit(AstVar* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	if (m_modp && !m_inToggleOff
+	if (m_modp && !m_inModOff && !m_inToggleOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageToggle()) {
 	    const char* disablep = varIgnoreToggle(nodep);
 	    if (disablep) {
@@ -209,8 +217,8 @@ private:
 				varp, chgVarp);
 	    }
 	}
-	else if (AstArrayDType* adtypep = dtypep->castArrayDType()) {
-	    for (int index_docs=adtypep->lsb(); index_docs<=adtypep->msb()+1; ++index_docs) {
+	else if (AstUnpackArrayDType* adtypep = dtypep->castUnpackArrayDType()) {
+	    for (int index_docs=adtypep->lsb(); index_docs<=adtypep->msb(); ++index_docs) {
 		int index_code = index_docs - adtypep->lsb();
 		ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
 				  new AstArraySel(varp->fileline(), above.m_varRefp->cloneTree(true), index_code),
@@ -221,6 +229,50 @@ private:
 		newent.cleanup();
 	    }
 	}
+	else if (AstPackArrayDType* adtypep = dtypep->castPackArrayDType()) {
+	    for (int index_docs=adtypep->lsb(); index_docs<=adtypep->msb(); ++index_docs) {
+		AstNodeDType* subtypep = adtypep->subDTypep()->skipRefp();
+		int index_code = index_docs - adtypep->lsb();
+		ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
+				  new AstSel(varp->fileline(), above.m_varRefp->cloneTree(true),
+					     index_code*subtypep->width(), subtypep->width()),
+				  new AstSel(varp->fileline(), above.m_chgRefp->cloneTree(true),
+					     index_code*subtypep->width(), subtypep->width()));
+		toggleVarRecurse(adtypep->subDTypep()->skipRefp(), depth+1,
+				 newent,
+				 varp, chgVarp);
+		newent.cleanup();
+	    }
+	}
+	else if (AstStructDType* adtypep = dtypep->castStructDType()) {
+	    // For now it's packed, so similar to array
+	    for (AstMemberDType* itemp = adtypep->membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
+		AstNodeDType* subtypep = itemp->subDTypep()->skipRefp();
+		int index_code = itemp->lsb();
+		ToggleEnt newent (above.m_comment+string(".")+itemp->name(),
+				  new AstSel(varp->fileline(), above.m_varRefp->cloneTree(true),
+					     index_code, subtypep->width()),
+				  new AstSel(varp->fileline(), above.m_chgRefp->cloneTree(true),
+					     index_code, subtypep->width()));
+		toggleVarRecurse(subtypep, depth+1,
+				 newent,
+				 varp, chgVarp);
+		newent.cleanup();
+	    }
+	}
+	else if (AstUnionDType* adtypep = dtypep->castUnionDType()) {
+	    // Arbitrarially handle only the first member of the union
+	    if (AstMemberDType* itemp = adtypep->membersp()) {
+		AstNodeDType* subtypep = itemp->subDTypep()->skipRefp();
+		ToggleEnt newent (above.m_comment+string(".")+itemp->name(),
+				  above.m_varRefp->cloneTree(true),
+				  above.m_chgRefp->cloneTree(true));
+		toggleVarRecurse(subtypep, depth+1,
+				 newent,
+				 varp, chgVarp);
+		newent.cleanup();
+	    }
+	}
 	else {
 	    dtypep->v3fatalSrc("Unexpected node data type in toggle coverage generation: "<<dtypep->prettyTypeName());
 	}
@@ -230,12 +282,18 @@ private:
     virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
 	UINFO(4," IF: "<<nodep<<endl);
 	if (m_checkBlock) {
+	    // An else-if.  When we iterate the if, use "elsif" marking
+	    bool elsif = (nodep->elsesp()->castIf()
+			  && !nodep->elsesp()->castIf()->nextp());
+	    if (elsif) nodep->elsesp()->castIf()->user1(true);
+	    //
 	    nodep->ifsp()->iterateAndNext(*this);
-	    if (m_checkBlock
+	    if (m_checkBlock && !m_inModOff
 		&& nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "if" branch didn't disable it
-		if (!nodep->backp()->castIf()
-		    || nodep->backp()->castIf()->elsesp()!=nodep) {  // Ignore if else; did earlier
-		    UINFO(4,"   COVER: "<<nodep<<endl);
+		UINFO(4,"   COVER: "<<nodep<<endl);
+		if (nodep->user1()) {
+		    nodep->addIfsp(newCoverInc(nodep->fileline(), "", "v_line", "elsif"));
+		} else {
 		    nodep->addIfsp(newCoverInc(nodep->fileline(), "", "v_line", "if"));
 		}
 	    }
@@ -243,12 +301,10 @@ private:
 	    if (nodep->elsesp()) {
 		m_checkBlock = true;
 		nodep->elsesp()->iterateAndNext(*this);
-		if (m_checkBlock
+		if (m_checkBlock && !m_inModOff
 		    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {	// if a "else" branch didn't disable it
 		    UINFO(4,"   COVER: "<<nodep<<endl);
-		    if (nodep->elsesp()->castIf()) {
-			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "", "v_line", "elsif"));
-		    } else {
+		    if (!elsif) {  // elsif done inside if()
 			nodep->addElsesp(newCoverInc(nodep->elsesp()->fileline(), "", "v_line", "else"));
 		    }
 		}
@@ -258,7 +314,7 @@ private:
     }
     virtual void visit(AstCaseItem* nodep, AstNUser*) {
 	UINFO(4," CASEI: "<<nodep<<endl);
-	if (m_checkBlock
+	if (m_checkBlock && !m_inModOff
 	    && nodep->fileline()->coverageOn() && v3Global.opt.coverageLine()) {
 	    nodep->bodysp()->iterateAndNext(*this);
 	    if (m_checkBlock) {	// if the case body didn't disable it
@@ -287,7 +343,7 @@ private:
 	    // Skip all NEXT nodes under this block, and skip this if/case branch
 	    UINFO(4,"  OFF: "<<nodep<<endl);
 	    m_checkBlock = false;
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else {
 	    if (m_checkBlock) nodep->iterateChildren(*this);
 	}
@@ -322,11 +378,12 @@ private:
 
 public:
     // CONSTUCTORS
-    CoverageVisitor(AstNetlist* rootp) {
+    explicit CoverageVisitor(AstNetlist* rootp) {
 	// Operate on all modules
 	m_checkBlock = true;
 	m_beginHier = "";
 	m_inToggleOff = false;
+	m_inModOff = true;
 	rootp->iterateChildren(*this);
     }
     virtual ~CoverageVisitor() {}
@@ -338,4 +395,5 @@ public:
 void V3Coverage::coverage(AstNetlist* rootp) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CoverageVisitor visitor (rootp);
+    V3Global::dumpCheckGlobalTree("coverage.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Coverage.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3CoverageJoin.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -93,7 +93,7 @@ private:
 		    UINFO(8,"   new "<<removep->incp()->declp()<<endl);
 		    // Mark the found node as a duplicate of the first node
 		    // (Not vice-versa as we have the iterator for the found node)
-		    removep->unlinkFrBack();  pushDeletep(removep); removep=NULL;
+		    removep->unlinkFrBack();  pushDeletep(removep); VL_DANGLING(removep);
 		    // Remove node from comparison so don't hit it again
 		    hashed.erase(dupit);
 		    ++m_statToggleJoins;
@@ -121,7 +121,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CoverageJoinVisitor(AstNetlist* nodep) {
+    explicit CoverageJoinVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CoverageJoinVisitor() {
@@ -135,4 +135,5 @@ public:
 void V3CoverageJoin::coverageJoin(AstNetlist* rootp) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     CoverageJoinVisitor visitor (rootp);
+    V3Global::dumpCheckGlobalTree("coveragejoin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3CoverageJoin.h

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.

src/V3Dead.cpp

@@ -6,7 +6,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2013 by Wilson Snyder.  This program is free software; you can
+// Copyright 2003-2015 by Wilson Snyder.  This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -58,7 +58,7 @@ private:
     }
 public:
     // CONSTRUCTORS
-    DeadModVisitor(AstNodeModule* nodep) {
+    explicit DeadModVisitor(AstNodeModule* nodep) {
 	nodep->accept(*this);
     }
     virtual ~DeadModVisitor() {}
@@ -81,6 +81,7 @@ private:
     typedef multimap<AstVarScope*,AstNodeAssign*>	AssignMap;
 
     // STATE
+    AstNodeModule*		m_modp;		// Current module
     vector<AstNode*>		m_varEtcsp;	// List of all encountered to avoid another loop through tree
     vector<AstVarScope*>	m_vscsp;	// List of all encountered to avoid another loop through tree
     AssignMap			m_assignMap;	// List of all simple assignments for each variable
@@ -103,13 +104,21 @@ private:
     }
     void checkDType(AstNodeDType* nodep) {
 	if (!nodep->generic()  // Don't remove generic types
-	    && m_elimDTypes) {  // dtypes stick around until post-widthing
+	    && m_elimDTypes  // dtypes stick around until post-widthing
+	    && !nodep->castMemberDType() // Keep member names iff upper type exists
+	    ) {
 	    m_varEtcsp.push_back(nodep);
 	}
 	if (AstNode* subnodep = nodep->virtRefDTypep()) subnodep->user1Inc();
     }
 
     // VISITORS
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+	m_modp = nodep;
+	nodep->iterateChildren(*this);
+	checkAll(nodep);
+	m_modp = NULL;
+    }
     virtual void visit(AstCell* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
@@ -156,6 +165,13 @@ private:
 	    nodep->packagep()->user1Inc();
 	}
     }
+    virtual void visit(AstTypedef* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	checkAll(nodep);
+	// Don't let packages with only public variables disappear
+	// Normal modules may disappear, e.g. if they are parameterized then removed
+	if (nodep->attrPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
+    }
     virtual void visit(AstVarScope* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
@@ -166,6 +182,7 @@ private:
     virtual void visit(AstVar* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	checkAll(nodep);
+	if (nodep->isSigPublic() && m_modp && m_modp->castPackage()) m_modp->user1Inc();
 	if (mightElim(nodep)) {
 	    m_varEtcsp.push_back(nodep);
 	}
@@ -206,13 +223,13 @@ private:
 	    AstNodeModule* nextmodp;
 	    for (AstNodeModule* modp = v3Global.rootp()->modulesp(); modp; modp=nextmodp) {
 		nextmodp = modp->nextp()->castNodeModule();
-		if (modp->level()>2	&& modp->user1()==0) {
+		if (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);
-		    modp->unlinkFrBack()->deleteTree(); modp=NULL;
+		    modp->unlinkFrBack()->deleteTree(); VL_DANGLING(modp);
 		    retry = true;
 		}
 	    }
@@ -221,7 +238,9 @@ private:
     bool mightElim(AstVar* nodep) {
 	return (!nodep->isSigPublic()	// Can't elim publics!
 		&& !nodep->isIO()
-		&& (nodep->isTemp() || nodep->isParam() || m_elimUserVars));
+		&& (nodep->isTemp()
+		    || (nodep->isParam() && !nodep->isTrace())
+		    || m_elimUserVars));  // Post-Trace can kill most anything
     }
     void deadCheckVar() {
 	// Delete any unused varscopes
@@ -233,9 +252,9 @@ private:
 		for (AssignMap::iterator it = eqrange.first; it != eqrange.second; ++it) {
 		    AstNodeAssign* assp = it->second;
 		    UINFO(4,"    Dead assign "<<assp<<endl);
-		    assp->unlinkFrBack()->deleteTree(); assp=NULL;
+		    assp->unlinkFrBack()->deleteTree(); VL_DANGLING(assp);
 		}
-		vscp->unlinkFrBack()->deleteTree(); vscp=NULL;
+		vscp->unlinkFrBack()->deleteTree(); VL_DANGLING(vscp);
 	    }
 	}
 	for (vector<AstNode*>::iterator it = m_varEtcsp.begin(); it!=m_varEtcsp.end(); ++it) {
@@ -249,6 +268,7 @@ private:
 public:
     // CONSTRUCTORS
     DeadVisitor(AstNetlist* nodep, bool elimUserVars, bool elimDTypes) {
+	m_modp = NULL;
 	m_elimUserVars = elimUserVars;
 	m_elimDTypes = elimDTypes;
 	m_sideEffect = false;
@@ -271,12 +291,15 @@ public:
 void V3Dead::deadifyModules(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     DeadVisitor visitor (nodep, false, false);
+    V3Global::dumpCheckGlobalTree("deadModules.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 6);
 }
 void V3Dead::deadifyDTypes(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     DeadVisitor visitor (nodep, false, true);
+    V3Global::dumpCheckGlobalTree("deadDType.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }
 void V3Dead::deadifyAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
     DeadVisitor visitor (nodep, true, true);
+    V3Global::dumpCheckGlobalTree("deadAll.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Dead.h

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