Version bump

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

.gitignore

@@ -6,16 +6,22 @@
 *.info
 *.log
 *.1
+.*.swp
 *.tmp
 *.tex
+*.pdf
 /Makefile
 README
+TAGS
+autom4te.cache
 config.cache
 config.status
 configure
 dddrun*
+doxygen-doc
 gdbrun*
+internals.txt
 verilator.txt
-verilator.pdf
 verilator_bin*
-autom4te.cache
+verilator_coverage_bin*
+verilator.pc

MANIFEST.SKIP

@@ -4,25 +4,40 @@
 \.svn/
 \.(bak|old)/
 \.(bak|old)$
-\bMakefile$
 \.tar\.
 .*\.tgz
 .*\.log
+\..*\.swp
 .*\.tmp
 .*\.tex
 .*\.key
 .*\.vcd
+.*\.1
 /obj_dir/
 /obj_dbg/
 /obj_opt/
 /INCA_libs/
 /cov_work/
 /logs/
-Makefile
-src/Makefile_obj
-include/verilated.mk
-config.cache
-config.status
+^Makefile$
+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/
+/simv$
+/simv.daidir/
+/vc_hdrs.h$
+/csrc/
+doxygen-doc/.*
+TAGS
+.*~

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-2009 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.
@@ -54,11 +52,13 @@ srcdir = @srcdir@
 VPATH = @srcdir@
 HOST = @HOST@
 
+DOXYGEN = doxygen
 INSTALL = @INSTALL@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_DATA = @INSTALL_DATA@
 MAKEINFO = makeinfo
-TEXI2DVI = texi2dvi
+POD2TEXT = pod2text
+POD2LATEXFIX = $(srcdir)/src/pod2latexfix
 PERL = @PERL@
 
 # Destination prefix for RPMs
@@ -84,102 +84,117 @@ 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@
 
 # Compile options
+CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
+CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
+PACKAGE_VERSION = @PACKAGE_VERSION@
 
 #### End of system configuration section. ####
 ######################################################################
 
 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 verilator.txt verilator.html verilator.1 verilator.pdf
+INFOS = README README.html README.pdf internals.txt internals.html \
+        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
-# Files to distribute.
-DISTBIN = $(wildcard bin/verilator-*)
 
 DISTFILES_INC = $(INFOS) .gitignore Artistic COPYING COPYING.LESSER \
 	*.in *.ac \
-	Changes README TODO \
+	Changes TODO \
 	MANIFEST.SKIP \
 	bin/* \
-	install-sh configure mkinstalldirs *.texi \
-	include/verilated*.[chv]* \
+	doxygen-mainpage doxygen.config veripool-logo.png \
+	install-sh configure mkinstalldirs *.pod \
+	include/*.[chv]* \
 	include/*.in \
 	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_*/vlint \
+	test_*/*.pl test_*/*.v test_*/*.vc test_*/*.vh \
 	test_verilated/vgen*.pl \
+	test_regress/t/t*/*.sv* \
+	test_regress/t/t*/*.v* \
 	test_regress/t/*.cpp \
 	test_regress/t/*.h \
 	test_regress/t/*.dat \
 	test_regress/t/*.mem \
 	test_regress/t/*.out \
 	test_regress/t/*.pl \
+	test_regress/t/*.pf \
 	test_regress/t/*.v* \
-	verilator.* \
 
 INST_PROJ_FILES = \
 	bin/verilator \
+	bin/verilator_coverage \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
-	include/verilated.[chv]* \
 	include/verilated.mk \
-	include/verilatedos.[chv]* \
-	include/verilatedsc.[chv]* \
+	include/*.[chv]* \
+	include/vltstd/*.[chv]* \
 
 INST_PROJ_BIN_FILES = \
 	verilator_bin \
 	verilator_bin_dbg \
+	verilator_coverage_bin_dbg \
 
 DISTFILES := $(DISTFILES_INC)
 
-VL_INST_MAN_FILES = verilator.1
-
-ifeq ($(OBJCACHE_HOSTS),)
-export OBJCACHE_JOBS :=
-else
+ifeq ($(OBJCACHE_JOBS),)
+ifneq ($(OBJCACHE_HOSTS),)
 export OBJCACHE_JOBS := -j $(shell objcache --jobs "$(OBJCACHE_HOSTS)")
 endif
+endif
 
+default: all
 all: all_nomsg msg_test
 all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 
 .PHONY:verilator_exe
-verilator_exe verilator_bin verilator_bin_dbg:
+.PHONY:verilator_bin
+.PHONY: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) )
 
 .PHONY:msg_test
-msg_test:
+msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
 	@echo "Type 'make test' to test."
 	@echo
 
 .PHONY:test
-ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
-test: test_vcs test_c test_sc test_sp test_verilated test_regress
+ifeq ($(CFG_WITH_LONGTESTS),yes)	# Local... Else don't burden users
+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
@@ -188,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
@@ -200,82 +211,155 @@ test_regress: all_nomsg
 info: $(INFOS)
 
 # Use --no-split to avoid creating filenames > 14 chars.
-verilator.1: bin/verilator
+%.1: ${srcdir}/bin/%
 	pod2man $< $@
 
-verilator.txt: bin/verilator
-	pod2text $< $@
+verilator.txt: ${srcdir}/bin/verilator
+	$(POD2TEXT) $< $@
 
-verilator.html: bin/verilator
+verilator.html: ${srcdir}/bin/verilator
 	pod2html $< >$@
 
-verilator.pdf: bin/verilator $(DISTCONFIG)
-	pod2latex --full --out verilator.tex bin/verilator
-	cat < verilator.tex \
-	   | sed 's/\\begin{document}/\\usepackage[left=1.7in,right=1.7in,top=1.3in,bottom=1.3in]{geometry}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\usepackage[pdftex,bookmarks=true,bookmarksnumbered=true,hypertexnames=false,breaklinks=true,linkbordercolor={0 0 1}]{hyperref}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\usepackage{fancyhdr} \\pagestyle{fancy}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\setlength{\\parindent}{0pt} \\setlength{\\parskip}{\\baselineskip}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\title{$(DISTTITLE)} \\date{${DISTDATE}} \\author{Wilson Snyder\\\\ http:\/\/www.veripool.org}\n\\begin{document}/' \
-	   | sed 's/\\begin{document}/\\lhead[$(DISTTITLE)]{$(DISTTITLE)}\n\\begin{document}/' \
-	   | sed 's/\\tableofcontents/\\begin{titlepage} \\maketitle \\end{titlepage}\n\\tableofcontents/' \
-	   > verilator2.tex
+# PDF needs DIST variables; but having configure.ac as dependency isn't detected
+verilator.pdf: ${srcdir}/bin/verilator Makefile
+	pod2latex --full --out verilator.tex ${srcdir}/bin/verilator
+	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE)" "${DISTDATE}" < verilator.tex > verilator2.tex
 	mv verilator2.tex verilator.tex
 	pdflatex verilator.tex
 	pdflatex verilator.tex
 	-rm -f verilator.toc verilator.aux verilator.idx verilator.out
 
-INSTALL: install.texi
-	$(MAKEINFO) -I$(srcdir) $(srcdir)/install.texi --output=$@ \
-	--no-headers --no-validate
+README: README.pod
+	-rm -f $@
+	$(POD2TEXT) --loose $< > $@
 
-README: readme.texi
-	$(MAKEINFO) -I$(srcdir) $(srcdir)/readme.texi --output=$@ \
-	--no-headers --no-validate
+README.html: README.pod
+	pod2html $< >$@
 
-# See uninstall also
-VL_INST_BIN_FILES = verilator verilator_bin verilator_bin_dbg \
-	verilator_includer verilator_profcfunc
+# 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
+	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) README File" "${DISTDATE}" < README.tex > README2.tex
+	mv README2.tex README.tex
+	pdflatex README.tex
+	pdflatex README.tex
+	-rm -f README.toc README.aux README.idx README.out
+
+internals.txt: internals.pod
+	-rm -f $@
+	$(POD2TEXT) --loose $< > $@
+
+internals.html: internals.pod
+	pod2html $< >$@
+
+# PDF needs DIST variables; but having configure.ac as dependency isn't detected
+internals.pdf: internals.pod Makefile
+	pod2latex --full --out internals.tex internals.pod
+	$(PERL) $(POD2LATEXFIX) "$(DISTTITLE) Internals Manual" "${DISTDATE}" < internals.tex > internals2.tex
+	mv internals2.tex internals.tex
+	pdflatex internals.tex
+	pdflatex internals.tex
+	-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_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 verilator_coverage.1 verilator_profcfunc.1
+
+VL_INST_INC_BLDDIR_FILES = \
+	include/verilated.mk \
+
+# Files under srcdir, instead of build time
+VL_INST_INC_SRCDIR_FILES = \
+	include/*.[chv]* \
+	include/vltstd/*.[chv]* \
+
+VL_INST_DATA_SRCDIR_FILES = \
+	test_v/*.[chv]* \
+	test_c/*.[chv]*   test_c/Makefile  test_c/Makefile_obj  \
+	test_sc/*.[chv]*  test_sc/Makefile test_sc/Makefile_obj \
+
 installbin:
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(bindir)
-	( cd bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
-	( cd bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
+	( 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 bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
 
-installman:
+# Man files can either be part of the original kit, or built in current directory
+# So important we use $< so VPATH is searched
+installman: $(VL_INST_MAN_FILES)
 	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(mandir)/man1
-	for p in $(VL_INST_MAN_FILES) ; do \
-	  $(INSTALL_PROGRAM) $$p $(DESTDIR)$(mandir)/man1/$$p; \
+	for p in $^ ; do \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(mandir)/man1/$$p; \
 	done
 
 installdata:
-	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples
-	cp -r include $(DESTDIR)$(pkgdatadir)
-	cp -r test_c  $(DESTDIR)$(pkgdatadir)/examples
-	cp -r test_sc $(DESTDIR)$(pkgdatadir)/examples
-	cp -r test_sp $(DESTDIR)$(pkgdatadir)/examples
-	cp -r test_v  $(DESTDIR)$(pkgdatadir)/examples
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/include/vltstd
+	for p in $(VL_INST_INC_BLDDIR_FILES) ; do \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
+	done
+	cd $(srcdir) \
+	; for p in $(VL_INST_INC_SRCDIR_FILES) ; do \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
+	done
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_c
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_sc
+	$(SHELL) ${srcdir}/mkinstalldirs $(DESTDIR)$(pkgdatadir)/examples/test_v
+	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)
 
-VL_INST_DATA_FILES = verilator.1
-install: all_nomsg installbin installman installdata install-msg
+# We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
+uninstall:
+	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
+	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/examples && rm -f $(VL_INST_DATA_SRCDIR_FILES)
+	-rm $(DESTDIR)$(pkgconfigdir)/verilator.pc
+	-rmdir $(DESTDIR)$(pkgdatadir)/bin
+	-rmdir $(DESTDIR)$(pkgdatadir)/include/vltstd
+	-rmdir $(DESTDIR)$(pkgdatadir)/include
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_c
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sc
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_sp
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/test_v
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples
+	-rmdir $(DESTDIR)$(pkgdatadir)
+	-rmdir $(DESTDIR)$(pkgconfigdir)
+
+install: all_nomsg install-all
+install-all: installbin installman installdata install-msg
 
 install-here: installman ftp
 
 ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
+DISTNAMEREV = $(shell sed -e '/DTVERSION/!d' -e 's/.*verilator_\([^"]*\).*/\1/' -e q ${srcdir}/src/config_rev.h)
+
 DIRPROJECT := $(shell project_dir --project)
+VERILATOR_CAD_DIR = $(CAD_DIR)/verilator/$(DISTNAMEREV)/$(DIRPROJECT_ARCH)
 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 verilator.1 ; do \
-	  $(INSTALL_PROGRAM) -m 0666 $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \
+	for p in $(VL_INST_MAN_FILES) ; do \
+	  $(INSTALL_DATA) $$p $(DIRPROJECT_PREFIX)/man/man1/$$p; \
 	done
 	$(INST_PROJ_CVS) $(DISTNAME).tgz $(DIRPROJECT)/hw/utils/verilator/verilator.tgz
 	rm $(DISTNAME).tgz
@@ -292,49 +376,82 @@ endif
 	for p in $(INST_PROJ_BIN_FILES) ; do \
 	  $(INST_PROJ_CVS) $$p $(DIRPROJECT)/hw/utils/verilator/$$p-$(DIRPROJECT_ARCH); \
 	done
+
+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 \
+	  $(INSTALL_DATA) $$p $(VERILATOR_CAD_DIR)/man/man1/$$p; \
+	done
+	$(INST_PROJ_CVS) $(DISTNAME).tgz $(VERILATOR_CAD_DIR)/verilator.tgz
+	rm $(DISTNAME).tgz
+
+install-cadtools-quick:
+ifeq ($(CFG_WITH_DEFENV),yes)
+	@echo "%Error: Reconfigure with './configure --disable-defenv' to avoid hardcoded paths."
+	false
 endif
+	@echo "Install-cadtools-quick (no strip) to $(VERILATOR_CAD_DIR)"
+	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/include/vltstd
+	$(SHELL) ${srcdir}/mkinstalldirs $(VERILATOR_CAD_DIR)/bin
+	for p in $(INST_PROJ_FILES) ; do \
+	  $(INST_PROJ_CVS) $$p $(VERILATOR_CAD_DIR)/$$p; \
+	done
+	for p in $(INST_PROJ_BIN_FILES) ; do \
+	  $(INST_PROJ_CVS) $$p $(VERILATOR_CAD_DIR)/$$p; \
+	done
+
+# VERILATOR_AUTHOR_SITE
+endif
+
+# Use --xml flag to see the cppcheck code to use for suppression
+CPPCHECK = src/cppcheck_filtered
+CPPCHECK_FLAGS = --enable=all --inline-suppr \
+	--suppress=unusedScopedObject --suppress=cstyleCast --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 $(CPPCHECK_INC) $<
 
 ftp: info
 
 install-msg:
 	@echo "Installed!"
 	@echo
-	@echo "Add to your startup file (for bash or csh, as appropriate):"
-	@echo "	export VERILATOR_ROOT="`pwd`
-	@echo "	setenv VERILATOR_ROOT "`pwd` " ; export VERILATOR_ROOT "
-	@echo
-	@echo "See 'verilator.txt' for documentation."
+	@echo "For documentation see 'man verilator' or 'verilator --help'"
+	@echo "For forums and to report bugs see http://www.veripool.org/verilator"
 	@echo
 
-uninstall:
-	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
-	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_BIN_FILES)
-	-rm -f $(DESTDIR)$(pkgdatadir)
+IN_WILD := ${srcdir}/*.in ${srcdir}/*/*.in
 
-# autoheader might not change config_build.h.in, so touch a stamp file.
-IN_WILD := ${srcdir}/*.in ${srcdir}/*/*.in ${srcdir}/*/*/*.in \
-	*.in */*.in */*.in
-
-${srcdir}/config_build.h.in: stamp-h.in
-${srcdir}/stamp-h.in: configure.ac $(wildcard $(IN_WILD))
+# autoheader might not change config_build.h.in, so touch it
+${srcdir}/config_build.h: ${srcdir}/config_build.h.in configure
 	cd ${srcdir} && autoheader
-	echo timestamp > ${srcdir}/stamp-h.in
-config_build.h: stamp-h
-stamp-h: config_build.h.in config.status
-	./config.status
-Makefile: Makefile.in config.status
-	./config.status
-src/Makefile: src/Makefile.in config.status
+	touch $@
+Makefile: Makefile.in config.status $(IN_WILD)
 	./config.status
+src/Makefile: src/Makefile.in Makefile
 config.status: configure
 	./config.status --recheck
+
 configure: configure.ac
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+	autoconf --warnings=all
+else
 	autoconf
+endif
 
 maintainer-clean::
 	@echo "This command is intended for maintainers to use;"
 	@echo "rebuilding the deleted files requires makeinfo."
-	rm -f *.info* $(INFOS) faq.html verilator.html configure
+	rm -f *.info* $(INFOS) configure
 
 clean mostlyclean distclean maintainer-clean maintainer-copy::
 	for dir in $(SUBDIRS); do \
@@ -350,15 +467,21 @@ 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}/*/[a-z]*.in \
-	${srcdir}/[a-z]*.in ${srcdir}/*.texi
+TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
+	${srcdir}/*.in ${srcdir}/*.pod
 
 TAGS:	$(TAGFILES)
 	etags $(TAGFILES)
 
+.PHONY: doxygen
+
+doxygen:
+	$(DOXYGEN) doxygen.config
+
 ######################################################################
 # Test targets
 
@@ -370,14 +493,12 @@ dist-file-list:
 ######################################################################
 # Distributions
 
-DISTCONFIG = src/config_build.h.in
-
-DISTTITLE := $(shell sed -e '/DTVERSION/!d' -e 's/[^0-9]*\([0-9.a-z]*\).*/verilator-\1/' -e 's/v/V/' -e q $(DISTCONFIG))
-DISTNAME := $(shell sed -e '/DTVERSION/!d' -e 's/[^0-9]*\([0-9.a-z]*\).*/verilator-\1/' -e q $(DISTCONFIG))
-DISTDATEPRE := $(shell sed -e '/DTVERSION/!d' -e 's/.*\([1-2][0-9][0-9][0-9].[0-9]*[0-9].[0-9]*[0-9]\).*/\1/' -e q $(DISTCONFIG))
+DISTTITLE := Verilator $(word 1,$(PACKAGE_VERSION))
+DISTNAME := verilator-$(word 1,$(PACKAGE_VERSION))
+DISTDATEPRE := $(word 2,$(PACKAGE_VERSION))
+DISTDATE := $(subst /,-,$(DISTDATEPRE))
 
 DISTTAGNAME := $(subst .,_,$(subst -,_,$(DISTNAME)))
-DISTDATE := $(subst /,-,$(DISTDATEPRE))
 
 tag:
 	svnorcvs tag $(DISTTAGNAME)

README.pod

@@ -0,0 +1,201 @@
+# DESCRIPTION: DOCUMENT source run through perl to produce README file
+# Use 'make README' to produce the output file
+
+=pod
+
+=head1 NAME
+
+This is the Verilator package README file.
+
+=head1 DISTRIBUTION
+
+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
+the terms of either the GNU Lesser General Public License Version 3 or the
+Perl Artistic License Version 2.0.  (See the documentation for more
+details.)
+
+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.
+
+=head1 DESCRIPTION
+
+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 .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
+compiled in C++, and linked with the Verilated files.
+
+The resulting executable will perform the actual simulation.
+
+=head1 SUPPORTED SYSTEMS
+
+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
+
+For more details see 
+L<http://www.veripool.org/projects/verilator/wiki/Installing>.
+
+If you will be modifying Verilator, you should use the "git" method as it
+will let you track changes.
+
+=over 4
+
+=item
+
+The latest version is available at L<http://www.veripool.org/verilator>.
+
+Download the latest package from that site, and decompress.
+
+    tar xvzf verilator_version.tgz
+
+=item
+
+If you will be using SystemC (vs straight C++ output), download SystemC
+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
+
+You will need the C<flex> and C<bison> packages installed.
+
+=item
+
+C<cd> to the Verilator directory containing this README.
+
+=item
+
+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,
+and SYSTEMC_LIBDIR as defaults into the executable, so try to have them
+correct before configuring.
+
+=over 4
+
+=item 1.
+
+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 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
+    ./configure
+
+=item 2.
+
+To install globally onto a "cad" disk with multiple versions of every tool,
+and add it to path using Modules/modulecmd:
+
+    unset VERILATOR_ROOT      # if your shell is bash
+    unsetenv VERILATOR_ROOT   # if your shell is csh
+    # For the tarball, use the version number instead of git describe
+    ./configure --prefix /CAD_DISK/verilator/`git describe | sed "s/verilator_//"`
+
+    After installing you'll want a module file like the following:
+
+    set install_root /CAD_DISK/verilator/{version-number-used-above}
+    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.
+
+The next option is to install it globally, using the normal system paths:
+
+    unset VERILATOR_ROOT      # if your shell is bash
+    unsetenv VERILATOR_ROOT   # if your shell is csh
+    ./configure
+
+=item 4.
+
+Alternatively you can configure a prefix that install will populate, as
+most GNU tools support:
+
+    unset VERILATOR_ROOT      # if your shell is bash
+    unsetenv VERILATOR_ROOT   # if your shell is csh
+    ./configure --prefix /opt/verilator-VERSION
+
+Then after installing you will need to add /opt/verilator-VERSION/bin to
+PATH.
+
+=back
+
+=item
+
+Type C<make> to compile Verilator.
+
+Type C<make test> to check the compilation.
+
+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
+unsigned long uint32_t;}.
+
+=item
+
+If you used the VERILATOR_ROOT scheme you're done.  Programs should set the
+environment variable VERILATOR_ROOT to point to this distribution, then
+execute $VERILATOR_ROOT/bin/verilator, which will find the path to all
+needed files.
+
+If you used the prefix scheme, now do a C<make install>.  To run verilator,
+have the verilator binary directory in your PATH (this should already be
+true if using the default configure), and make sure VERILATOR_ROOT is not
+set.
+
+=back
+
+=head1 USAGE DOCUMENTATION
+
+Detailed documentation and the man page can be seen by running:
+
+    bin/verilator --help
+
+or reading verilator.txt in the same directory as this README.
+
+=head1 DIRECTORY STRUCTURE
+
+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.v         => Stub defines for linting
+    include/verilated.mk        => Common makefile
+    src/                        => Translator source code
+    test_v                      => Example Verilog code for other test dirs
+    test_c                      => Example Verilog->C++ conversion
+    test_sc                     => Example Verilog->SystemC conversion
+    test_verilated              => Internal tests
+    test_regress                => Internal tests
+
+=head1 LIMITATIONS
+
+See verilator.txt (or execute C<bin/verilator --help>) for limitations.

TODO

@@ -1,154 +1,129 @@
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2009 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.
 
 
-Features:
-	Finish 3.400 new ordering fixes
-	Latch optimizations {Need here}
-	Task I/Os connecting to non-simple variables.
-	Fix nested casez statements expanding into to huge C++. [JeanPaul Vanitegem]
-	Fix FileLine memory inefficiency
-	Fix ordering of each bit separately in a signal (mips)
+Language support:
+	* Fix ordering of each bit separately in a signal (mips)
 		assign b[3:0] = b[7:4];  assign b[7:4] = in;
-	Support gate primitives/ cell libraries from xilinx, etc
-	Assign dont_care value to an 1'bzzz assignment
-	Function to eval combo logic after /*verilator public*/ functions [gwaters]
-	Support generated clocks (correctness)
-	?gcov coverage
-	Selectable SystemC types based on widths (see notes below)
-	Compile time
-		Inline first level trace routines
-	Coverage
-		Points should be per-scope like everything else rather then per-module
-		Expression coverage (see notes)
-	Constant functions for widths, etc, IE   "input [log2(PARAM):0] xx;"
-	More Verilog 2001 Support
-		(* *) Attributes  (just ignore -- preprocessor?)
-		Real numbers (NEVER)
-		Recursive functions (NEVER)
-		Verilog configuration files (NEVER)
-	DPI to define C/C++ calls from Verilog
+	* Support UDP gate primitives/ cell libraries
+		(have code for combos - problem is sequential udps)
+	* Function to eval combo logic after /*verilator public*/ functions [gwaters]
+	* Support generated clocks (correctness)
+	* Real numbers
+	* Recursive functions
+	* Verilog configuration files
+	* Structs/unions (have starting point)
+	* DPI to define C/C++ calls from Verilog
+	* Expression coverage (see notes)
+	* Better tristate support
 
 Long-term Features
-	Assertions
-	VHDL parser  [Philips]
-	Tristate support
-	SystemPerl integration
-	Multithreaded execution
-	Front end parser integration into Verilog-Perl like Netlist
+	* Assertions
+	* Tristate support
+	* Multithreaded execution
+
+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.
 
 Testing:
-	Capture all inputs into global "rerun it" file
-	Code to make wrapper that sets signals, so can do comparison checks
-	New random program generator
-	Better graph viewer with search and zoom
-	Port and test against opencores.org code
+	* Move test_c/sp/v/verilated into test_regress format (4.000?)
+	* Capture all inputs into global "rerun it" file
+	* Code to make wrapper that sets signals, so can do comparison checks
+	* New random program generator
+	* Better graph viewer with search and zoom
+	* Port and test against opencores.org code
+	* // verilator debug in code so can see only tree affecting those nodes
 
 Usability:
-	Better reporting of unopt problems, including what lines of code
-	Report more errors (all of them?) before exiting [Eugene Weber]
+	* Detect and pre-remove most UNOPTFLATs (4.000) 
+	* Better reporting of unopt problems, including what lines of code
+	* Report more errors (all of them?) before exiting [Eugene Weber]
+	* Auto-create scons config files
+	* Print version/etc message at runtime. (4.000?)
+	  Include number of lines of code, percent comments, code complexity measurement
+	  <-80chars------------------------------------------------------------------->
+	  Verilator 3.600 - fast, free, open-sourced.  Copyright 2001-2013.
+	  Verilated #### modules, #### instances, ##### sigs,
+	  	    #### non-comment lines, ##### ops, ### KB model size
+	* Default the --l2name to remove extra "v" level of hierarchy (flag to make "top")
+
+Lint:
+	* CDCRSTLOGIC should allow filtering with paths
+	  "waive CDCRSTLOGIC --from a.b.sig  --to a.c.sig --via OR"
 
 Internal Code:
-	Eliminate the AstNUser* passed to all visitors; its only needed in V3Width,
-	and removing it will speed up and simplify all the other code.
-	V3Graph should be templated container type, taking in Vertex + Edge types
+	* Eliminate the AstNUser* passed to all visitors; its only needed in V3Width,
+	  and removing it will speed up and simplify all the other code.
+	* V3Graph should be templated container type, taking in Vertex + Edge types
+	* Rename V3PreLex etc to match VerilogPerl filenames
+	* Instead of string, have an VEncodedString/VIdString which contains __DOT__ish
+	  things, to reduce bugs.  Also add _20 trailing space to \ encoded names. (4.000)
+
+Runtime:
+	* New evalulation loop   ~/src/verilator/notes/event_loop.txt (4.000?)
+	* Remove all private internal functions from top level wrapper header, move
+	  to new level (4.000?)
+	* Completely standalone simulation (4.000)
+	   main() records arguments for $test$plusvars
+	   instantiates top,
+	   does tracing  (support $dump?)
+	   calls top->simulateForever()
+	   exits
 
 Performance:
-	Constant propagation
+	* Latch optimizations
+	* Constant propagation
 		Extra cleaning AND:  1 & ((VARREF >> 1) | ((&VARREF >> 1) & VARREF))
 		Extra shift (perhaps due to clean): if (1 & CAST (VARREF >> #))
-	Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
+	* Gated clock and latch conversion to flops.  [JeanPaul Vanitegem]
 		Could propagate the AND into pos/negedges and let domaining optimize.
-	Negedge reset
+	* Negedge reset
 		Switch to remove negedges that don't matter
 		Can't remove async resets from control flops (like in syncronizers)
-	If all references to array have a constant index, blow up into separate signals-per-index
-	Multithreaded execution
-	Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
-	Move _last sets and all other combo logic inside master
+	* If all references to array have a constant index, blow up into separate signals-per-index
+	* Bit-multiply for faster bit swapping and a=b[1,3,2] random bit reorderings.
+	* Move _last sets and all other combo logic inside master
 		if() that triggers on all possible sense items
-	Rewrite and combine V3Life, V3Subst
+	* Rewrite and combine V3Life, V3Subst
 		If block temp only ever set in one place to constant, propagate it
 			Used in t_mem for array delayed assignments
 		Replace variables if set later in same cfunc branch
 			See for example duplicate sets of _narrow in cycle 90/91 of t_select_plusloop
-	Same assignment on both if branches
+	* Same assignment on both if branches
 		"if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
 		Careful though, as b could appear in the statement or multiple times in statement
 		(Could just require exatly two 'b's in statement)
-	Simplify XOR/XNOR/AND/OR bit selection trees
+	* Simplify XOR/XNOR/AND/OR bit selection trees
 		Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
-	Combine variables into wider elements
+	* Combine variables into wider elements
 		Parallel statements on different bits should become single signal
 		Variables that are always consumed in "parallel" can be joined
-	Duplicate assignments in gate optimization
+	* Duplicate assignments in gate optimization
 		Common to have many separate posedge blocks, each with identical
 		reset_r <= rst_in
-	*If signal is used only once (not counting trace), always gate substitute
+	* If signal is used only once (not counting trace), always gate substitute
 		Don't merge if any combining would form circ logic (out goes back to in)
-	Multiple assignments each bit can become single assign with concat
+	* Multiple assignments each bit can become single assign with concat
 		Make sure a SEL of a CONCAT can get the single bit back.
-	Usually blocks/values
+	* Usually blocks/values
 		Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
-	Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
-	Allow Split of case statements without a $display/$stop
-	I-cache packing improvements (what/how?)
-	Data cache organization (order of vars in class)
+	* Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
+	* Allow Split of case statements without a $display/$stop
+	* I-cache packing improvements (what/how?)
+	* Data cache organization (order of vars in class)
 		First have clocks,
 		then bools instead of uint32_t's
 		then based on what sense list they come from, all outputs, then all inputs
 		finally have any signals part of a "usually" block, or constant.
-	Rather then tracking widths, have a MSB...LSB of this expression
+	* Rather then tracking widths, have a MSB...LSB of this expression
 		(or better, a bitmask of bits relevant in this expression)
-	Track recirculation and convert into clock-enables
-	Clock enables should become new clocking domains for speed
-	If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
-	Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)
-
-	All of the temp vars that get set, exp pre_ vars and never feedback
-	(not flops) don't need to be stored in the structs, but instead can
-	be per-invocation, and even better register-colored-like to reuse
-	the space.  This will greatly reduce the data footprint.
-
-
-//**********************************************************************
-//* Detailed notes on 'todo' features
-
-Selectable SystemC types based on widths (see notes below)
-	Statements:
-		verilator sc_type    uint32_t  {override specific I/O signals}
-		verilator sc_typedef width 1     bool
-		verilator sc_typedef width 2-32  uint32_t
-		verilator sc_typedef width 33-64 uint64_t
-		verilator sc_typedef width 65+   sc_bv<width>	//<< programmable width
-	Replace `systemc_clock, --pins64
-	Have accessor function with type overloading to get or set the pin value.
-	(Get rid of getdatap mess?)
-
-//**********************************************************************
-//* Eventual tristate bus Stuff allowed (old verilator)
-
- 1) Tristate assignments must be continuous assignments
-    The RHS of a tristate assignment can be the following
-       a) a node (tristate or non-tristate)
-       b) a constant (must be all or no z's)
-	    x'b0, x'bz, x{x'bz}, x{x'b0} -> are allowed
-       c) a conditional whose possible values are (a) or (b)
-
- 2) One can lose that fact that a node is a tristate node.  This happens
-    if a tristate node is assigned to a 'standard' node, or is used on
-    RHS of a conditional. The following infer tristate signals:
-       a) inout <SIGNAL>
-       b) tri <SIGNAL>
-       c) assigning to 'Z' (maybe through a conditional)
-    Note: tristate-ness of an output port determined only by
-          statements in the module (not the instances it calls)
-
- 4) Tristate variables can't be multidimensional arrays
- 5) Only check tristate contention between modules (not within!)
- 6) Only simple compares with 'Z' are allowed (===)
-
+	* Track recirculation and convert into clock-enables
+	* Clock enables should become new clocking domains for speed
+	* If floped(a) & flopped(b) and no other a&b, then instead flop(a&b).
+	* Sort by output bitselects so can combine more assignments (see DDP example dx_dm signal)

bin/verilator_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

@@ -14,6 +14,19 @@ use vars qw ($Debug);
 
 #======================================================================
 
+# Old version 1 dump nodes with no dtypep's
+our %Ver1_Non_Dtyped = map {$_ => 1} qw(
+  ACTIVE ALWAYS ALWAYSPOST ALWAYSPUBLIC ATTROF BEGIN BREAK CASE CASEITEM
+  CCALL CELL CELLINLINE CFILE CFUNC CHANGEDET CLOCKING COMMENT CONTINUE
+  COVERDECL COVERINC COVERTOGGLE CRETURN CSTMT DEFPARAM DISABLE DISPLAY DOT
+  DPIEXPORT FCLOSE FFLUSH FINAL FINISH FOPEN GENCASE GENERATE GENFOR GENIF
+  IF IMPLICIT INITARRAY INITIAL JUMPGO JUMPLABEL MODULE NETLIST
+  NOTFOUNDMODULE PACKAGE PACKAGEIMPORT PARSEREF PIN PORT PRAGMA PRIMITIVE
+  PSLASSERT PSLCOVER PSLDEFCLOCK PULL RANGE READMEM REPEAT RETURN SCCTOR
+  SCDTOR SCHDR SCIMP SCIMPHDR SCINT SCOPE SELBIT SELEXTRACT SELMINUS
+  SELPLUS SENGATE SENITEM SENTREE SFORMAT SFORMATF STOP SYSIGNORE SYSTEMT
+  TASK TASKREF TEXT TOPSCOPE TYPEDEFFWD TYPETABLE UCSTMT UDPTABLE
+  UDPTABLELINE UNTILSTABLE VASSERT WHILE );
 
 #======================================================================
 # main
@@ -62,6 +75,7 @@ sub diff_dir {
 	(my $base = $fn) =~ s!.*/!!;
 	$files{$base}{b} = $fn;
     }
+    my $any;
     foreach my $base (sort (keys %files)) {
 	my $a = $files{$base}{a};
 	my $b = $files{$base}{b};
@@ -69,34 +83,81 @@ sub diff_dir {
 	print "="x70,"\n";
 	print "= $a <-> $b\n";
 	diff_file($a,$b);
+	$any = 1;
     }
+    $any or warn "%Warning: No .tree files found\n";
 }
 
 sub diff_file {
     my $a = shift;
     my $b = shift;
     # Compare the two tree files
-    my $tmp_a = "/tmp/$$.a";
-    my $tmp_b = "/tmp/$$.b";
+    (my $short_a = $a) =~ s/[^a-zA-Z0-9.]+/_/g;
+    (my $short_b = $b) =~ s/[^a-zA-Z0-9.]+/_/g;
+    my $tmp_a = "/tmp/${$}_${short_a}.a";
+    my $tmp_b = "/tmp/${$}_${short_b}.b";
 
-    filter ($a, $tmp_a);
-    filter ($b, $tmp_b);
+    my $vera = version_from($a);
+    my $verb = version_from($b);
+    my $verCvt = (($vera < 0x3900 && $verb >= 0x3900)
+		  || ($vera >= 0x3900 && $verb < 0x3900));
+
+    filter ($a, $tmp_a, $verCvt);
+    filter ($b, $tmp_b, $verCvt);
     system("diff -u $tmp_a $tmp_b");
     unlink $tmp_a;
     unlink $tmp_b;
 }
 
+sub version_from {
+    my $fn = shift;
+    # Return dump format
+    my $f1 = IO::File->new ($fn) or die "%Error: $! $fn,";
+    while (defined (my $line=$f1->getline())) {
+	last if $. > 10;
+	return hex $1 if $line =~ /\(format (0x[0-9.]+)\)/;
+    }
+    return 1.0;
+}
+
 sub filter {
     my $fn1 = shift;
     my $fn2 = shift;
+    my $verCvt = shift;
     # Remove hex numbers before diffing
     my $f1 = IO::File->new ($fn1) or die "%Error: $! $fn1,";
     my $f2 = IO::File->new ($fn2,"w") or die "%Error: $! $fn2,";
     while (defined (my $line=$f1->getline())) {
+      same_line:
 	next if $line =~ / This=/;
 	$line =~ s/0x[a-f0-9]+/0x/g;
 	$line =~ s/<e[0-9]+\#?>/<e>/g;
-	$line =~ s/{\d+}/{}/g if !$Opt_Lineno;
+	$line =~ s/{[a-z]*\d+}/{}/g if !$Opt_Lineno;
+	if ($verCvt) {
+	    next if $line =~ /^     NETLIST/;
+	    $line =~ s!\@dt=0x\(G?/?([^)]+)\)!$1!g;  # NEW: @dt -> OLD: non @dt format
+	    #					     # Below Ver1_Non_Dtyped may replace above further
+	    if ($line =~ /: ([A-Z]+) /) {
+		my $type = $1;
+		next if $type =~ 'DTYPE';
+		if ($type eq 'TYPETABLE' || $type eq 'RANGE') {
+		    $line =~ /^(\s+\S+:) /; my $prefix = $1;
+		    while (defined ($line=$f1->getline())) {
+			next if $line =~ /^\s+[a-z]/;  # Table body
+			next if $line =~ /^${prefix}[0-9]:/;
+			goto same_line;
+		    }
+		    next;
+		}
+		if ($Ver1_Non_Dtyped{$type}) {
+		    $line =~ s! w[0-9]+!!g;
+		}
+	    }
+	    $line =~ s!\@dt=0$!NoW!g;   # NEW: dt=null -> common format
+	    $line =~ s!\@dt=0 !NoW !g;  # NEW: dt=null -> common format
+	    $line =~ s! s?w0$! NoW!g;   # OLD: no width -> common format
+	    $line =~ s! s?w0 ! NoW !g;  # OLD: no width -> common format
+	}
 	print $f2 $line;
     }
     $f1->close;
@@ -106,7 +167,7 @@ sub filter {
 #----------------------------------------------------------------------
 
 sub usage {
-    pod2usage(-verbose=>2, -exitval => 2);
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
     exit (1);
 }
 
@@ -174,7 +235,7 @@ Do not show differences in line numbering.
 
 The latest version is available from L<http://www.veripool.org/verilator>.
 
-Copyright 2005-2009 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.
 
@@ -190,5 +251,5 @@ C<verilator>
 
 ######################################################################
 ### Local Variables:
-### compile-command: "$V4/bin/verilator_difftree  $V4/test_c/obj_dir/V*_03_*.tree $V4N/test_c/obj_dir/V*_03_*.tree"
+### compile-command: "$V4/bin/verilator_difftree  {$V4D,$V4}/test_regress/obj_dir/t_EXAMPLE/V*_03_*.tree"
 ### End:

bin/verilator_includer

@@ -3,13 +3,18 @@ eval 'exec perl -wS $0 ${1+"$@"}'
   if 0;
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2009 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.
 ######################################################################
 
 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

@@ -39,7 +39,7 @@ profcfunc($Opt_File);
 #----------------------------------------------------------------------
 
 sub usage {
-    pod2usage(-verbose=>2, -exitval => 2);
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
     exit (1);
 }
 
@@ -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-2009 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,36 +1,87 @@
-dnl DESCRIPTION: Process this file with autoconf to produce a configure script.
-dnl
-dnl Copyright 2003-2009 by Wilson Snyder. Verilator is free software; you can
-dnl redistribute it and/or modify it under the terms of either the GNU Lesser
-dnl General Public License Version 3 or the Perl Artistic License Version 2.0.
+# DESCRIPTION: Process this file with autoconf to produce a configure script.
+#
+# 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.878 2015-11-01])
+# When releasing, also update header of Changes file
 
-AC_INIT(src/Verilator.cpp)
 AC_CONFIG_HEADER(src/config_build.h)
+AC_CONFIG_FILES(Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc)
 
-dnl Special Substitutions
-AC_ARG_ENABLE(defenv,
-   [AS_HELP_STRING([--disable-defenv], [disable hardcoded default environment variables])],
-   CFG_WITH_DEFENV=$enableval,
-   CFG_WITH_DEFENV=yes)
+AC_MSG_RESULT([configuring for $PACKAGE_STRING])
+
+# Special Substitutions - CFG_WITH_DEFENV
+AC_MSG_CHECKING(whether to disable hardcoded paths)
+AC_ARG_ENABLE([defenv],
+              [AS_HELP_STRING([--disable-defenv],
+                              [disable using some hardcoded data paths extracted from some default environment variables (the default is to use hardcoded paths)])],
+              [case "${enableval}" in
+                yes) CFG_WITH_DEFENV=yes ;;
+                no)  CFG_WITH_DEFENV=no ;;
+                *)   AC_MSG_ERROR([bad value ${enableval} for --disable-defenv]) ;;
+               esac],
+              CFG_WITH_DEFENV=yes)
 AC_SUBST(CFG_WITH_DEFENV)
+AC_MSG_RESULT($CFG_WITH_DEFENV)
 
-dnl Compiler flags
-CXX=g++
+# Special Substitutions - CFG_WITH_CCWARN
+AC_MSG_CHECKING(whether to show and stop on compilation warnings)
+AC_ARG_ENABLE([ccwarn],
+              [AS_HELP_STRING([--enable-ccwarn],
+                              [enable showing and stopping on compilation warnings])],
+              [case "${enableval}" in
+                yes) CFG_WITH_CCWARN=yes ;;
+                no)  CFG_WITH_CCWARN=no ;;
+                *)   AC_MSG_ERROR([bad value ${enableval} for --enable-ccwarn]) ;;
+               esac],
+              [case "x${VERILATOR_AUTHOR_SITE}" in
+                x)   CFG_WITH_CCWARN=no ;;
+                *)   CFG_WITH_CCWARN=yes ;;
+               esac]
+	      )
+AC_SUBST(CFG_WITH_CCWARN)
+AC_MSG_RESULT($CFG_WITH_CCWARN)
+
+# Special Substitutions - CFG_WITH_LONGTESTS
+AC_MSG_CHECKING(whether to run long tests)
+AC_ARG_ENABLE([longtests],
+              [AS_HELP_STRING([--enable-longtests],
+                              [enable running long developer tests])],
+              [case "${enableval}" in
+                yes) CFG_WITH_LONGTESTS=yes ;;
+                no)  CFG_WITH_LONGTESTS=no ;;
+                *)   AC_MSG_ERROR([bad value ${enableval} for --enable-longtests]) ;;
+               esac],
+              [case "x${VERILATOR_AUTHOR_SITE}" in
+                x)   CFG_WITH_LONGTESTS=no ;;
+                *)   CFG_WITH_LONGTESTS=yes ;;
+               esac]
+	      )
+AC_SUBST(CFG_WITH_LONGTESTS)
+AC_MSG_RESULT($CFG_WITH_LONGTESTS)
+
+# Compiler flags
 CFLAGS=-I${includedir}
 CPPFLAGS=-I${includedir}
 CXXFLAGS=-I${includedir}
 LDFLAGS=-L${libdir}
 
-dnl Checks for programs.
+# Checks for programs.
 AC_PROG_CC
 AC_PROG_CXX
 AC_PROG_INSTALL
 
 AC_LANG_PUSH(C++)
 AC_MSG_CHECKING([that C++ compiler can compile simple program])
-AC_TRY_RUN([int main() { return 0; }],
+AC_RUN_IFELSE(
+           [AC_LANG_SOURCE([int main() { return 0; }])],
            AC_MSG_RESULT(yes),
-           AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]))
+           AC_MSG_RESULT(no);AC_MSG_ERROR([a working C++ compiler is required]),
+	   AC_MSG_RESULT(yes))
 
 AC_PATH_PROG(PERL,perl)
 if test "x$PERL" = "x" ; then
@@ -45,33 +96,78 @@ if test "x$YACC" = "x" ; then
    AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
 fi
 
-dnl Checks for libraries.
+# Checks for libraries.
 
-dnl Checks for header files.
-AC_HEADER_STDC
-AC_HEADER_SYS_WAIT
-AC_CHECK_HEADERS(fcntl.h unistd.h inttypes.h sys/file.h sys/time.h sys/un.h math.h stdint.h mingw/stdint.h)
-
-dnl Checks for typedefs, structures
+# Checks for typedefs, structures
 AC_CHECK_TYPE(size_t,unsigned int)
-AC_CHECK_TYPE(uint_t,unsigned int)
-AC_CHECK_TYPE(ulong_t,unsigned long)
 AC_TYPE_SIZE_T
-AC_STRUCT_TM
 
-dnl Checks for compiler characteristics.
+# Checks for compiler characteristics.
 AC_C_INLINE
 
-dnl Checks for library functions.
+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 $2 -Werror"
+    AC_MSG_CHECKING([whether $CXX accepts $2])
+    AC_COMPILE_IFELSE(
+         [AC_LANG_PROGRAM([],[])],
+	 [_my_result=yes
+	  if test -s conftest.err; then
+	    if grep -e "$2" conftest.err >/dev/null; then
+	      _my_result=no
+	    fi
+	  fi],
+	 [_my_result=no])
+    AC_MSG_RESULT($_my_result)
+    if test "$_my_result" = "yes" ; then
+       $1="$$1 $2"
+    fi
+    CXXFLAGS="$ACO_SAVE_CXXFLAGS"
+   ])# _MY_CXX_CHECK_OPT
 
-dnl Checks for system services
+# 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)
 
-dnl Other install directories
+# 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(CFG_CXXFLAGS_NO_UNUSED,-Wno-char-subscripts)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-Wno-parentheses-equality)
+# Random code often does / 0.  Unfortunately VL_DIV_I(0,0) will warn
+# without this flag, even though there's a conditional to prevent the divide.
+# We still don't add no-div-by-zero as it throws message to stdout, though doesn't die.
+#_MY_CXX_CHECK_OPT(-Wno-div-by-zero)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_NO_UNUSED,-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.
+
+# Checks for system services
+
+# Other install directories
 pkgdatadir=${datadir}/verilator
 AC_SUBST(pkgdatadir)
+pkgconfigdir=${datadir}/pkgconfig
+AC_SUBST(pkgconfigdir)
 
-AC_OUTPUT(Makefile src/Makefile src/Makefile_obj include/verilated.mk)
+AC_OUTPUT
 
 AC_MSG_RESULT([])
-AC_MSG_RESULT([Now type 'gmake'])
+AC_MSG_RESULT([Now type 'make' (or sometimes 'gmake') to build Verilator.])
 AC_MSG_RESULT([])

doxygen-mainpage

@@ -0,0 +1,6 @@
+/*! \mainpage Verilator Doxygen Documentation
+ *
+ * \section intro_sec Introduction
+ *
+ * This is a full doxygen analysis of the Verilator source tree.
+ */

include/.gitignore

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

include/verilated.h

@@ -1,7 +1,7 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2009 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>
@@ -35,23 +36,66 @@
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <iostream>
+#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;
 
+//=============================================================================
+// Switches
+
+#if VM_TRACE		// Verilator tracing requested
+# define WAVES 1	// Set backward compatibility flag as in systemperl.h
+#endif
+
 //=========================================================================
 // Basic types
 
-typedef vluint8_t    CData;	///< Verilated data, 1-8 bits
-typedef vluint16_t   SData;	///< Verilated data, 9-16 bits
-typedef vluint32_t   IData;	///< Verilated data, 17-32 bits
-typedef vluint64_t   QData;	///< Verilated data, 33-64 bits
-typedef vluint32_t   WData;	///< Verilated data, >64 bits, as an array
+//		     P		// Packed data of bit type (C/S/I/Q/W)
+typedef vluint8_t    CData;	///< Verilated pack data, 1-8 bits
+typedef vluint16_t   SData;	///< Verilated pack data, 9-16 bits
+typedef vluint32_t   IData;	///< Verilated pack data, 17-32 bits
+typedef vluint64_t   QData;	///< Verilated pack data, 33-64 bits
+typedef vluint32_t   WData;	///< Verilated pack data, >64 bits, as an array
+//	float	     F		// No typedef needed; Verilator uses float
+//	double	     D		// No typedef needed; Verilator uses double
+//	string	     N		// No typedef needed; Verilator uses string
 
 typedef const WData* WDataInP;	///< Array input to a function
 typedef       WData* WDataOutP;	///< Array output from a function
 
+typedef void (*VerilatedVoidCb)(void);
+
 class SpTraceVcd;
 class SpTraceVcdCFile;
+class VerilatedScopeNameMap;
+class VerilatedVar;
+class VerilatedVarNameMap;
+class VerilatedVcd;
+class VerilatedVcdC;
+
+enum VerilatedVarType {
+    VLVT_UNKNOWN=0,
+    VLVT_PTR,		// Pointer to something
+    VLVT_UINT8,		// AKA CData
+    VLVT_UINT16,	// AKA SData
+    VLVT_UINT32,	// AKA IData
+    VLVT_UINT64,	// AKA QData
+    VLVT_WDATA,		// AKA WData
+    VLVT_STRING		// C++ string
+};
+
+enum VerilatedVarFlags {
+    VLVD_IN=1,		// == vpiInput
+    VLVD_OUT=2,		// == vpiOutput
+    VLVD_INOUT=3,	// == vpiInOut
+    VLVD_NODIR=5,	// == vpiNoDirection
+    VLVF_MASK_DIR=7,	// Bit mask for above directions
+    // Flags
+    VLVF_PUB_RD=(1<<8),	// Public readable
+    VLVF_PUB_RW=(1<<9)	// Public writable
+};
 
 //=========================================================================
 /// Base class for all Verilated module classes
@@ -60,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
 };
@@ -103,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="")
@@ -122,50 +166,164 @@ public:
 #ifndef VL_PRINTF
 # define VL_PRINTF printf	///< Print ala printf; may redefine if desired
 #endif
+#ifndef VL_VPRINTF
+# define VL_VPRINTF vprintf	///< Print ala vprintf; may redefine if desired
+#endif
+
+//===========================================================================
+/// Verilator symbol table base class
+
+class VerilatedSyms {
+    // VerilatedSyms base class exists just so symbol tables have a common pointer type
+};
 
 //===========================================================================
 /// Verilator global static information class
 
-struct Verilated {
-    // Extern Vars
-    // Below two are used as bool, but having as uint32_t avoids conversion time
-private:
-    static int		s_randReset;		///< Random reset: 0=all 0s, 1=all 1s, 2=random
-    static int		s_debug;		///< See accessors... only when VL_DEBUG set
-    static bool		s_calcUnusedSigs;	///< Waves file on, need all signals calculated
-    static bool		s_gotFinish;		///< A $finish statement executed
-    static bool		s_assertOn;		///< Assertions are enabled
+class VerilatedScope {
+    // Fastpath:
+    VerilatedSyms*	m_symsp;	///< Symbol table
+    void**		m_callbacksp;	///< Callback table pointer (Fastpath)
+    int			m_funcnumMax;	///< Maxium function number stored (Fastpath)
+    // 4 bytes padding (on -m64), for rent.
+    VerilatedVarNameMap* m_varsp;	///< Variable map
+    const char* 	m_namep;	///< Scope name (Slowpath)
+
+public:  // But internals only - called from VerilatedModule's
+    VerilatedScope();
+    ~VerilatedScope();
+    void configure(VerilatedSyms* symsp, const char* prefixp, const char* suffixp);
+    void exportInsert(int finalize, const char* namep, void* cb);
+    void varInsert(int finalize, const char* namep, void* datap,
+		   VerilatedVarType vltype, int vlflags, int dims, ...);
+    // ACCESSORS
+    const char* name() const { return m_namep; }
+    inline VerilatedSyms* symsp() const { return m_symsp; }
+    VerilatedVar* varFind(const char* namep) const;
+    VerilatedVarNameMap* varsp() const { return m_varsp; }
+    void* exportFindError(int funcnum) const;
+    void* exportFindNullError(int funcnum) const;
+    void scopeDump() const;
+    inline void* exportFind(int funcnum) const {
+	if (VL_UNLIKELY(!this)) return exportFindNullError(funcnum);
+	if (VL_LIKELY(funcnum < m_funcnumMax)) {
+	    // m_callbacksp must be declared, as Max'es are > 0
+	    return m_callbacksp[funcnum];
+	} else {
+	    return exportFindError(funcnum);
+	}
+    }
+};
+
+//===========================================================================
+/// Verilator global static information class
+
+class Verilated {
+    // MEMBERS
+    // Slow path variables
+    static VerilatedVoidCb  s_flushCb;		///< Flush callback function
+
+    static struct Serialized {   // All these members serialized/deserialized
+	// Slow path
+	int		s_randReset;		///< Random reset: 0=all 0s, 1=all 1s, 2=random
+	// Fast path
+	int		s_debug;		///< See accessors... only when VL_DEBUG set
+	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;
+
+    static VL_THREAD const VerilatedScope* t_dpiScopep;	///< DPI context scope
+    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
+
     /// Select initial value of otherwise uninitialized signals.
     ////
     /// 0 = Set to zeros
     /// 1 = Set all bits to one
     /// 2 = Randomize all bits
-    static void randReset(int val) { s_randReset=val; }
-    static int  randReset() { return s_randReset; }	///< Return randReset value
+    static void randReset(int val) { s_s.s_randReset=val; }
+    static int  randReset() { return s_s.s_randReset; }	///< Return randReset value
 
     /// Enable debug of internal verilated code
-    static inline void debug(int level) { s_debug = level; }
+    static inline void debug(int level) { s_s.s_debug = level; }
 #ifdef VL_DEBUG
-    static inline int  debug() { return s_debug; }	///< Return debug value
+    static inline int  debug() { return s_s.s_debug; }	///< Return debug value
 #else
     static inline int  debug() { return 0; }		///< Constant 0 debug, so C++'s optimizer rips up
 #endif
-    /// Internal: Create a new module name by concatenating two strings
-    static const char* catName(const char* n1, const char* n2); // Returns new'ed data
     /// Enable calculation of unused signals
-    static void calcUnusedSigs(bool flag) { s_calcUnusedSigs=flag; }
-    static bool calcUnusedSigs() { return s_calcUnusedSigs; }	///< Return calcUnusedSigs value
+    static void calcUnusedSigs(bool flag) { s_s.s_calcUnusedSigs=flag; }
+    static bool calcUnusedSigs() { return s_s.s_calcUnusedSigs; }	///< Return calcUnusedSigs value
     /// Did the simulation $finish?
-    static void gotFinish(bool flag) { s_gotFinish=flag; }
-    static bool gotFinish() { return s_gotFinish; }	///< Return if got a $finish
+    static void gotFinish(bool flag) { s_s.s_gotFinish=flag; }
+    static bool gotFinish() { return s_s.s_gotFinish; }	///< Return if got a $finish
     /// Allow traces to at some point be enabled (disables some optimizations)
     static void traceEverOn(bool flag) {
 	if (flag) { calcUnusedSigs(flag); }
     }
     /// Enable/disable assertions
-    static void assertOn(bool flag) { s_assertOn=flag; }
-    static bool assertOn() { return s_assertOn; }
+    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)(); }
+
+    /// 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.
+    static void scopesDump();
+
+    // METHODS - INTERNAL USE ONLY
+    // Internal: Create a new module name by concatenating two strings
+    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; }
+    static void dpiContext(const VerilatedScope* scopep, const char* filenamep, int lineno) {
+	t_dpiScopep=scopep; t_dpiFilename=filenamep; t_dpiLineno=lineno; }
+    static void dpiClearContext() { t_dpiScopep = NULL; }
+    static bool dpiInContext() { return t_dpiScopep != NULL; }
+    static const char* dpiFilenamep() { return t_dpiFilename; }
+    static int dpiLineno() { return t_dpiLineno; }
+    static int exportFuncNum(const char* namep);
+    static size_t serializedSize() { return sizeof(s_s); }
+    static void* serializedPtr() { return &s_s; }
 };
 
 //=========================================================================
@@ -196,11 +354,15 @@ extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp);	///< Zero reset a
 extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP lwp, WDataInP rwp, bool is_modulus);
 
 /// File I/O
-extern IData VL_FGETS_IXQ(int sbits, void* strgp, QData fpq);
+extern IData VL_FGETS_IXI(int obits, void* destp, IData fpi);
 
-extern QData VL_FOPEN_WI(int fnwords, WDataInP ofilename, IData mode);
-extern QData VL_FOPEN_QI(QData ofilename, IData mode);
-inline QData VL_FOPEN_II(IData ofilename, IData mode) { return VL_FOPEN_QI(ofilename,mode); }
+extern IData VL_FOPEN_S(const char* filenamep, const char* mode);
+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,
 			 WDataInP ofilename, void* memp, IData start, IData end);
@@ -211,13 +373,27 @@ inline void VL_READMEM_I(bool hex, int width, int depth, int array_lsb, int fnwo
     VL_READMEM_Q(hex, width,depth,array_lsb,fnwords, ofilename,memp,start,end); }
 
 extern void VL_WRITEF(const char* formatp, ...);
-extern void VL_FWRITEF(QData fpq, const char* formatp, ...);
+extern void VL_FWRITEF(IData fpi, const char* formatp, ...);
 
-extern IData VL_FSCANF_IX(QData fpq, const char* formatp, ...);
+extern IData VL_FSCANF_IX(IData fpi, const char* formatp, ...);
 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);
+extern IData VL_SYSTEM_IQ(QData lhs);
+inline IData VL_SYSTEM_II(IData lhs) { return VL_SYSTEM_IQ(lhs); }
+
+extern IData VL_TESTPLUSARGS_I(const char* formatp);
+extern IData VL_VALUEPLUSARGS_IW(int rbits, const char* prefixp, char fmt, WDataOutP rwp);
+extern const char* vl_mc_scan_plusargs(const char* prefixp);  // PLIish
+
 //=========================================================================
 // Base macros
 
@@ -228,16 +404,29 @@ extern IData VL_SSCANF_IWX(int lbits, WDataInP lwp, const char* formatp, ...);
 #define VL_BITISSETLIMIT_W(data,width,bit) (((bit)<(width)) && data[VL_BITWORD_I(bit)] & (VL_UL(1)<<VL_BITBIT_I(bit)))
 
 /// Create two 32-bit words from quadword
-#define VL_SET_WQ(owp,data)	{ owp[0]=(data); owp[1]=((data)>>VL_WORDSIZE); }
-#define VL_SET_WI(owp,data)	{ owp[0]=(data); owp[1]=0; }
+#define VL_SET_WQ(owp,data)	{ owp[0]=(IData)(data); owp[1]=(IData)((data)>>VL_WORDSIZE); }
+#define VL_SET_WI(owp,data)	{ owp[0]=(IData)(data); owp[1]=0; }
 #define VL_SET_QW(lwp)		( ((QData)(lwp[0])) | ((QData)(lwp[1])<<((QData)(VL_WORDSIZE)) ))
 #define _VL_SET_QII(ld,rd)      ( ((QData)(ld)<<VL_ULL(32)) | (QData)(rd) )
 
+/// Return FILE* from IData
+extern FILE*  VL_CVT_I_FP(IData lhs);
+
 // Use a union to avoid cast-to-different-size warnings
-/// Return FILE* from QData
-static inline FILE*  VL_CVT_Q_FP(QData lhs) { union { FILE* fp; QData q; } u; u.q=lhs; return u.fp; }
-/// Return QData from FILE*
-static inline QData  VL_CVT_FP_Q(FILE* fp) { union { FILE* fp; QData q; } u; u.q=0; u.fp=fp; return u.q; }
+/// Return void* from QData
+static inline void*  VL_CVT_Q_VP(QData lhs) { union { void* fp; QData q; } u; u.q=lhs; return u.fp; }
+/// Return QData from void*
+static inline QData  VL_CVT_VP_Q(void* fp) { union { void* fp; QData q; } u; u.q=0; u.fp=fp; return u.q; }
+/// Return double from QData (bits, not numerically)
+static inline double VL_CVT_D_Q(QData lhs) { union { double d; QData q; } u; u.q=lhs; return u.d; }
+/// Return QData from double (bits, not numerically)
+static inline QData  VL_CVT_Q_D(double lhs) { union { double d; QData q; } u; u.d=lhs; return u.q; }
+/// Return double from QData (numeric)
+static inline double VL_ITOR_D_I(IData lhs) { return ((double)((vlsint32_t)(lhs))); }
+/// Return QData from double (numeric)
+static inline IData  VL_RTOI_I_D(double lhs) { return ((vlsint32_t)(VL_TRUNC(lhs))); }
+/// Return QData from double (numeric)
+static inline IData  VL_RTOIROUND_I_D(double lhs) { return ((vlsint32_t)(VL_ROUND(lhs))); }
 
 // Sign extend such that if MSB set, we get ffff_ffff, else 0s
 // (Requires clean input)
@@ -251,26 +440,27 @@ static inline IData  VL_EXTENDSIGN_I(int lbits, IData lhs) { return (-((lhs)&(VL
 static inline QData  VL_EXTENDSIGN_Q(int lbits, QData lhs) { return (-((lhs)&(VL_ULL(1)<<(lbits-1)))); }
 
 // Debugging prints
-static inline void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp) {
-    printf("  Data: w%d: ", lbits);
-    for (int i=VL_WORDS_I(lbits)-1; i>=0; i--) { printf("%08x ",iwp[i]); }
-    printf("\n");
-}
+void _VL_DEBUG_PRINT_W(int lbits, WDataInP iwp);
 
 //=========================================================================
 // Pli macros
 
+#ifndef VL_TIME_PRECISION
+# define VL_TIME_PRECISION -12	///< Timescale units only for for VPI return - picoseconds
+#endif
 #ifndef VL_TIME_MULTIPLIER
 # define VL_TIME_MULTIPLIER 1
 #endif
 
 /// Return current simulation time
 #if defined(SYSTEMC_VERSION) && (SYSTEMC_VERSION>20011000)
-# define VL_TIME_I(ign) ((IData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
-# define VL_TIME_Q(ign) ((QData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
+# define VL_TIME_I() ((IData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
+# define VL_TIME_Q() ((QData)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
+# define VL_TIME_D() ((double)(sc_time_stamp().to_default_time_units()*VL_TIME_MULTIPLIER))
 #else
-# define VL_TIME_I(ign) ((IData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
-# define VL_TIME_Q(ign) ((QData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
+# define VL_TIME_I() ((IData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
+# define VL_TIME_Q() ((QData)(sc_time_stamp()*VL_TIME_MULTIPLIER))
+# define VL_TIME_D() ((double)(sc_time_stamp()*VL_TIME_MULTIPLIER))
 extern double sc_time_stamp();
 #endif
 
@@ -370,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()); }
@@ -387,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) { \
@@ -409,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
 
@@ -537,7 +756,7 @@ static inline IData VL_REDXOR_64(QData r) {
     return __builtin_parityll(r);
 #else
     r=(r^(r>>1)); r=(r^(r>>2)); r=(r^(r>>4)); r=(r^(r>>8)); r=(r^(r>>16)); r=(r^(r>>32));
-    return r;
+    return (IData)r;
 #endif
 }
 static inline IData VL_REDXOR_W(int words, WDataInP lwp) {
@@ -556,7 +775,7 @@ static inline IData VL_COUNTONES_I(IData lhs) {
     return r;
 }
 static inline IData VL_COUNTONES_Q(QData lhs) {
-    return VL_COUNTONES_I(lhs) + VL_COUNTONES_I(lhs>>32);
+    return VL_COUNTONES_I((IData)lhs) + VL_COUNTONES_I((IData)(lhs>>32));
 }
 static inline IData VL_COUNTONES_W(int words, WDataInP lwp) {
     IData r = 0;
@@ -602,14 +821,14 @@ static inline IData VL_ONEHOT0_W(int words, WDataInP lwp) {
 
 static inline IData VL_CLOG2_I(IData lhs) {
     // There are faster algorithms, or fls GCC4 builtins, but rarely used
-    if (!lhs) return 0;
+    if (VL_UNLIKELY(!lhs)) return 0;
     lhs--;
     int shifts=0;
     for (; lhs!=0; shifts++) lhs = lhs >> 1;
     return shifts;
 }
 static inline IData VL_CLOG2_Q(QData lhs) {
-    if (!lhs) return 0;
+    if (VL_UNLIKELY(!lhs)) return 0;
     lhs--;
     int shifts=0;
     for (; lhs!=0; shifts++) lhs = lhs >> VL_ULL(1);
@@ -660,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);
 }
@@ -803,7 +1022,7 @@ static inline WDataOutP VL_ADD_W(int words, WDataOutP owp,WDataInP lwp,WDataInP
 static inline WDataOutP VL_SUB_W(int words, WDataOutP owp,WDataInP lwp,WDataInP rwp){
     QData carry = 0;
     for (int i=0; i<words; i++) {
-	carry = carry + (QData)(lwp[i]) + (QData)(~rwp[i]);
+	carry = carry + (QData)(lwp[i]) + (QData)(IData)(~rwp[i]);
 	if (i==0) carry++;  // Negation of temp2
 	owp[i] = (carry & VL_ULL(0xffffffff));
 	carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff);
@@ -811,19 +1030,16 @@ static inline WDataOutP VL_SUB_W(int words, WDataOutP owp,WDataInP lwp,WDataInP
     return(owp);
 }
 
-// Optimization bug in GCC 2.96 and presumably all-pre GCC 3 versions need this workaround
-#if 1 //defined(__GNUC__) && __GNUC__ < 3
-static inline IData  VL_UNARYMIN_I(IData data) { return -data; }
-static inline QData  VL_UNARYMIN_Q(QData data) { return -data; }
-#else
-# define VL_UNARYMIN_I(IData data) (-(data))
-# define VL_UNARYMIN_Q(QData data) (-(data))
-#endif
+// Optimization bug in GCC 2.96 and presumably all-pre GCC 3 versions need this workaround,
+// we can't just
+//# define VL_NEGATE_I(data) (-(data))
+static inline IData  VL_NEGATE_I(IData data) { return -data; }
+static inline QData  VL_NEGATE_Q(QData data) { return -data; }
 
-static inline WDataOutP VL_UNARYMIN_W(int words, WDataOutP owp,WDataInP lwp){
+static inline WDataOutP VL_NEGATE_W(int words, WDataOutP owp,WDataInP lwp){
     QData carry = 0;
     for (int i=0; i<words; i++) {
-	carry = carry + (QData)(~lwp[i]);
+	carry = carry + (QData)(IData)(~lwp[i]);
 	if (i==0) carry++;  // Negation of temp2
 	owp[i] = (carry & VL_ULL(0xffffffff));
 	carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff);
@@ -867,21 +1083,21 @@ static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lw
     IData lneg = VL_SIGN_I(lbits,lwp[words-1]);
     if (lneg) { // Negate lhs
 	lwusp = lwstore;
-	VL_UNARYMIN_W(words, lwstore, lwp);
+	VL_NEGATE_W(words, lwstore, lwp);
 	lwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
     }
     IData rneg = VL_SIGN_I(lbits,rwp[words-1]);
     if (rneg) { // Negate rhs
 	rwusp = rwstore;
-	VL_UNARYMIN_W(words, rwstore, rwp);
+	VL_NEGATE_W(words, rwstore, rwp);
 	rwstore[words-1] &= VL_MASK_I(lbits);  // Clean it
     }
     VL_MUL_W(words,owp,lwusp,rwusp);
     owp[words-1] &= VL_MASK_I(lbits);  // Clean.  Note it's ok for the multiply to overflow into the sign bit
-    if ((lneg ^ rneg) & 1) {      // Negate output  (not using UNARYMIN, as owp==lwp)
+    if ((lneg ^ rneg) & 1) {      // Negate output  (not using NEGATE, as owp==lwp)
 	QData carry = 0;
 	for (int i=0; i<words; i++) {
-	    carry = carry + (QData)(~owp[i]);
+	    carry = carry + (QData)(IData)(~owp[i]);
 	    if (i==0) carry++;  // Negation of temp2
 	    owp[i] = (carry & VL_ULL(0xffffffff));
 	    carry = (carry >> VL_ULL(32)) & VL_ULL(0xffffffff);
@@ -893,25 +1109,25 @@ static inline WDataOutP VL_MULS_WWW(int,int lbits,int, WDataOutP owp,WDataInP lw
 }
 
 static inline IData VL_DIVS_III(int lbits, IData lhs,IData rhs) {
-    if (rhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 0;
     vlsint32_t lhs_signed = VL_EXTENDS_II(32, lbits, lhs);
     vlsint32_t rhs_signed = VL_EXTENDS_II(32, lbits, rhs);
     return lhs_signed / rhs_signed;
 }
 static inline QData VL_DIVS_QQQ(int lbits, QData lhs,QData rhs) {
-    if (rhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 0;
     vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);
     vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);
     return lhs_signed / rhs_signed;
 }
 static inline IData VL_MODDIVS_III(int lbits, IData lhs,IData rhs) {
-    if (rhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 0;
     vlsint32_t lhs_signed = VL_EXTENDS_II(32, lbits, lhs);
     vlsint32_t rhs_signed = VL_EXTENDS_II(32, lbits, rhs);
     return lhs_signed % rhs_signed;
 }
 static inline QData VL_MODDIVS_QQQ(int lbits, QData lhs,QData rhs) {
-    if (rhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 0;
     vlsint64_t lhs_signed = VL_EXTENDS_QQ(64, lbits, lhs);
     vlsint64_t rhs_signed = VL_EXTENDS_QQ(64, lbits, rhs);
     return lhs_signed % rhs_signed;
@@ -921,16 +1137,18 @@ 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;
-    if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), lwstore, lwp)); }
-    if (rsign) { rtup = _VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), rwstore, rwp)); }
+    if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), lwstore, lwp)); }
+    if (rsign) { rtup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), rwstore, rwp)); }
     if ((lsign && !rsign) || (!lsign && rsign)) {
 	IData qNoSign[VL_MULS_MAX_WORDS];
 	VL_DIV_WWW(lbits,qNoSign,ltup,rtup);
-	_VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), owp, qNoSign));
+	_VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), owp, qNoSign));
 	return owp;
     } else {
 	return VL_DIV_WWW(lbits,owp,ltup,rtup);
@@ -940,24 +1158,29 @@ 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;
-    if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), lwstore, lwp)); }
-    if (rsign) { rtup = _VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), rwstore, rwp)); }
+    if (lsign) { ltup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), lwstore, lwp)); }
+    if (rsign) { rtup = _VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), rwstore, rwp)); }
     if (lsign) {  // Only dividend sign matters for modulus
 	IData qNoSign[VL_MULS_MAX_WORDS];
 	VL_MODDIV_WWW(lbits,qNoSign,ltup,rtup);
-	_VL_CLEAN_INPLACE_W(lbits, VL_UNARYMIN_W(VL_WORDS_I(lbits), owp, qNoSign));
+	_VL_CLEAN_INPLACE_W(lbits, VL_NEGATE_W(VL_WORDS_I(lbits), owp, qNoSign));
 	return owp;
     } else {
 	return VL_MODDIV_WWW(lbits,owp,ltup,rtup);
     }
 }
 
+#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 (lhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 1;
+    if (VL_UNLIKELY(lhs==0)) return 0;
     IData power = lhs;
     IData out = 1;
     for (int i=0; i<rbits; i++) {
@@ -966,11 +1189,9 @@ 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 (lhs==0) return 0;
+    if (VL_UNLIKELY(rhs==0)) return 1;
+    if (VL_UNLIKELY(lhs==0)) return 0;
     QData power = lhs;
     QData out = VL_ULL(1);
     for (int i=0; i<rbits; i++) {
@@ -980,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
 
@@ -1120,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.
@@ -1206,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;
@@ -1224,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);
@@ -1248,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)
@@ -1285,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);
 }
@@ -1300,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 ((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 {
@@ -1316,7 +1690,7 @@ static inline IData VL_BITSEL_IWII(int, int lbits, int, int, WDataInP lwp, IData
 
 static inline IData VL_SEL_IWII(int, int lbits, int, int, WDataInP lwp, IData lsb, IData width) {
     int msb = lsb+width-1;
-    if (msb>lbits) {
+    if (VL_UNLIKELY(msb>lbits)) {
 	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
     } else if (VL_BITWORD_I(msb)==VL_BITWORD_I((int)lsb)) {
 	return (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb));
@@ -1330,7 +1704,7 @@ static inline IData VL_SEL_IWII(int, int lbits, int, int, WDataInP lwp, IData ls
 
 static inline QData VL_SEL_QWII(int, int lbits, int, int, WDataInP lwp, IData lsb, IData width) {
     int msb = lsb+width-1;
-    if (msb>lbits) {
+    if (VL_UNLIKELY(msb>lbits)) {
 	return ~0; // Spec says you can go outside the range of a array.  Don't coredump if so.
     } else if (VL_BITWORD_I(msb)==VL_BITWORD_I((int)lsb)) {
 	return (lwp[VL_BITWORD_I(lsb)]>>VL_BITBIT_I(lsb));
@@ -1352,7 +1726,7 @@ static inline QData VL_SEL_QWII(int, int lbits, int, int, WDataInP lwp, IData ls
 static inline WDataOutP VL_SEL_WWII(int obits,int lbits,int,int,WDataOutP owp,WDataInP lwp, IData lsb, IData width) {
     int msb = lsb+width-1;
     int word_shift = VL_BITWORD_I(lsb);
-    if (msb>lbits) { // Outside bounds,
+    if (VL_UNLIKELY(msb>lbits)) { // Outside bounds,
 	for (int i=0; i<VL_WORDS_I(obits)-1; i++) owp[i] = ~0;
 	owp[VL_WORDS_I(obits)-1] = VL_MASK_I(obits);
     } else if (VL_BITBIT_I(lsb)==0) {
@@ -1420,6 +1794,26 @@ static inline WDataOutP VL_COND_WIWW(int obits, int, int, int,
     return(owp);
 }
 
+//======================================================================
+// System Functions
+
+inline IData VL_VALUEPLUSARGS_IQ(int rbits, const char* prefixp, char fmt, QData& ldr) {
+    WData wd[2]; IData v=VL_VALUEPLUSARGS_IW(rbits,prefixp,fmt,wd); if (v) ldr=VL_SET_QW(wd);
+    return v;
+}
+inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, CData& ldr) {
+    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(CData)qd;
+    return v;
+}
+inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, SData& ldr) {
+    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(SData)qd;
+    return v;
+}
+inline IData VL_VALUEPLUSARGS_II(int rbits, const char* prefixp, char fmt, IData& ldr) {
+    QData qd; IData v=VL_VALUEPLUSARGS_IQ(rbits,prefixp,fmt,qd); if (v) ldr=(IData)qd;
+    return v;
+}
+
 //======================================================================
 // Constification
 
@@ -1482,6 +1876,6 @@ static inline WDataOutP VL_CONST_W_9X(int obits, WDataOutP o,
 
 #undef _END
 
-// Debugging
+//======================================================================
 
 #endif /*_VERILATED_H_*/

include/verilated.mk.in

@@ -2,7 +2,7 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2009 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.
 ######################################################################
@@ -13,11 +13,26 @@ LINK = @CXX@
 AR     = ar
 RANLIB = ranlib
 
+CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
+CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
+
+# Compiler flags to use to turn off unused and generated code warnings, such as -Wno-div-by-zero
+CFG_CXXFLAGS_NO_UNUSED = @CFG_CXXFLAGS_NO_UNUSED@
+
 ######################################################################
 # 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
+
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+endif
 
 ######################################################################
 # C Preprocessor flags
@@ -26,24 +41,22 @@ SP_INCLUDER     = $(PERL) $(VERILATOR_ROOT)/bin/verilator_includer
 VK_CPPFLAGS_ALWAYS += \
 		-MMD \
 		-I$(VERILATOR_ROOT)/include \
+		-I$(VERILATOR_ROOT)/include/vltstd \
 		-DVL_PRINTF=printf \
 		-DVM_TRACE=$(VM_TRACE) \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
+		$(CFG_CXXFLAGS_NO_UNUSED) \
 
-ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
 VK_CPPFLAGS_WALL += -Wall \
-		-Wno-char-subscripts \
-		-Wno-sign-compare \
-		-Wno-unused-parameter \
-		-Wno-unused-variable \
-		-Wno-uninitialized \
 		-Werror
 endif
 
-CPPFLAGS += -I. $(VK_CPPFLAGS_ALWAYS) $(VK_CPPFLAGS_WALL)
+CPPFLAGS += -I. $(VK_CPPFLAGS_WALL) $(VK_CPPFLAGS_ALWAYS)
 
 VPATH += ..
 VPATH += $(VERILATOR_ROOT)/include
+VPATH += $(VERILATOR_ROOT)/include/vltstd
 
 #OPT = -ggdb -DPRINTINITSTR -DDETECTCHANGE
 #OPT = -ggdb -DPRINTINITSTR
@@ -56,6 +69,12 @@ LDFLAGS  += $(M32)
 # These aren't ever set by Verilator, so users are free to override them.
 CPPFLAGS += $(USER_CPPFLAGS)
 LDFLAGS  += $(USER_LDFLAGS)
+LDLIBS   += $(USER_LDLIBS)
+
+# Add flags from -CFLAGS and -LDFLAGS on Verilator command line
+CPPFLAGS += $(VM_USER_CFLAGS)
+LDFLAGS  += $(VM_USER_LDFLAGS)
+LDLIBS   += $(VM_USER_LDLIBS)
 
 # See the benchmarking section of bin/verilator.
 # Support class optimizations.  This includes the tracing and symbol table.
@@ -76,10 +95,10 @@ VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)
 ##### SystemC or SystemPerl builds
 
 ifeq ($(VM_SP_OR_SC),1)
-  CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC)/include
-  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC)/lib-$(VM_SC_TARGET_ARCH)
+  CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
+  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
   SC_LIBS   = -lsystemc
- ifneq ($(wildcard $(SYSTEMC)/lib-$(VM_SC_TARGET_ARCH)/*numeric_bit*),)
+ ifneq ($(wildcard $(SYSTEMC_LIBDIR)/*numeric_bit*),)
   # Systemc 1.2.1beta
   SC_LIBS   += -lnumeric_bit -lqt
  endif
@@ -109,10 +128,6 @@ endif
 
 ifeq ($(VM_SC),1)
   LIBS   += -lm -lstdc++
- ifeq ($(VM_TRACE),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
- endif
 endif
 
 #######################################################################
@@ -120,10 +135,6 @@ endif
 
 ifeq ($(VM_PCLI),1)
   LIBS   += -lm -lstdc++
- ifeq ($(VM_TRACE),1)
-  CPPFLAGS += -I$(SYSTEMPERL_INCLUDE)
-  VPATH    +=   $(SYSTEMPERL_INCLUDE)
- endif
 endif
 
 #######################################################################
@@ -136,15 +147,17 @@ VK_SUPPORT_CPP = $(addsuffix .cpp, $(VM_SUPPORT))
 
 VK_USER_OBJS   = $(addsuffix .o, $(VM_USER_CLASSES))
 
+VK_GLOBAL_OBJS = $(addsuffix .o, $(VM_GLOBAL_FAST) $(VM_GLOBAL_SLOW))
+
 ifneq ($(VM_PARALLEL_BUILDS),1)
   # Fast building, all .cpp's in one fell swoop
   # This saves about 5 sec per module, but can be slower if only a little changes
   VK_OBJS += $(VM_PREFIX)__ALLcls.o   $(VM_PREFIX)__ALLsup.o
   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))
@@ -171,13 +184,16 @@ $(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
 ######################################################################
 ### Debugging
 
-debug::
+debug-make::
 	@echo
 	@echo VM_PREFIX:  $(VM_PREFIX)
 	@echo VM_CLASSES_FAST: $(VM_CLASSES_FAST)
 	@echo VM_CLASSES_SLOW: $(VM_CLASSES_SLOW)
 	@echo VM_SUPPORT_FAST: $(VM_SUPPORT_FAST)
 	@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

@@ -1,11 +1,10 @@
-// -*- C++ -*-
 //*************************************************************************
 //
 // Code available from: http://www.veripool.org/verilator
 //
 //*************************************************************************
 //
-// Copyright 2003-2009 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,15 +22,11 @@
  `define _VERILATED_V_ 1
 
  // Hide verilator pragmas from other tools
- `ifdef verilator `else
+ `ifdef VERILATOR `else
   `define coverage_block_off
  `endif
 
- // Hide file descriptor difference
- `ifdef verilator
-  `define verilator_file_descriptor reg [63:0]
- `else
-  `define verilator_file_descriptor integer
- `endif
+ // Hide file descriptor difference - deprecated - for older versions
+ `define verilator_file_descriptor integer
 
 `endif // guard

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

@@ -0,0 +1,303 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// 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.
+//
+// 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: DPI implementation code
+///
+///	This file must be compiled and linked against all objects
+///	created from Verilator or called by Verilator that use the DPI.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//=========================================================================
+
+#define _VERILATED_DPI_CPP_
+#include "verilatedos.h"
+#include "verilated_dpi.h"
+#include "verilated_imp.h"
+
+// On MSVC++ we need svdpi.h to declare exports, not imports
+#define DPI_PROTOTYPES
+#define XXTERN DPI_EXTERN DPI_DLLESPEC
+#define EETERN DPI_EXTERN DPI_DLLESPEC
+
+#include "vltstd/svdpi.h"
+
+//======================================================================
+// Internal macros
+
+// Not supported yet
+#define _VL_SVDPI_UNIMP() \
+    vl_fatal(__FILE__,__LINE__,"",(string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())
+
+// Function requires a "context" in the import declaration
+#define _VL_SVDPI_CONTEXT_WARN() \
+    VL_PRINTF("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");
+
+//======================================================================
+//======================================================================
+//======================================================================
+// DPI ROUTINES
+
+const char* svDpiVersion() {
+    return "1800-2005";
+}
+
+//======================================================================
+// Bit-select utility functions.
+
+svBit svGetBitselBit(const svBitVecVal* s, int i) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+svLogic svGetBitselLogic(const svLogicVecVal* s, int i) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+
+void svPutBitselBit(svBitVecVal* d, int i, svBit s) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitselLogic(svLogicVecVal* d, int i, svLogic s) {
+    _VL_SVDPI_UNIMP();
+}
+
+void svGetPartselBit(svBitVecVal* d, const svBitVecVal* s, int i, int w) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetPartselLogic(svLogicVecVal* d, const svLogicVecVal* s, int i, int w) {
+    _VL_SVDPI_UNIMP();
+}
+
+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) {
+    _VL_SVDPI_UNIMP();
+}
+
+//======================================================================
+// Open array querying functions
+
+int svLeft(const svOpenArrayHandle h, int d) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+int svRight(const svOpenArrayHandle h, int d) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+int svLow(const svOpenArrayHandle h, int d) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+int svHigh(const svOpenArrayHandle h, int d) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+int svIncrement(const svOpenArrayHandle h, int d) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+int svDimensions(const svOpenArrayHandle h) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+
+void *svGetArrayPtr(const svOpenArrayHandle) {
+    _VL_SVDPI_UNIMP(); return NULL;
+}
+
+int svSizeOfArray(const svOpenArrayHandle) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+
+void *svGetArrElemPtr(const svOpenArrayHandle, int indx1, ...) {
+    _VL_SVDPI_UNIMP(); return NULL;
+}
+void *svGetArrElemPtr1(const svOpenArrayHandle, int indx1) {
+    _VL_SVDPI_UNIMP(); return NULL;
+}
+void *svGetArrElemPtr2(const svOpenArrayHandle, int indx1, int indx2) {
+    _VL_SVDPI_UNIMP(); return NULL;
+}
+void *svGetArrElemPtr3(const svOpenArrayHandle, int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP(); return NULL;
+}
+
+//======================================================================
+// s=source, d=destination
+// From user space into simulator storage
+
+void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+			   int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem1VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+			    int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem2VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+			    int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+			    int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+			     int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem1VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+			      int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem2VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+			      int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+			      int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+
+//======================================================================
+// From simulator storage into user space
+
+void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
+			   int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetBitArrElem1VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+			    int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetBitArrElem2VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+			    int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+			    int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+			     int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetLogicArrElem1VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+			      int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+			      int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+			      int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+
+svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+svBit svGetBitArrElem1(const svOpenArrayHandle s, int indx1) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+svBit svGetBitArrElem2(const svOpenArrayHandle s, int indx1, int indx2) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP(); return 0;
+}
+svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
+    _VL_SVDPI_UNIMP(); return sv_x;
+}
+svLogic svGetLogicArrElem1(const svOpenArrayHandle s, int indx1) {
+    _VL_SVDPI_UNIMP(); return sv_x;
+}
+svLogic svGetLogicArrElem2(const svOpenArrayHandle s, int indx1, int indx2) {
+    _VL_SVDPI_UNIMP(); return sv_x;
+}
+svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP(); return sv_x;
+}
+void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem1(const svOpenArrayHandle d, svBit value, int indx1) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem2(const svOpenArrayHandle d, svBit value, int indx1, int indx2) {
+    _VL_SVDPI_UNIMP();
+}
+void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1, int indx2, int indx3) {
+    _VL_SVDPI_UNIMP();
+}
+
+//======================================================================
+// Functions for working with DPI context
+
+svScope svGetScope() {
+    if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return NULL; }
+    return (svScope)Verilated::dpiScope();
+}
+
+svScope svSetScope(const svScope scope) {
+    const VerilatedScope* prevScopep = Verilated::dpiScope();
+    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    Verilated::dpiScope(vscopep);
+    return (svScope)prevScopep;
+}
+
+const char* svGetNameFromScope(const svScope scope) {
+    const VerilatedScope* vscopep = (const VerilatedScope*)(scope);
+    return vscopep->name();
+}
+
+svScope svGetScopeFromName(const char* scopeName) {
+    return (svScope)VerilatedImp::scopeFind(scopeName);
+}
+
+int svPutUserData(const svScope scope, void *userKey, void* userData) {
+    VerilatedImp::userInsert(scope,userKey,userData);
+    return 0;
+}
+
+void* svGetUserData(const svScope scope, void* userKey) {
+    return VerilatedImp::userFind(scope,userKey);
+}
+
+int svGetCallerInfo(const char** fileNamepp, int *lineNumberp) {
+    if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return false; }
+    if (VL_LIKELY(fileNamepp)) *fileNamepp = Verilated::dpiFilenamep();  // thread local
+    if (VL_LIKELY(lineNumberp)) *lineNumberp = Verilated::dpiLineno();  // thread local
+    return true;
+}
+
+//======================================================================
+// Disables
+
+int svIsDisabledState() {
+    return 0; // Disables not implemented
+}
+
+void svAckDisabledState() {
+    // Disables not implemented
+}

include/verilated_dpi.h

@@ -0,0 +1,64 @@
+// -*- 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: Common include for all Verilated C files that use DPI
+///
+///	This file is included automatically by Verilator at the top of
+///	all C++ files it generates where DPI is used.  It contains
+///	DPI interface functions required by the Verilated code.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+#ifndef _VERILATED_DPI_H_
+#define _VERILATED_DPI_H_ 1 ///< Header Guard
+
+#include "verilated.h"   // Presumed done by caller
+#include "svdpi.h"
+
+//===================================================================
+// SETTING OPERATORS
+
+/// Return svBitVecVal from WData
+static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, svBitVecVal* lwp) {
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
+}
+static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) {
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i<words-1; i++) owp[i]=lwp[i];
+    owp[words-1] = lwp[words-1] & VL_MASK_I(obits);
+}
+static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, svLogicVecVal* lwp) {
+    // Note we ignore X/Z in svLogicVecVal
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i<words-1; i++) owp[i]=lwp[i].aval;
+    owp[words-1] = lwp[words-1].aval & VL_MASK_I(obits);
+}
+static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) {
+    // Note we don't create X/Z in svLogicVecVal
+    int words = VL_WORDS_I(obits);
+    for (int i=0; i<words; i++) owp[i].bval=0;
+    for (int i=0; i<words-1; i++) owp[i].aval=lwp[i];
+    owp[words-1].aval = lwp[words-1] & VL_MASK_I(obits);
+}
+
+//======================================================================
+
+#endif // _VERILATED_DPI_H_

include/verilated_heavy.h

@@ -0,0 +1,68 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// 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.
+//
+// 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: String include for all Verilated C files
+///
+///	This file is included automatically by Verilator at the top of
+///	all C++ files it generates.  It is used when strings or other
+///	heavyweight types are required; these contents are not part of
+///	verilated.h to save compile time when such types aren't used.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+#ifndef _VERILATED_HEAVY_H_
+#define _VERILATED_HEAVY_H_ 1 ///< Header Guard
+
+#include "verilated.h"
+
+#include <string>
+
+//======================================================================
+// Conversion functions
+
+extern string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp);
+inline string VL_CVT_PACK_STR_NQ(QData lhs) {
+    IData lw[2];  VL_SET_WQ(lw, lhs);
+    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

@@ -0,0 +1,257 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// 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.
+//
+// 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: Implementation Header, only for verilated.cpp internals.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//=========================================================================
+
+
+#ifndef _VERILATED_IMP_H_
+#define _VERILATED_IMP_H_ 1 ///< Header Guard
+
+#if !defined(_VERILATED_CPP_) && !defined(_VERILATED_DPI_CPP_)
+# error "verilated_imp.h only to be included by verilated*.cpp internals"
+#endif
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_heavy.h"
+#include "verilated_syms.h"
+
+#include <map>
+#include <vector>
+#include <deque>
+#include <string>
+
+class VerilatedScope;
+
+//======================================================================
+// Types
+
+class VerilatedImp {
+    // Whole class is internal use only - Global information shared between verilated*.cpp files.
+
+    // TYPES
+    typedef vector<string> ArgVec;
+    typedef map<pair<const void*,void*>,void*> UserMap;
+    typedef map<const char*, int, VerilatedCStrCmp>  ExportNameMap;
+
+    // MEMBERS
+    static VerilatedImp	s_s;		///< Static Singleton; One and only static this
+
+    // Nothing here is save-restored; users expected to re-register appropriately
+
+    ArgVec		m_argVec;	///< Argument list (NOT save-restored, may want different results)
+    bool		m_argVecLoaded;	///< Ever loaded argument list
+    UserMap	 	m_userMap;	///< Map of <(scope,userkey), userData>
+    VerilatedScopeNameMap	m_nameMap;	///< Map of <scope_name, scope pointer>
+    // Slow - somewhat static:
+    ExportNameMap	m_exportMap;	///< Map of <export_func_proto, func number>
+    int			m_exportNext;	///< Next export funcnum
+
+    // File I/O
+    vector<FILE*>	m_fdps;		///< File descriptors
+    deque<IData>	m_fdFree;	///< List of free descriptors (SLOW - FOPEN/CLOSE only)
+
+public: // But only for verilated*.cpp
+    // CONSTRUCTORS
+    VerilatedImp() : m_argVecLoaded(false), m_exportNext(0) {
+	m_fdps.resize(3);
+	m_fdps[0] = stdin;
+	m_fdps[1] = stdout;
+	m_fdps[2] = stderr;
+    }
+    ~VerilatedImp() {}
+    static void internalsDump() {
+	VL_PRINTF("internalsDump:\n");
+	VL_PRINTF("  Argv:");
+	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
+	    VL_PRINTF(" %s",it->c_str());
+	}
+	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) {
+	s_s.m_argVec.clear();
+	for (int i=0; i<argc; i++) s_s.m_argVec.push_back(argv[i]);
+	s_s.m_argVecLoaded = true; // Can't just test later for empty vector, no arguments is ok
+    }
+    static string argPlusMatch(const char* prefixp) {
+	// Note prefixp does not include the leading "+"
+	size_t len = strlen(prefixp);
+	if (VL_UNLIKELY(!s_s.m_argVecLoaded)) {
+	    s_s.m_argVecLoaded = true;  // Complain only once
+	    vl_fatal("unknown",0,"",
+		     "%Error: Verilog called $test$plusargs or $value$plusargs without"
+		     " testbench C first calling Verilated::commandArgs(argc,argv).");
+	}
+	for (ArgVec::iterator it=s_s.m_argVec.begin(); it!=s_s.m_argVec.end(); ++it) {
+	    if ((*it)[0]=='+') {
+		if (0==strncmp(prefixp, it->c_str()+1, len)) return *it;
+	    }
+	}
+	return "";
+    }
+
+    // METHODS - user scope tracking
+    // We implement this as a single large map instead of one map per scope
+    // There's often many more scopes than userdata's and thus having a ~48byte
+    // per map overhead * N scopes would take much more space and cache thrashing.
+    static inline void userInsert(const void* scopep, void* userKey, void* userData) {
+	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
+	if (it != s_s.m_userMap.end()) it->second = userData;
+	// When we support VL_THREADs, we need a lock around this insert, as it's runtime
+	else s_s.m_userMap.insert(it, make_pair(make_pair(scopep,userKey),userData));
+    }
+    static inline void* userFind(const void* scopep, void* userKey) {
+	UserMap::iterator it=s_s.m_userMap.find(make_pair(scopep,userKey));
+	if (VL_LIKELY(it != s_s.m_userMap.end())) return it->second;
+	else return NULL;
+    }
+private:
+    /// Symbol table destruction cleans up the entries for each scope.
+    static void userEraseScope(const VerilatedScope* scopep) {
+	// Slow ok - called once/scope on destruction, so we simply iterate.
+	for (UserMap::iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ) {
+	    if (it->first.first == scopep) {
+		s_s.m_userMap.erase(it++);
+	    } else {
+		++it;
+	    }
+	}
+    }
+    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
+	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) {
+	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);
+	VerilatedScopeNameMap::iterator it=s_s.m_nameMap.find(scopep->name());
+	if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
+    }
+    static void scopesDump() {
+	VL_PRINTF("  scopesDump:\n");
+	for (VerilatedScopeNameMap::iterator it=s_s.m_nameMap.begin(); it!=s_s.m_nameMap.end(); ++it) {
+	    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
+
+    // Each function prototype is converted to a function number which we
+    // then use to index a 2D table also indexed by scope number, because we
+    // can't know at Verilation time what scopes will exist in other modules
+    // in the design that also happen to have our same callback function.
+    // Rather than a 2D map, the integer scheme saves 500ish ns on a likely
+    // miss at the cost of a multiply, and all lookups move to slowpath.
+    static int exportInsert(const char* namep) {
+	// Slow ok - called once/function at creation
+	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
+	if (it == s_s.m_exportMap.end()) {
+	    s_s.m_exportMap.insert(it, make_pair(namep, s_s.m_exportNext++));
+	    return s_s.m_exportNext++;
+	} else {
+	    return it->second;
+	}
+    }
+    static int exportFind(const char* namep) {
+	ExportNameMap::iterator it=s_s.m_exportMap.find(namep);
+	if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
+	string msg = (string("%Error: Testbench C called ")+namep
+		      +" but no such DPI export function name exists in ANY model");
+	vl_fatal("unknown",0,"", msg.c_str());
+	return -1;
+    }
+    static const char* exportName(int funcnum) {
+	// Slowpath; find name for given export; errors only so no map to reverse-map it
+	for (ExportNameMap::iterator it=s_s.m_exportMap.begin(); it!=s_s.m_exportMap.end(); ++it) {
+	    if (it->second == funcnum) return it->first;
+	}
+	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.
+
+public: // But only for verilated*.cpp
+    // METHODS - file IO
+    static IData fdNew(FILE* fp) {
+	if (VL_UNLIKELY(!fp)) return 0;
+	// Bit 31 indicates it's a descriptor not a MCD
+	if (s_s.m_fdFree.empty()) {
+	    // Need to create more space in m_fdps and m_fdFree
+	    size_t start = s_s.m_fdps.size();
+	    s_s.m_fdps.resize(start*2);
+	    for (size_t i=start; i<start*2; i++) s_s.m_fdFree.push_back((IData)i);
+	}
+	IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
+	s_s.m_fdps[idx] = fp;
+	return (idx | (1UL<<31));  // bit 31 indicates not MCD
+    }
+    static void fdDelete(IData fdi) {
+	IData idx = VL_MASK_I(31) & fdi;
+	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return;
+	if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
+	s_s.m_fdps[idx] = NULL;
+	s_s.m_fdFree.push_back(idx);
+    }
+    static inline FILE* fdToFp(IData fdi) {
+	IData idx = VL_MASK_I(31) & fdi;
+	if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return NULL;
+	return s_s.m_fdps[idx];
+    }
+};
+
+#endif  // Guard

include/verilated_save.cpp

@@ -0,0 +1,234 @@
+// -*- 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 C++ Tracing in VCD Format
+///
+//=============================================================================
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_save.h"
+
+#include <fcntl.h>
+#include <cerrno>
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
+#ifndef O_LARGEFILE // For example on WIN32
+# define O_LARGEFILE 0
+#endif
+#ifndef O_NONBLOCK
+# define O_NONBLOCK 0
+#endif
+
+// CONSTANTS
+static const char* VLTSAVE_HEADER_STR = "verilatorsave01\n";	///< Value of first bytes of each file
+static const char* VLTSAVE_TRAILER_STR = "vltsaved";	///< Value of last bytes of each file
+
+//=============================================================================
+//=============================================================================
+//=============================================================================
+// Searalization
+
+bool VerilatedDeserialize::readDiffers (const void* __restrict datap, size_t size) {
+    bufferCheck();
+    const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
+    vluint8_t miss = 0;
+    while (size--) {
+	miss |= (*dp++ ^ *m_cp++);
+    }
+    return (miss!=0);
+}
+
+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(fn.c_str(), 0, "", msg.c_str());
+	close();
+    }
+    return *this;  // For function chaining
+}
+
+void VerilatedSerialize::header() {
+    VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
+    assert((strlen(VLTSAVE_HEADER_STR) & 7) == 0);  // Keep aligned
+    os.write(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR));
+
+    // Verilated doesn't do it itself, as if we're not using save/restore
+    // it doesn't need to compile this stuff in
+    os.write(Verilated::serializedPtr(), Verilated::serializedSize());
+}
+
+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(fn.c_str(), 0, "", msg.c_str());
+	close();
+    }
+    os.read(Verilated::serializedPtr(), Verilated::serializedSize());
+}
+
+void VerilatedSerialize::trailer() {
+    VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
+    assert((strlen(VLTSAVE_TRAILER_STR) & 7) == 0);  // Keep aligned
+    os.write(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR));
+}
+
+void VerilatedDeserialize::trailer() {
+    VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
+    if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR)))) {
+	string fn = filename();
+	string msg = (string)"Can't deserialize; file has wrong end-of-file signature";
+	vl_fatal(fn.c_str(), 0, "", msg.c_str());
+	close();
+    }
+}
+
+//=============================================================================
+//=============================================================================
+//=============================================================================
+// Opening/Closing
+
+void VerilatedSave::open (const char* filenamep) {
+    if (isOpen()) return;
+    VL_DEBUG_IF(VL_PRINTF("-vltSave: opening save file %s\n",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) {
+	    // User code can check isOpen()
+	    m_isOpen = false;
+	    return;
+	}
+    }
+    m_isOpen = true;
+    m_filename = filenamep;
+    m_cp = m_bufp;
+    header();
+}
+
+void VerilatedRestore::open (const char* filenamep) {
+    if (isOpen()) return;
+    VL_DEBUG_IF(VL_PRINTF("-vltRestore: opening restore file %s\n",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) {
+	    // User code can check isOpen()
+	    m_isOpen = false;
+	    return;
+	}
+    }
+    m_isOpen = true;
+    m_filename = filenamep;
+    m_cp = m_bufp;
+    m_endp = m_bufp;
+    header();
+}
+
+void VerilatedSave::close () {
+    if (!isOpen()) return;
+    trailer();
+    flush();
+    m_isOpen = false;
+    ::close(m_fd);  // May get error, just ignore it
+}
+
+void VerilatedRestore::close () {
+    if (!isOpen()) return;
+    trailer();
+    flush();
+    m_isOpen = false;
+    ::close(m_fd);  // May get error, just ignore it
+}
+
+//=============================================================================
+// Buffer management
+
+void VerilatedSave::flush() {
+    if (VL_UNLIKELY(!isOpen())) return;
+    vluint8_t* wp = m_bufp;
+    while (1) {
+	ssize_t remaining = (m_cp - wp);
+	if (remaining==0) break;
+	errno = 0;
+	ssize_t got = ::write (m_fd, wp, remaining);
+	if (got>0) {
+	    wp += got;
+	} else if (got < 0) {
+	    if (errno != EAGAIN && errno != EINTR) {
+		// write failed, presume error (perhaps out of disk space)
+		string msg = string(__FUNCTION__)+": "+strerror(errno);
+		vl_fatal("",0,"",msg.c_str());
+		close();
+		break;
+	    }
+	}
+    }
+    m_cp = m_bufp; // Reset buffer
+}
+
+void VerilatedRestore::fill() {
+    if (VL_UNLIKELY(!isOpen())) return;
+    // Move remaining characters down to start of buffer.  (No memcpy, overlaps allowed)
+    vluint8_t* rp = m_bufp;
+    for (vluint8_t* sp=m_cp; rp < m_endp;) *rp++ = *sp++;  // Overlaps
+    m_endp = m_bufp + (m_endp - m_cp);
+    m_cp = m_bufp; // Reset buffer
+    // Read into buffer starting at m_endp 
+    while (1) {
+	ssize_t remaining = (m_bufp+bufferSize() - m_endp);
+	if (remaining==0) break;
+	errno = 0;
+	ssize_t got = ::read (m_fd, m_endp, remaining);
+	if (got>0) {
+	    m_endp += got;
+	} else if (got < 0) {
+	    if (errno != EAGAIN && errno != EINTR) {
+		// write failed, presume error (perhaps out of disk space)
+		string msg = string(__FUNCTION__)+": "+strerror(errno);
+		vl_fatal("",0,"",msg.c_str());
+		close();
+		break;
+	    }
+	} else { // got==0, EOF
+	    // Fill buffer from here to end with NULLs so reader's don't need to check eof each character.
+	    while (m_endp < m_bufp+bufferSize()) *m_endp++ = '\0';
+	    break;
+	}
+    }
+}
+
+//=============================================================================
+// Serialization of types
+
+

include/verilated_save.h

@@ -0,0 +1,234 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// 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.
+//
+// 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 Save-restore serialization of verilated modules
+///
+//=============================================================================
+
+#ifndef _VERILATED_SAVE_C_H_
+#define _VERILATED_SAVE_C_H_ 1
+
+#include "verilatedos.h"
+
+#include <string>
+using namespace std;
+
+//=============================================================================
+// VerilatedSerialBase - internal base class for common code between VerilatedSerialize and VerilatedDeserialize
+
+class VerilatedSerialBase {
+protected:
+    // MEMBERS
+    // For speed, keep m_cp as the first member of this structure
+    vluint8_t*		m_cp;		///< Current pointer into m_bufp buffer
+    vluint8_t*		m_bufp;		///< Output buffer
+    bool 		m_isOpen;	///< True indicates open file/stream
+    string		m_filename;
+
+    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
+    inline static size_t bufferInsertSize() { return 16*1024; }
+
+    // CREATORS
+    VerilatedSerialBase() {
+	m_isOpen = false;
+	m_bufp = new vluint8_t [bufferSize()];
+	m_cp = m_bufp;
+    }
+private:
+    VerilatedSerialBase(const VerilatedSerialBase& );	///< N/A, no copy constructor
+public:
+    // CREATORS
+    virtual ~VerilatedSerialBase() {
+	close();
+	if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+    }
+    // METHODS
+    bool isOpen() const { return m_isOpen; }
+    string filename() const { return m_filename; }
+    virtual void close() { flush(); }
+    virtual void flush() {}
+};
+
+//=============================================================================
+// VerilatedSerialize - convert structures to a stream representation
+
+class VerilatedSerialize : public VerilatedSerialBase {
+protected:
+    virtual void close() { flush(); }
+    virtual void flush() {}
+    void header();
+    void trailer();
+public:
+    // CREATORS
+    VerilatedSerialize() {}
+    virtual ~VerilatedSerialize() { close(); }
+    // METHODS
+    VerilatedSerialize& bufferCheck() {
+	// Flush the write buffer if there's not enough space left for new information
+	// We only call this once per vector, so we need enough slop for a very wide "b###" line
+	if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
+	    flush();
+	}
+	return *this;  // For function chaining
+    }
+    inline VerilatedSerialize& write (const void* __restrict datap, size_t size) {
+	const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
+	while (size) {
+	    bufferCheck();
+	    size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+	    const vluint8_t* __restrict maxp = dp + blk;
+	    while (dp < maxp) *m_cp++ = *dp++;
+	    size -= blk;
+	}
+	return *this;  // For function chaining
+    }
+};
+
+//=============================================================================
+// VerilatedDeserial - load structures from a stream representation
+
+class VerilatedDeserialize : public VerilatedSerialBase {
+protected:
+    vluint8_t*		m_endp;		///< Last valid byte in m_bufp buffer
+    virtual void fill() = 0;
+    void header();
+    void trailer();
+public:
+    // CREATORS
+    VerilatedDeserialize() { m_endp = NULL; }
+    virtual ~VerilatedDeserialize() { close(); }
+    // METHODS
+    inline VerilatedDeserialize& read (void* __restrict datap, size_t size) {
+	vluint8_t* __restrict dp = (vluint8_t* __restrict)datap;
+	while (size) {
+	    bufferCheck();
+	    size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+	    const vluint8_t* __restrict maxp = dp + blk;
+	    while (dp < maxp) *dp++ = *m_cp++;
+	    size -= blk;
+	}
+	return *this;  // For function chaining
+    }
+    // Read a datum and compare with expected value
+    bool readDiffers (const void* __restrict datap, size_t size);
+    VerilatedDeserialize& readAssert (const void* __restrict datap, size_t size);
+    VerilatedDeserialize& readAssert (vluint64_t data) { return readAssert(&data, sizeof(data)); }
+    VerilatedDeserialize& bufferCheck() {
+	// Flush the write buffer if there's not enough space left for new information
+	// We only call this once per vector, so we need enough slop for a very wide "b###" line
+	if (VL_UNLIKELY((m_cp+bufferInsertSize()) > m_endp)) {
+	    fill();
+	}
+	return *this;  // For function chaining
+    }
+};
+
+//=============================================================================
+// VerilatedSave - serialize to a file
+
+class VerilatedSave : public VerilatedSerialize {
+private:
+    int			m_fd;		///< File descriptor we're writing to
+
+public:
+    // CREATORS
+    VerilatedSave() { m_fd=-1; }
+    virtual ~VerilatedSave() { close(); }
+    // METHODS
+    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
+    void open(const string& filename) { open(filename.c_str()); }
+    virtual void close();
+    virtual void flush();
+};
+
+//=============================================================================
+// VerilatedRestore - deserialize from a file
+
+class VerilatedRestore : public VerilatedDeserialize {
+private:
+    int			m_fd;		///< File descriptor we're writing to
+
+public:
+    // CREATORS
+    VerilatedRestore() { m_fd=-1; }
+    virtual ~VerilatedRestore() { close(); }
+
+    // METHODS
+    void open(const char* filenamep);	///< Open the file; call isOpen() to see if errors
+    void open(const string& filename) { open(filename.c_str()); }
+    virtual void close();
+    virtual void flush() {}
+    virtual void fill();
+};
+
+//=============================================================================
+
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint64_t& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint64_t& rhs){
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint32_t& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint32_t& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint16_t& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint16_t& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint8_t& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint8_t& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   bool& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, bool& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   double& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, double& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   float& rhs) {
+    return os.write(&rhs, sizeof(rhs));
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, float& rhs) {
+    return os.read(&rhs, sizeof(rhs));
+}
+inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   string& rhs) {
+    vluint32_t len=rhs.length();
+    os<<len;
+    return os.write(rhs.data(), len);
+}
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, string& rhs) {
+    vluint32_t len=0;
+    os>>len;
+    rhs.resize(len);
+    return os.read((void*)rhs.data(), len);
+}
+
+#endif // guard

include/verilated_sc.h

@@ -1,7 +1,7 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2009 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.
@@ -24,8 +24,8 @@
 //*************************************************************************
 
 
-#ifndef _VERILATEDSC_H_
-#define _VERILATEDSC_H_ 1 ///< Header Guard
+#ifndef _VERILATED_SC_H_
+#define _VERILATED_SC_H_ 1 ///< Header Guard
 
 #include "verilatedos.h"
 #include "systemc.h"
@@ -39,9 +39,9 @@
 #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
 class VlScBvExposer : public sc_bv_base {
 public:
-    static uint32_t* sp_datap(const sc_bv_base& base) {
+    static vluint32_t* sp_datap(const sc_bv_base& base) {
 	return static_cast<const VlScBvExposer*>(&base)->sp_datatp(); }
-    uint32_t* sp_datatp() const { return (uint32_t*)(m_data); }
+    vluint32_t* sp_datatp() const { return (vluint32_t*)(m_data); }
     // Above reads this protected element in sc_bv_base:
     //   sc_digit* m_data; // data array
 };

include/verilated_syms.h

@@ -0,0 +1,106 @@
+// -*- 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: Include to allow symbol inspection
+///
+///	This file is for inclusion by files that need to inspect
+///	the symbol table.  It is not included in verilated.h
+///	as it requires some heavyweight C++ classes.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//*************************************************************************
+
+
+#ifndef _VERILATED_SYMS_H_
+#define _VERILATED_SYMS_H_ 1 ///< Header Guard
+
+#include "verilated_heavy.h"
+
+#include <map>
+
+//===========================================================================
+/// Verilator range
+
+// See also V3Ast::VNumRange
+class VerilatedRange { 
+    int		m_left;
+    int		m_right;
+protected:
+    friend class VerilatedVar;
+    friend class VerilatedScope;
+    VerilatedRange() : m_left(0), m_right(0) {}
+    void sets(int left, int right) { m_left=left; m_right=right; }
+public:
+    ~VerilatedRange() {}
+    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)); }
+};
+
+//===========================================================================
+/// Verilator variable
+
+class VerilatedVar {
+    void*		m_datap;	// Location of data
+    VerilatedVarType	m_vltype;	// Data type
+    VerilatedVarFlags	m_vlflags;	// Direction
+    VerilatedRange	m_range;	// First range
+    VerilatedRange	m_array;	// Array
+    int			m_dims;		// Dimensions
+    const char*		m_namep;	// Name - slowpath
+protected:
+    friend class VerilatedScope;
+    VerilatedVar(const char* namep, void* datap,
+		 VerilatedVarType vltype, VerilatedVarFlags vlflags, int dims)
+	: m_datap(datap), m_vltype(vltype), m_vlflags(vlflags), m_dims(dims), m_namep(namep) {}
+public:
+    ~VerilatedVar() {}
+    void* datap() const { return m_datap; }
+    VerilatedVarType vltype() const { return m_vltype; }
+    VerilatedVarFlags vldir() const { return (VerilatedVarFlags)((int)m_vlflags & VLVF_MASK_DIR); }
+    vluint32_t entSize() const;
+    bool isPublicRW() const { return ((m_vlflags & VLVF_PUB_RW) != 0); }
+    const VerilatedRange& range() const { return m_range; }
+    const VerilatedRange& array() const { return m_array; }
+    const char* name() const { return m_namep; }
+    int dims() const { return m_dims; }
+};
+
+//======================================================================
+/// Types
+
+struct VerilatedCStrCmp {
+    /// Ordering maps keyed by const char*'s
+    bool operator() (const char *a, const char *b) const {
+	return std::strcmp(a, b) < 0;
+    }
+};
+
+class VerilatedScopeNameMap
+    : public map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
+public:
+    VerilatedScopeNameMap() {}
+    ~VerilatedScopeNameMap() {}
+};
+
+class VerilatedVarNameMap : public map<const char*, VerilatedVar, VerilatedCStrCmp> {
+public:
+    VerilatedVarNameMap() {}
+    ~VerilatedVarNameMap() {}
+};
+
+#endif // Guard

include/verilated_vcd_c.cpp

@@ -0,0 +1,756 @@
+// -*- 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 C++ Tracing in VCD Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#include "verilatedos.h"
+#include "verilated.h"
+#include "verilated_vcd_c.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cerrno>
+#include <ctime>
+#include <algorithm>
+
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
+// SPDIFF_ON
+
+#ifndef O_LARGEFILE // For example on WIN32
+# define O_LARGEFILE 0
+#endif
+#ifndef O_NONBLOCK
+# define O_NONBLOCK 0
+#endif
+
+//=============================================================================
+// Global
+
+vector<VerilatedVcd*>	VerilatedVcd::s_vcdVecp;	///< List of all created traces
+
+//=============================================================================
+// VerilatedVcdCallInfo
+/// Internal callback routines for each module being traced.
+////
+/// 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.
+
+class VerilatedVcdCallInfo {
+protected:
+    friend class VerilatedVcd;
+    VerilatedVcdCallback_t	m_initcb;	///< Initialization Callback function
+    VerilatedVcdCallback_t	m_fullcb;	///< Full Dumping Callback function
+    VerilatedVcdCallback_t	m_changecb;	///< Incremental Dumping Callback function
+    void*		m_userthis;	///< Fake "this" for caller
+    vluint32_t		m_code;		///< Starting code number
+    // CREATORS
+    VerilatedVcdCallInfo (VerilatedVcdCallback_t icb, VerilatedVcdCallback_t fcb,
+			  VerilatedVcdCallback_t changecb,
+			  void* ut, vluint32_t code)
+	: m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {};
+};
+
+//=============================================================================
+//=============================================================================
+//=============================================================================
+// 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;
+
+    // Set member variables
+    m_filename = filename;
+    s_vcdVecp.push_back(this);
+
+    // SPDIFF_OFF
+    // Set callback so an early exit will flush us
+    Verilated::flushCb(&flush_all);
+
+    // SPDIFF_ON
+    openNext (m_rolloverMB!=0);
+    if (!isOpen()) return;
+
+    dumpHeader();
+
+    // Allocate space now we know the number of codes
+    if (!m_sigs_oldvalp) {
+	m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
+    }
+
+    if (m_rolloverMB) {
+	openNext(true);
+	if (!isOpen()) return;
+    }
+}
+
+void VerilatedVcd::openNext (bool incFilename) {
+    // Open next filename in concat sequence, mangle filename if
+    // incFilename is true.
+    closePrev(); // Close existing
+    if (incFilename) {
+	// Find _0000.{ext} in filename
+	string name = m_filename;
+	size_t pos=name.rfind(".");
+	if (pos>8 && 0==strncmp("_cat",name.c_str()+pos-8,4)
+	    && isdigit(name.c_str()[pos-4])
+	    && isdigit(name.c_str()[pos-3])
+	    && isdigit(name.c_str()[pos-2])
+	    && isdigit(name.c_str()[pos-1])) {
+	    // Increment code.
+	    if ((++(name[pos-1])) > '9') {
+		name[pos-1] = '0';
+		if ((++(name[pos-2])) > '9') {
+		    name[pos-2] = '0';
+		    if ((++(name[pos-3])) > '9') {
+			name[pos-3] = '0';
+			if ((++(name[pos-4])) > '9') {
+			    name[pos-4] = '0';
+			}}}}
+	} else {
+	    // Append _cat0000
+	    name.insert(pos,"_cat0000");
+	}
+	m_filename = name;
+    }
+    if (m_filename[0]=='|') {
+	assert(0);	// Not supported yet.
+    } else {
+	// cppcheck-suppress duplicateExpression
+	if (!m_filep->open(m_filename)) {
+	    // User code can check isOpen()
+	    m_isOpen = false;
+	    return;
+	}
+    }
+    m_isOpen = true;
+    m_fullDump = true;	// First dump must be full
+    m_wroteBytes = 0;
+}
+
+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];
+	cip->m_code = nextCode();
+	(cip->m_initcb) (this, cip->m_userthis, cip->m_code);
+    }
+
+    // Though not speced, it's illegal to generate a vcd with signals
+    // not under any module - it crashes at least two viewers.
+    // If no scope was specified, prefix everything with a "top"
+    // This comes from user instantiations with no name - IE Vtop("").
+    bool nullScope = false;
+    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	const string& hiername = it->first;
+	if (hiername.size() >= 1 && hiername[0] == '\t') nullScope=true;
+    }
+    if (nullScope) {
+	NameMap* newmapp = new NameMap;
+	for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	    const string& hiername = it->first;
+	    const string& decl     = it->second;
+	    string newname = string("top");
+	    if (hiername[0] != '\t') newname += ' ';
+	    newname += hiername;
+	    newmapp->insert(make_pair(newname,decl));
+	}
+	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); }
+}
+
+void VerilatedVcd::closePrev () {
+    if (!isOpen()) return;
+
+    bufferFlush();
+    m_isOpen = false;
+    m_filep->close();
+}
+
+void VerilatedVcd::closeErr () {
+    // Close due to an error.  We might abort before even getting here,
+    // depending on the definition of vl_fatal.
+    if (!isOpen()) return;
+
+    // No buffer flush, just fclose
+    m_isOpen = false;
+    m_filep->close();  // May get error, just ignore it
+}
+
+void VerilatedVcd::close() {
+    if (!isOpen()) return;
+    if (m_evcd) {
+	printStr("$vcdclose ");
+	printTime(m_timeLastDump);
+	printStr(" $end\n");
+    }
+    closePrev();
+}
+
+void VerilatedVcd::printStr (const char* str) {
+    // Not fast...
+    while (*str) {
+	*m_writep++ = *str++;
+	bufferCheck();
+    }
+}
+
+void VerilatedVcd::printQuad (vluint64_t n) {
+    char buf [100];
+    sprintf(buf,"%" VL_PRI64 "u", n);
+    printStr(buf);
+}
+
+void VerilatedVcd::printTime (vluint64_t timeui) {
+    // VCD file format specification does not allow non-integers for timestamps
+    // Dinotrace doesn't mind, but Cadence vvision seems to choke
+    if (VL_UNLIKELY(timeui < m_timeLastDump)) {
+	timeui = m_timeLastDump;
+	static bool backTime = false;
+	if (!backTime) {
+	    backTime = true;
+	    VL_PRINTF("VCD time is moving backwards, wave file may be incorrect.\n");
+	}
+    }
+    m_timeLastDump = 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()
+    // This is much faster than using buffered I/O
+    if (VL_UNLIKELY(!isOpen())) return;
+    char* wp = m_wrBufp;
+    while (1) {
+	ssize_t remaining = (m_writep - wp);
+	if (remaining==0) break;
+	errno = 0;
+	ssize_t got = m_filep->write(wp, remaining);
+	if (got>0) {
+	    wp += got;
+	    m_wroteBytes += got;
+	} else if (got < 0) {
+	    if (errno != EAGAIN && errno != EINTR) {
+		// write failed, presume error (perhaps out of disk space)
+		string msg = (string)"VerilatedVcd::bufferFlush: "+strerror(errno);
+		vl_fatal("",0,"",msg.c_str());
+		closeErr();
+		break;
+	    }
+	}
+    }
+
+    // Reset buffer
+    m_writep = m_wrBufp;
+}
+
+//=============================================================================
+// Simple methods
+
+void VerilatedVcd::set_time_unit (const char* unitp) {
+    //cout<<" set_time_unit ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
+    m_timeUnit = timescaleToDouble(unitp);
+}
+
+void VerilatedVcd::set_time_resolution (const char* unitp) {
+    //cout<<"set_time_resolution ("<<unitp<<") == "<<timescaleToDouble(unitp)<<" == "<<doubleToTimescale(timescaleToDouble(unitp))<<endl;
+    m_timeRes = timescaleToDouble(unitp);
+}
+
+double VerilatedVcd::timescaleToDouble (const char* unitp) {
+    char* endp;
+    double value = strtod(unitp, &endp);
+    if (!value) value=1;  // On error so we allow just "ns" to return 1e-9.
+    unitp=endp;
+    while (*unitp && isspace(*unitp)) unitp++;
+    switch (*unitp) {
+    case 's': value *= 1e1; break;
+    case 'm': value *= 1e-3; break;
+    case 'u': value *= 1e-6; break;
+    case 'n': value *= 1e-9; break;
+    case 'p': value *= 1e-12; break;
+    case 'f': value *= 1e-15; break;
+    case 'a': value *= 1e-18; break;
+    }
+    return value;
+}
+
+string VerilatedVcd::doubleToTimescale (double value) {
+    const char* suffixp = "s";
+    if	    (value>=1e0)   { suffixp="s"; value *= 1e0; }
+    else if (value>=1e-3 ) { suffixp="ms"; value *= 1e3; }
+    else if (value>=1e-6 ) { suffixp="us"; value *= 1e6; }
+    else if (value>=1e-9 ) { suffixp="ns"; value *= 1e9; }
+    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,"%3.0f%s", value, suffixp);
+    return valuestr;  // Gets converted to string, so no ref to stack
+}
+
+//=============================================================================
+// Definitions
+
+void VerilatedVcd::printIndent (int level_change) {
+    if (level_change<0) m_modDepth += level_change;
+    assert(m_modDepth>=0);
+    for (int i=0; i<m_modDepth; i++) printStr(" ");
+    if (level_change>0) m_modDepth += level_change;
+}
+
+void VerilatedVcd::dumpHeader () {
+    printStr("$version Generated by VerilatedVcd $end\n");
+    time_t time_str = time(NULL);
+    printStr("$date "); printStr(ctime(&time_str)); printStr(" $end\n");
+
+    printStr("$timescale ");
+    const string& timeResStr = doubleToTimescale(m_timeRes);
+    printStr(timeResStr.c_str());
+    printStr(" $end\n");
+
+    makeNameMap();
+
+    // Signal header
+    assert (m_modDepth==0);
+    printIndent(1);
+    printStr("\n");
+
+    // We detect the spaces in module names to determine hierarchy.  This
+    // allows signals to be declared without fixed ordering, which is
+    // required as Verilog signals might be separately declared from
+    // "SP_TRACE" signals.
+
+    // Print the signal names
+    const char* lastName = "";
+    for (NameMap::iterator it=m_namemapp->begin(); it!=m_namemapp->end(); ++it) {
+	const string& hiernamestr = it->first;
+	const string& decl = it->second;
+
+	// Determine difference between the old and new names
+	const char* hiername = hiernamestr.c_str();
+	const char* lp = lastName;
+	const char* np = hiername;
+	lastName = hiername;
+
+	// Skip common prefix, it must break at a space or tab
+	for (; *np && (*np == *lp); np++, lp++) {}
+	while (np!=hiername && *np && *np!=' ' && *np!='\t') { np--; lp--; }
+	//printf("hier %s\n  lp=%s\n  np=%s\n",hiername,lp,np);
+
+	// Any extra spaces in last name are scope ups we need to do
+	bool first = true;
+	for (; *lp; lp++) {
+	    if (*lp==' ' || (first && *lp!='\t')) {
+		printIndent(-1);
+		printStr("$upscope $end\n");
+	    }
+	    first = false;
+	}
+
+	// Any new spaces are scope downs we need to do
+	while (*np) {
+	    if (*np==' ') np++;
+	    if (*np=='\t') break; // tab means signal name starts
+	    printIndent(1);
+	    printStr("$scope module ");
+	    for (; *np && *np!=' ' && *np!='\t'; np++) {
+		if (*np=='[') printStr("(");
+		else if (*np==']') printStr(")");
+		else *m_writep++=*np;
+	    }
+	    printStr(" $end\n");
+	}
+
+	printIndent(0);
+	printStr(decl.c_str());
+    }
+
+    while (m_modDepth>1) {
+	printIndent(-1);
+	printStr("$upscope $end\n");
+    }
+
+    printIndent(-1);
+    printStr("$enddefinitions $end\n\n\n");
+    assert (m_modDepth==0);
+
+    // Reclaim storage
+    deleteNameMap();
+}
+
+void VerilatedVcd::module (const string& name) {
+    m_modName = name;
+}
+
+void VerilatedVcd::declare (vluint32_t code, const char* name, const char* wirep,
+			    int arraynum, bool tri, bool bussed, int msb, int lsb) {
+    if (!code) { vl_fatal(__FILE__,__LINE__,"","Internal: internal trace problem, code 0 is illegal"); }
+
+    int bits = ((msb>lsb)?(msb-lsb):(lsb-msb))+1;
+    int codesNeeded = 1+int(bits/32);
+    if (tri) codesNeeded *= 2;   // Space in change array for __en signals
+
+    // Make sure array is large enough
+    m_nextCode = max(nextCode(), code+codesNeeded);
+    if (m_sigs.capacity() <= m_nextCode) {
+	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);
+
+    // Split name into basename
+    // Spaces and tabs aren't legal in VCD signal names, so:
+    // Space separates each level of scope
+    // Tab separates final scope from signal name
+    // Tab sorts before spaces, so signals nicely will print before scopes
+    // Note the hiername may be nothing, if so we'll add "\t{name}"
+    string nameasstr = name;
+    if (m_modName!="") { nameasstr = m_modName+m_scopeEscape+nameasstr; }  // Optional ->module prefix
+    string hiername;
+    string basename;
+    for (const char* cp=nameasstr.c_str(); *cp; cp++) {
+	if (isScopeEscape(*cp)) {
+	    // Ahh, we've just read a scope, not a basename
+	    if (hiername!="") hiername += " ";
+	    hiername += basename;
+	    basename = "";
+	} else {
+	    basename += *cp;
+	}
+    }
+    hiername += "\t"+basename;
+
+    // Print reference
+    string decl = "$var ";
+    if (m_evcd) decl += "port"; else decl += wirep;  // usually "wire"
+    char buf [1000];
+    sprintf(buf, " %2d ", bits);
+    decl += buf;
+    if (m_evcd) {
+	sprintf(buf, "<%d", code);
+	decl += buf;
+    } else {
+	decl += stringCode(code);
+    }
+    decl += " ";
+    decl += basename;
+    if (arraynum>=0) {
+	sprintf(buf, "(%d)", arraynum);
+	decl += buf;
+	hiername += buf;
+    }
+    if (bussed) {
+	sprintf(buf, " [%d:%d]", msb, lsb);
+	decl += buf;
+    }
+    decl += " $end\n";
+    m_namemapp->insert(make_pair(hiername,decl));
+}
+
+void VerilatedVcd::declBit      (vluint32_t code, const char* name, int arraynum)
+{  declare (code, name, "wire", arraynum, false, false, 0, 0); }
+void VerilatedVcd::declBus      (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+void VerilatedVcd::declQuad     (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+void VerilatedVcd::declArray    (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, false, true, msb, lsb); }
+void VerilatedVcd::declTriBit   (vluint32_t code, const char* name, int arraynum)
+{  declare (code, name, "wire", arraynum, true, false, 0, 0); }
+void VerilatedVcd::declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+void VerilatedVcd::declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+void VerilatedVcd::declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb)
+{  declare (code, name, "wire", arraynum, true, true, msb, lsb); }
+void VerilatedVcd::declFloat    (vluint32_t code, const char* name, int arraynum)
+{  declare (code, name, "real", arraynum, false, false, 31, 0); }
+void VerilatedVcd::declDouble   (vluint32_t code, const char* name, int arraynum)
+{  declare (code, name, "real", arraynum, false, false, 63, 0); }
+
+//=============================================================================
+
+void VerilatedVcd::fullDouble (vluint32_t code, const double newval) {
+    (*((double*)&m_sigs_oldvalp[code])) = newval;
+    // Buffer can't overflow before sprintf; we sized during declaration
+    sprintf(m_writep, "r%.16g", newval);
+    m_writep += strlen(m_writep);
+    *m_writep++=' '; printCode(code); *m_writep++='\n';
+    bufferCheck();
+}
+void VerilatedVcd::fullFloat (vluint32_t code, const float newval) {
+    (*((float*)&m_sigs_oldvalp[code])) = newval;
+    // 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';
+    bufferCheck();
+}
+
+//=============================================================================
+// Callbacks
+
+void VerilatedVcd::addCallback (
+    VerilatedVcdCallback_t initcb, VerilatedVcdCallback_t fullcb, VerilatedVcdCallback_t changecb,
+    void* userthis)
+{
+    if (VL_UNLIKELY(isOpen())) {
+	string msg = (string)"Internal: "+__FILE__+"::"+__FUNCTION__+" called with already open file";
+	vl_fatal(__FILE__,__LINE__,"",msg.c_str());
+    }
+    VerilatedVcdCallInfo* vci = new VerilatedVcdCallInfo(initcb, fullcb, changecb, userthis, nextCode());
+    m_callbacks.push_back(vci);
+}
+
+//=============================================================================
+// Dumping
+
+void VerilatedVcd::dumpFull (vluint64_t timeui) {
+    dumpPrep (timeui);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
+	VerilatedVcdCallInfo *cip = m_callbacks[ent];
+	(cip->m_fullcb) (this, cip->m_userthis, cip->m_code);
+    }
+    dumpDone ();
+}
+
+void VerilatedVcd::dump (vluint64_t timeui) {
+    if (!isOpen()) return;
+    if (VL_UNLIKELY(m_fullDump)) {
+	m_fullDump = false;	// No need for more full dumps
+	dumpFull(timeui);
+	return;
+    }
+    if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > this->m_rolloverMB)) {
+	openNext(true);
+	if (!isOpen()) return;
+    }
+    dumpPrep (timeui);
+    for (vluint32_t ent = 0; ent< m_callbacks.size(); ent++) {
+	VerilatedVcdCallInfo *cip = m_callbacks[ent];
+	(cip->m_changecb) (this, cip->m_userthis, cip->m_code);
+    }
+    dumpDone();
+}
+
+void VerilatedVcd::dumpPrep (vluint64_t timeui) {
+    printStr("#");
+    printTime(timeui);
+    printStr("\n");
+}
+
+void VerilatedVcd::dumpDone () {
+}
+
+//======================================================================
+// Static members
+
+void VerilatedVcd::flush_all() {
+    for (vluint32_t ent = 0; ent< s_vcdVecp.size(); ent++) {
+	VerilatedVcd* vcdp = s_vcdVecp[ent];
+	vcdp->flush();
+    }
+}
+
+//======================================================================
+//======================================================================
+//======================================================================
+
+#ifdef VERILATED_VCD_TEST
+vluint32_t v1, v2, s1, s2[3];
+vluint32_t tri96[3];
+vluint32_t tri96__tri[3];
+vluint8_t ch;
+vluint64_t timestamp = 1;
+double doub = 0;
+
+void vcdInit (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+    vcdp->scopeEscape('.');
+    vcdp->module ("top");
+     vcdp->declBus (0x2, "v1",-1,5,1);
+     vcdp->declBus (0x3, "v2",-1,6,0);
+     vcdp->module ("top.sub1");
+      vcdp->declBit (0x4, "s1",-1);
+      vcdp->declBit (0x5, "ch",-1);
+     vcdp->module ("top.sub2");
+      vcdp->declArray (0x6, "s2",-1, 40,3);
+    // Note need to add 3 for next code.
+    vcdp->module ("top2");
+     vcdp->declBus (0x2, "t2v1",-1,4,1);
+     vcdp->declTriBit   (0x10, "io1", -1);
+     vcdp->declTriBus   (0x12, "io5", -1,4,0);
+     vcdp->declTriArray (0x16, "io96",-1,95,0);
+    // Note need to add 6 for next code.
+     vcdp->declDouble   (0x1c, "doub",-1);
+    // Note need to add 2 for next code.
+}
+
+void vcdFull (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+    vcdp->fullBus  (0x2, v1,5);
+    vcdp->fullBus  (0x3, v2,7);
+    vcdp->fullBit  (0x4, s1);
+    vcdp->fullBus  (0x5, ch,2);
+    vcdp->fullArray(0x6, &s2[0], 38);
+    vcdp->fullTriBit   (0x10, tri96[0]&1,    tri96__tri[0]&1);
+    vcdp->fullTriBus   (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f,  5);
+    vcdp->fullTriArray (0x16, tri96,         tri96__tri,          96);
+    vcdp->fullDouble(0x1c, doub);
+}
+
+void vcdChange (VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+    vcdp->chgBus  (0x2, v1,5);
+    vcdp->chgBus  (0x3, v2,7);
+    vcdp->chgBit  (0x4, s1);
+    vcdp->chgBus  (0x5, ch,2);
+    vcdp->chgArray(0x6, &s2[0], 38);
+    vcdp->chgTriBit   (0x10, tri96[0]&1,   tri96__tri[0]&1);
+    vcdp->chgTriBus   (0x12, tri96[0]&0x1f, tri96__tri[0]&0x1f, 5);
+    vcdp->chgTriArray (0x16, tri96,         tri96__tri,         96);
+    vcdp->chgDouble   (0x1c, doub);
+}
+
+main() {
+    cout<<"test: O_LARGEFILE="<<O_LARGEFILE<<endl;
+
+    v1 = v2 = s1 = 0;
+    s2[0] = s2[1] = s2[2] = 0;
+    tri96[2] = tri96[1] = tri96[0] = 0;
+    tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;
+    ch = 0;
+    doub = 0;
+    {
+	VerilatedVcdC* vcdp = new VerilatedVcdC;
+	vcdp->spTrace()->addCallback (&vcdInit, &vcdFull, &vcdChange, 0);
+	vcdp->open ("test.vcd");
+	// Dumping
+	vcdp->dump(timestamp++);
+	v1 = 0xfff;
+	tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
+	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
+	doub = 1.5;
+	vcdp->dump(timestamp++);
+	v2 = 0x1;
+	s2[1] = 2;
+	tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0; // enable w/o data change
+	doub = -1.66e13;
+	vcdp->dump(timestamp++);
+	ch = 2;
+	tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
+	doub = -3.33e-13;
+	vcdp->dump(timestamp++);
+	vcdp->dump(timestamp++);
+# ifdef VERILATED_VCD_TEST_64BIT
+	vluint64_t bytesPerDump = 15ULL;
+	for (vluint64_t i=0; i<((1ULL<<32) / bytesPerDump); i++) {
+	    v1 = i;
+	    vcdp->dump(timestamp++);
+	}
+# endif
+	vcdp->close();
+    }
+}
+#endif
+
+//********************************************************************
+// Local Variables:
+// 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

@@ -0,0 +1,435 @@
+// -*- 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 C++ Tracing in VCD Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_VCD_C_H_
+#define _VERILATED_VCD_C_H_ 1
+
+#include "verilatedos.h"
+
+#include <string>
+#include <vector>
+#include <map>
+using namespace std;
+
+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.
+
+class VerilatedVcdSig {
+protected:
+    friend class VerilatedVcd;
+    vluint32_t		m_code;		///< VCD file code number
+    int			m_bits;		///< Size of value in bits
+    VerilatedVcdSig (vluint32_t code, int bits)
+	: m_code(code), m_bits(bits) {}
+public:
+    ~VerilatedVcdSig() {}
+};
+
+//=============================================================================
+
+typedef void (*VerilatedVcdCallback_t)(VerilatedVcd* vcdp, void* userthis, vluint32_t code);
+
+//=============================================================================
+// VerilatedVcd
+/// 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
+    string		m_filename;	///< Filename we're writing to (if open)
+    vluint64_t		m_rolloverMB;	///< MB of file size to rollover at
+    char		m_scopeEscape;	///< Character to separate scope components
+    int			m_modDepth;	///< Depth of module hierarchy
+    bool		m_fullDump;	///< True indicates dump ignoring if changed
+    vluint32_t		m_nextCode;	///< Next code number to assign
+    string		m_modName;	///< Module name being traced now
+    double		m_timeRes;	///< Time resolution (ns/ms etc)
+    double		m_timeUnit;	///< Time units (ns/ms etc)
+    vluint64_t		m_timeLastDump;	///< Last time we did a dump
+
+    char*		m_wrBufp;	///< Output buffer
+    char*		m_wrFlushp;	///< Output buffer flush trigger location
+    char*		m_writep;	///< Write pointer into output buffer
+    vluint64_t		m_wrChunkSize;	///< Output buffer size
+    vluint64_t		m_wroteBytes;	///< Number of bytes written to this file
+
+    vluint32_t*			m_sigs_oldvalp;	///< Pointer to old signal values
+    vector<VerilatedVcdSig>	m_sigs;		///< Pointer to signal information
+    vector<VerilatedVcdCallInfo*>	m_callbacks;	///< Routines to perform dumping
+    typedef map<string,string>	NameMap;
+    NameMap*			m_namemapp;	///< List of names for the header
+    static vector<VerilatedVcd*>	s_vcdVecp;	///< List of all created traces
+
+    void bufferResize(vluint64_t minsize);
+    void bufferFlush();
+    inline void bufferCheck() {
+	// Flush the write buffer if there's not enough space left for new information
+	// We only call this once per vector, so we need enough slop for a very wide "b###" line
+	if (VL_UNLIKELY(m_writep > m_wrFlushp)) {
+	    bufferFlush();
+	}
+    }
+    void closePrev();
+    void closeErr();
+    void openNext();
+    void makeNameMap();
+    void deleteNameMap();
+    void printIndent (int levelchange);
+    void printStr (const char* str);
+    void printQuad (vluint64_t n);
+    void printTime (vluint64_t timeui);
+    void declare (vluint32_t code, const char* name, const char* wirep,
+		  int arraynum, bool tri, bool bussed, int msb, int lsb);
+
+    void dumpHeader();
+    void dumpPrep (vluint64_t timeui);
+    void dumpFull (vluint64_t timeui);
+    // cppcheck-suppress functionConst
+    void dumpDone ();
+    inline void printCode (vluint32_t code) {
+	if (code>=(94*94*94)) *m_writep++ = ((char)((code/94/94/94)%94+33));
+	if (code>=(94*94))    *m_writep++ = ((char)((code/94/94)%94+33));
+	if (code>=(94))       *m_writep++ = ((char)((code/94)%94+33));
+	*m_writep++ = ((char)((code)%94+33));
+    }
+    static string stringCode (vluint32_t code) {
+	string out;
+	if (code>=(94*94*94)) out += ((char)((code/94/94/94)%94+33));
+	if (code>=(94*94))    out += ((char)((code/94/94)%94+33));
+	if (code>=(94))       out += ((char)((code/94)%94+33));
+	return out + ((char)((code)%94+33));
+    }
+
+    VerilatedVcd(const VerilatedVcd& );	///< N/A, no copy constructor
+
+protected:
+    // METHODS
+    void evcd(bool flag) { m_evcd = flag; }
+
+public:
+    // CREATORS
+    explicit VerilatedVcd(VerilatedVcdFile* filep=NULL);
+    ~VerilatedVcd();
+
+    // ACCESSORS
+    /// Inside dumping routines, return next VCD signal code
+    vluint32_t nextCode() const {return m_nextCode;}
+    /// Set size in megabytes after which new file should be created
+    void rolloverMB(vluint64_t rolloverMB) { m_rolloverMB=rolloverMB; };
+    /// Is file open?
+    bool isOpen() const { return m_isOpen; }
+    /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
+    void scopeEscape(char flag) { m_scopeEscape = flag; }
+    /// Is this an escape?
+    inline bool isScopeEscape(char c) { return isspace(c) || c==m_scopeEscape; }
+
+    // METHODS
+    void open (const char* filename);	///< Open the file; call isOpen() to see if errors
+    void openNext (bool incFilename);	///< Open next data-only file
+    void flush() { bufferFlush(); }	///< Flush any remaining data
+    static void flush_all();		///< Flush any remaining data from all files
+    void close ();			///< Close the file
+
+    void set_time_unit (const char* unit); ///< Set time units (s/ms, defaults to ns)
+    void set_time_unit (const string& unit) { set_time_unit(unit.c_str()); }
+
+    void set_time_resolution (const char* unit); ///< Set time resolution (s/ms, defaults to ns)
+    void set_time_resolution (const string& unit) { set_time_resolution(unit.c_str()); }
+
+    double timescaleToDouble (const char* unitp);
+    string doubleToTimescale (double value);
+
+    /// Inside dumping routines, called each cycle to make the dump
+    void dump     (vluint64_t timeui);
+    /// Call dump with a absolute unscaled time in seconds
+    void dumpSeconds (double secs) { dump((vluint64_t)(secs * m_timeRes)); }
+
+    /// Inside dumping routines, declare callbacks for tracings
+    void addCallback (VerilatedVcdCallback_t init, VerilatedVcdCallback_t full,
+		      VerilatedVcdCallback_t change,
+		      void* userthis);
+
+    /// Inside dumping routines, declare a module
+    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);
+    void declQuad     (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declArray    (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriBit   (vluint32_t code, const char* name, int arraynum);
+    void declTriBus   (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriQuad  (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declTriArray (vluint32_t code, const char* name, int arraynum, int msb, int lsb);
+    void declDouble   (vluint32_t code, const char* name, int arraynum);
+    void declFloat    (vluint32_t code, const char* name, int arraynum);
+    //	... other module_start for submodules (based on cell name)
+
+    /// Inside dumping routines, dump one signal
+    void fullBit (vluint32_t code, const vluint32_t newval) {
+	// Note the &1, so we don't require clean input -- makes more common no change case faster
+	m_sigs_oldvalp[code] = newval;
+	*m_writep++=('0'+(char)(newval&1)); printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullBus (vluint32_t code, const vluint32_t newval, int bits) {
+	m_sigs_oldvalp[code] = newval;
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++=((newval&(1L<<bit))?'1':'0');
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullQuad (vluint32_t code, const vluint64_t newval, int bits) {
+	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++=((newval&(1ULL<<bit))?'1':'0');
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullArray (vluint32_t code, const vluint32_t* newval, int bits) {
+	for (int word=0; word<(((bits-1)/32)+1); ++word) {
+	    m_sigs_oldvalp[code+word] = newval[word];
+	}
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++=((newval[(bit/32)]&(1L<<(bit&0x1f)))?'1':'0');
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
+	m_sigs_oldvalp[code]   = newval;
+	m_sigs_oldvalp[code+1] = newtri;
+	*m_writep++ = "01zz"[m_sigs_oldvalp[code]
+			     | (m_sigs_oldvalp[code+1]<<1)];
+	printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
+	m_sigs_oldvalp[code] = newval;
+	m_sigs_oldvalp[code+1] = newtri;
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++ = "01zz"[((newval >> bit)&1)
+				 | (((newtri >> bit)&1)<<1)];
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
+	(*((vluint64_t*)&m_sigs_oldvalp[code])) = newval;
+	(*((vluint64_t*)&m_sigs_oldvalp[code+1])) = newtri;
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++ = "01zz"[((newval >> bit)&1ULL)
+				 | (((newtri >> bit)&1ULL)<<1ULL)];
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
+	for (int word=0; word<(((bits-1)/32)+1); ++word) {
+	    m_sigs_oldvalp[code+word*2]   = newvalp[word];
+	    m_sigs_oldvalp[code+word*2+1] = newtrip[word];
+	}
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    vluint32_t valbit = (newvalp[(bit/32)]>>(bit&0x1f)) & 1;
+	    vluint32_t tribit = (newtrip[(bit/32)]>>(bit&0x1f)) & 1;
+	    *m_writep++ = "01zz"[valbit | (tribit<<1)];
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    void fullDouble (vluint32_t code, const double newval);
+    void fullFloat (vluint32_t code, const float newval);
+
+    /// Inside dumping routines, dump one signal as unknowns
+    /// Presently this code doesn't change the oldval vector.
+    /// Thus this is for special standalone applications that after calling
+    /// fullBitX, must when then value goes non-X call fullBit.
+    inline void fullBitX (vluint32_t code) {
+	*m_writep++='x'; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    inline void fullBusX (vluint32_t code, int bits) {
+	*m_writep++='b';
+	for (int bit=bits-1; bit>=0; --bit) {
+	    *m_writep++='x';
+	}
+	*m_writep++=' '; printCode(code); *m_writep++='\n';
+	bufferCheck();
+    }
+    inline void fullQuadX (vluint32_t code, int bits) { fullBusX (code, bits); }
+    inline void fullArrayX (vluint32_t code, int bits) { fullBusX (code, bits); }
+
+    /// Inside dumping routines, dump one signal if it has changed
+    inline void chgBit (vluint32_t code, const vluint32_t newval) {
+	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+	if (VL_UNLIKELY(diff)) {
+	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
+	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
+		fullBit (code, newval);
+	    }
+	}
+    }
+    inline void chgBus (vluint32_t code, const vluint32_t newval, int bits) {
+	vluint32_t diff = m_sigs_oldvalp[code] ^ newval;
+	if (VL_UNLIKELY(diff)) {
+	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+		fullBus (code, newval, bits);
+	    }
+	}
+    }
+    inline void chgQuad (vluint32_t code, const vluint64_t newval, int bits) {
+	vluint64_t diff = (*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval;
+	if (VL_UNLIKELY(diff)) {
+	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+		fullQuad(code, newval, bits);
+	    }
+	}
+    }
+    inline void chgArray (vluint32_t code, const vluint32_t* newval, int bits) {
+	for (int word=0; word<(((bits-1)/32)+1); ++word) {
+	    if (VL_UNLIKELY(m_sigs_oldvalp[code+word] ^ newval[word])) {
+		fullArray (code,newval,bits);
+		return;
+	    }
+	}
+    }
+    inline void chgTriBit (vluint32_t code, const vluint32_t newval, const vluint32_t newtri) {
+	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+			 | (m_sigs_oldvalp[code+1] ^ newtri));
+	if (VL_UNLIKELY(diff)) {
+	    // Verilator 3.510 and newer provide clean input, so the below is only for back compatibility
+	    if (VL_UNLIKELY(diff & 1)) {   // Change after clean?
+		fullTriBit (code, newval, newtri);
+	    }
+	}
+    }
+    inline void chgTriBus (vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits) {
+	vluint32_t diff = ((m_sigs_oldvalp[code] ^ newval)
+			 | (m_sigs_oldvalp[code+1] ^ newtri));
+	if (VL_UNLIKELY(diff)) {
+	    if (VL_UNLIKELY(bits==32 || (diff & ((1U<<bits)-1) ))) {
+		fullTriBus (code, newval, newtri, bits);
+	    }
+	}
+    }
+    inline void chgTriQuad (vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits) {
+	vluint64_t diff = ( ((*((vluint64_t*)&m_sigs_oldvalp[code])) ^ newval)
+			  | ((*((vluint64_t*)&m_sigs_oldvalp[code+1])) ^ newtri));
+	if (VL_UNLIKELY(diff)) {
+	    if (VL_UNLIKELY(bits==64 || (diff & ((1ULL<<bits)-1) ))) {
+		fullTriQuad(code, newval, newtri, bits);
+	    }
+	}
+    }
+    inline void chgTriArray (vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits) {
+	for (int word=0; word<(((bits-1)/32)+1); ++word) {
+	    if (VL_UNLIKELY((m_sigs_oldvalp[code+word*2] ^ newvalp[word])
+			    | (m_sigs_oldvalp[code+word*2+1] ^ newtrip[word]))) {
+		fullTriArray (code,newvalp,newtrip,bits);
+		return;
+	    }
+	}
+    }
+    inline void chgDouble (vluint32_t code, const double newval) {
+	if (VL_UNLIKELY((*((double*)&m_sigs_oldvalp[code])) != newval)) {
+	    fullDouble (code, newval);
+	}
+    }
+    inline void chgFloat (vluint32_t code, const float newval) {
+	if (VL_UNLIKELY((*((float*)&m_sigs_oldvalp[code])) != newval)) {
+	    fullFloat (code, newval);
+	}
+    }
+};
+
+//=============================================================================
+// VerilatedVcdC
+/// Create a VCD dump file in C standalone (no SystemC) simulations.
+
+class VerilatedVcdC {
+    VerilatedVcd		m_sptrace;	///< Trace file being created
+public:
+    // CONSTRUCTORS
+    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); };
+    /// Close dump
+    void close() { m_sptrace.close(); }
+    /// Flush dump
+    void flush() { m_sptrace.flush(); }
+    /// Write one cycle of dump data
+    void dump (vluint64_t timeui) { m_sptrace.dump(timeui); }
+    /// Write one cycle of dump data - backward compatible and to reduce
+    /// conversion warnings.  It's better to use a vluint64_t time instead.
+    void dump (double timestamp) { dump((vluint64_t)timestamp); }
+    void dump (vluint32_t timestamp) { dump((vluint64_t)timestamp); }
+    void dump (int timestamp) { dump((vluint64_t)timestamp); }
+    /// Internal class access
+    inline VerilatedVcd* spTrace () { return &m_sptrace; };
+};
+
+#endif // guard

include/verilated_vcd_sc.cpp

@@ -0,0 +1,160 @@
+// -*- 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 tracing in VCD Format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#include "verilatedos.h"
+#include "verilated_vcd_sc.h"
+
+// SPDIFF_ON
+//======================================================================
+//======================================================================
+
+//--------------------------------------------------
+#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 **) {}
+
+# define DECL_TRACE_METHOD_A(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const std::string& name ) {}
+# define DECL_TRACE_METHOD_B(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const std::string& name, int width ) {}
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_A( sc_dt::sc_bit )
+    DECL_TRACE_METHOD_A( sc_dt::sc_logic )
+
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( unsigned short )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( unsigned long )
+#ifdef SYSTEMC_64BIT_PATCHES
+    DECL_TRACE_METHOD_B( unsigned long long)
+#endif
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long )
+    DECL_TRACE_METHOD_B( sc_dt::int64 )
+    DECL_TRACE_METHOD_B( sc_dt::uint64 )
+
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_dt::sc_int_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_signed )
+    DECL_TRACE_METHOD_A( sc_dt::sc_unsigned )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval_fast )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum_fast )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_lv_base )
+
+//--------------------------------------------------
+#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 **) {}
+
+#define DECL_TRACE_METHOD_A(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}
+#define DECL_TRACE_METHOD_B(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const sc_string& name, int width ) {}
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_A( sc_bit )
+    DECL_TRACE_METHOD_A( sc_logic )
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( unsigned short )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( unsigned long )
+#ifdef SYSTEMC_64BIT_PATCHES
+    DECL_TRACE_METHOD_B( unsigned long long)
+#endif
+#if (SYSTEMC_VERSION>20041000)
+    DECL_TRACE_METHOD_B( unsigned long long)
+    DECL_TRACE_METHOD_B( long long)
+#endif
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long )
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_int_base )
+    DECL_TRACE_METHOD_A( sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_signed )
+    DECL_TRACE_METHOD_A( sc_unsigned )
+    DECL_TRACE_METHOD_A( sc_fxval )
+    DECL_TRACE_METHOD_A( sc_fxval_fast )
+    DECL_TRACE_METHOD_A( sc_fxnum )
+    DECL_TRACE_METHOD_A( sc_fxnum_fast )
+    DECL_TRACE_METHOD_A( sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_lv_base )
+
+//--------------------------------------------------
+#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 **) {}
+
+#define DECL_TRACE_METHOD_A(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const sc_string& name ) {}
+#define DECL_TRACE_METHOD_B(tp) \
+    void VerilatedVcdSc::trace( const tp& object, const sc_string& name, int width ) {}
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( short unsigned int )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( long unsigned int )
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short int )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long int )
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_bit )
+    DECL_TRACE_METHOD_A( sc_logic )
+    DECL_TRACE_METHOD_A( sc_bool_vector )
+    DECL_TRACE_METHOD_A( sc_logic_vector )
+    DECL_TRACE_METHOD_A( sc_signal_bool_vector )
+    DECL_TRACE_METHOD_A( sc_signal_logic_vector )
+    DECL_TRACE_METHOD_A( sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_int_base )
+    DECL_TRACE_METHOD_A( sc_unsigned )
+    DECL_TRACE_METHOD_A( sc_signed )
+    DECL_TRACE_METHOD_A( sc_signal_resolved )
+    DECL_TRACE_METHOD_A( sc_signal_resolved_vector )
+    DECL_TRACE_METHOD_A( sc_bv_ns::sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_bv_ns::sc_lv_base )
+#endif
+
+#undef DECL_TRACE_METHOD_A
+#undef DECL_TRACE_METHOD_B
+
+//********************************************************************

include/verilated_vcd_sc.h

@@ -0,0 +1,213 @@
+// -*- 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 tracing in VCD format
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_VCD_SC_H_
+#define _VERILATED_VCD_SC_H_ 1
+
+#include "verilated_sc.h"
+#include "verilated_vcd_c.h"
+
+// SPDIFF_ON
+//=============================================================================
+// VerilatedVcdSc
+///
+/// This class is passed to the SystemC simulation kernel, just like a
+/// documented SystemC trace format.
+
+class VerilatedVcdSc
+    : sc_trace_file
+    , public VerilatedVcdC
+{
+public:
+    VerilatedVcdSc() {
+	sc_get_curr_simcontext()->add_trace_file(this);
+# if (SYSTEMC_VERSION>=20060505)
+	// We want to avoid a depreciated warning, but still be back compatible.
+	// Turning off the message just for this still results in an annoying "to turn off" message.
+	sc_time t1sec(1,SC_SEC);
+	if (t1sec.to_default_time_units()!=0) {
+	    sc_time tunits(1.0/t1sec.to_default_time_units(),SC_SEC);
+	    spTrace()->set_time_unit(tunits.to_string());
+	}
+	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+# elif (SYSTEMC_VERSION>20011000)
+	// To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
+	// we allow both flavors with overloaded set_time_* functions.
+	spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
+	spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
+# endif
+    }
+
+    virtual ~VerilatedVcdSc() {}
+    /// Called by SystemC simulate()
+    virtual void cycle (bool delta_cycle) {
+# if (SYSTEMC_VERSION>20011000)
+	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+# else
+	// VCD files must have integer timestamps, so we write all times in increments of time_resolution
+	if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
+# endif
+    }
+
+private:
+    /// Fake outs for linker
+
+#ifdef NC_SYSTEMC
+    // Cadence Incisive has these as abstract functions so we must create them
+    virtual void set_time_unit( int exponent10_seconds ) {} // deprecated
+#endif
+#if defined(NC_SYSTEMC) || (SYSTEMC_VERSION>=20111100)
+    virtual void set_time_unit( double v, sc_time_unit tu ) {}
+#endif
+
+
+//--------------------------------------------------
+# if (SYSTEMC_VERSION>=20050714)
+    // SystemC 2.1.v1
+# define DECL_TRACE_METHOD_A(tp) \
+    virtual void trace( const tp& object, const std::string& name );
+# define DECL_TRACE_METHOD_B(tp) \
+    virtual void trace( const tp& object, const std::string& name, int width );
+
+    virtual void write_comment (const std::string &);
+    virtual void trace (const unsigned int &, const std::string &, const char **);
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_A( sc_dt::sc_bit )
+    DECL_TRACE_METHOD_A( sc_dt::sc_logic )
+
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( unsigned short )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( unsigned long )
+#ifdef SYSTEMC_64BIT_PATCHES
+    DECL_TRACE_METHOD_B( unsigned long long)
+#endif
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long )
+    DECL_TRACE_METHOD_B( sc_dt::int64 )
+    DECL_TRACE_METHOD_B( sc_dt::uint64 )
+
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_dt::sc_int_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_signed )
+    DECL_TRACE_METHOD_A( sc_dt::sc_unsigned )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxval_fast )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum )
+    DECL_TRACE_METHOD_A( sc_dt::sc_fxnum_fast )
+
+    DECL_TRACE_METHOD_A( sc_dt::sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_dt::sc_lv_base )
+
+//--------------------------------------------------
+# elif (SYSTEMC_VERSION>20011000)
+    // SystemC 2.0.1
+# define DECL_TRACE_METHOD_A(tp) \
+    virtual void trace( const tp& object, const sc_string& name );
+# define DECL_TRACE_METHOD_B(tp) \
+    virtual void trace( const tp& object, const sc_string& name, int width );
+
+    virtual void write_comment (const sc_string &);
+    virtual void trace (const unsigned int &, const sc_string &, const char **);
+    virtual void delta_cycles (bool) {}
+    virtual void space( int n ) {}
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_A( sc_bit )
+    DECL_TRACE_METHOD_A( sc_logic )
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( unsigned short )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( unsigned long )
+#ifdef SYSTEMC_64BIT_PATCHES
+    DECL_TRACE_METHOD_B( unsigned long long)
+#endif
+#if (SYSTEMC_VERSION>20041000)
+    DECL_TRACE_METHOD_B( unsigned long long)
+    DECL_TRACE_METHOD_B( long long)
+#endif
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long )
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_int_base )
+    DECL_TRACE_METHOD_A( sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_signed )
+    DECL_TRACE_METHOD_A( sc_unsigned )
+    DECL_TRACE_METHOD_A( sc_fxval )
+    DECL_TRACE_METHOD_A( sc_fxval_fast )
+    DECL_TRACE_METHOD_A( sc_fxnum )
+    DECL_TRACE_METHOD_A( sc_fxnum_fast )
+    DECL_TRACE_METHOD_A( sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_lv_base )
+
+//--------------------------------------------------
+# else
+    // SystemC 1.2.1beta
+# define DECL_TRACE_METHOD_A(tp) \
+    virtual void trace( const tp& object, const sc_string& name );
+# define DECL_TRACE_METHOD_B(tp) \
+    virtual void trace( const tp& object, const sc_string& name, int width );
+
+    virtual void write_comment (const sc_string &);
+    virtual void trace (const unsigned int &, const sc_string &, const char **);
+
+    DECL_TRACE_METHOD_A( bool )
+    DECL_TRACE_METHOD_B( unsigned char )
+    DECL_TRACE_METHOD_B( short unsigned int )
+    DECL_TRACE_METHOD_B( unsigned int )
+    DECL_TRACE_METHOD_B( long unsigned int )
+    DECL_TRACE_METHOD_B( char )
+    DECL_TRACE_METHOD_B( short int )
+    DECL_TRACE_METHOD_B( int )
+    DECL_TRACE_METHOD_B( long int )
+    DECL_TRACE_METHOD_A( float )
+    DECL_TRACE_METHOD_A( double )
+    DECL_TRACE_METHOD_A( sc_bit )
+    DECL_TRACE_METHOD_A( sc_logic )
+    DECL_TRACE_METHOD_A( sc_bool_vector )
+    DECL_TRACE_METHOD_A( sc_logic_vector )
+    DECL_TRACE_METHOD_A( sc_signal_bool_vector )
+    DECL_TRACE_METHOD_A( sc_signal_logic_vector )
+    DECL_TRACE_METHOD_A( sc_uint_base )
+    DECL_TRACE_METHOD_A( sc_int_base )
+    DECL_TRACE_METHOD_A( sc_unsigned )
+    DECL_TRACE_METHOD_A( sc_signed )
+    DECL_TRACE_METHOD_A( sc_signal_resolved )
+    DECL_TRACE_METHOD_A( sc_signal_resolved_vector )
+    DECL_TRACE_METHOD_A( sc_bv_ns::sc_bv_base )
+    DECL_TRACE_METHOD_A( sc_bv_ns::sc_lv_base )
+# endif
+
+# undef DECL_TRACE_METHOD_A
+# undef DECL_TRACE_METHOD_B
+};
+
+#endif // guard

include/verilated_vpi.h

@@ -0,0 +1,497 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// 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.
+//
+// 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: VPI implementation code
+///
+///	This file must be compiled and linked against all objects
+///	created from Verilator or called by Verilator that use the VPI.
+///
+/// Code available from: http://www.veripool.org/verilator
+///
+//=========================================================================
+
+#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_VPI_ERROR(__FILE__,__LINE__,Verilated::catName("Unsupported VPI function: ",VL_FUNC));
+
+//======================================================================
+// Implementation
+
+// Base VPI handled object
+class VerilatedVpio {
+    // MEM MANGLEMENT
+    static vluint8_t* s_freeHead;
+
+public:
+    // CONSTRUCTORS
+    VerilatedVpio() {}
+    virtual ~VerilatedVpio() {}
+    inline static void* operator new(size_t size) {
+	// We new and delete tons of vpi structures, so keep them around
+	// To simplify our free list, we use a size large enough for all derived types
+	// We reserve word zero for the next pointer, as that's safer in case a
+	// dangling reference to the original remains around.
+	static size_t chunk = 96;
+	if (VL_UNLIKELY(size>chunk)) vl_fatal(__FILE__,__LINE__,"", "increase chunk");
+	if (VL_LIKELY(s_freeHead)) {
+	    vluint8_t* newp = s_freeHead;
+	    s_freeHead = *((vluint8_t**)newp);
+	    return newp+8;
+	} else {
+	    // +8: 8 bytes for next
+	    vluint8_t* newp = (vluint8_t*)(::operator new(chunk+8));
+	    return newp+8;
+	}
+    }
+    inline static void operator delete(void* obj, size_t size) {
+	vluint8_t* oldp = ((vluint8_t*)obj)-8;
+	*((void**)oldp) = s_freeHead;
+	s_freeHead = oldp;
+    }
+    // MEMBERS
+    static inline VerilatedVpio* castp(vpiHandle h) { return dynamic_cast<VerilatedVpio*>((VerilatedVpio*)h); }
+    inline vpiHandle castVpiHandle() { return (vpiHandle)(this); }
+    // ACCESSORS
+    virtual const char* name() { return "<null>"; }
+    virtual const char* fullname() { return "<null>"; }
+    virtual const char* defname() { return "<null>"; }
+    virtual const vluint32_t type() { return 0; }
+    virtual const vluint32_t size() const { return 0; }
+    virtual const VerilatedRange* rangep() const { return NULL; }
+    virtual vpiHandle dovpi_scan() { return 0; }
+};
+
+typedef PLI_INT32 (*VerilatedPliCb)(struct t_cb_data *);
+
+class VerilatedVpioCb : public VerilatedVpio {
+    t_cb_data		m_cbData;
+    s_vpi_value		m_value;
+    QData		m_time;
+public:
+    // cppcheck-suppress uninitVar  // m_value
+    VerilatedVpioCb(const t_cb_data* cbDatap, QData time)
+	: m_cbData(*cbDatap), m_time(time) {
+        m_value.format = cbDatap->value ? cbDatap->value->format : vpiSuppressVal;
+	m_cbData.value = &m_value;
+    }
+    virtual ~VerilatedVpioCb() {}
+    static inline VerilatedVpioCb* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioCb*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiCallback; }
+    vluint32_t reason() const { return m_cbData.reason; }
+    VerilatedPliCb cb_rtnp() const { return m_cbData.cb_rtn; }
+    t_cb_data* cb_datap() { return &(m_cbData); }
+    QData time() const { return m_time; }
+};
+
+class VerilatedVpioConst : public VerilatedVpio {
+    vlsint32_t	m_num;
+public:
+    explicit VerilatedVpioConst(vlsint32_t num) : m_num(num) {}
+    virtual ~VerilatedVpioConst() {}
+    static inline VerilatedVpioConst* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioConst*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiUndefined; }
+    vlsint32_t num() const { return m_num; }
+};
+
+class VerilatedVpioRange : public VerilatedVpio {
+    const VerilatedRange* m_range;
+    vlsint32_t                  m_iteration;
+public:
+    explicit VerilatedVpioRange(const VerilatedRange* range) : m_range(range), m_iteration(0) {}
+    virtual ~VerilatedVpioRange() {}
+    static inline VerilatedVpioRange* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioRange*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiRange; }
+    virtual const vluint32_t size() const { return m_range->elements(); }
+    virtual const VerilatedRange* rangep() const { return m_range; }
+    int iteration() const { return m_iteration; }
+    void iterationInc() { ++m_iteration; }
+    virtual vpiHandle dovpi_scan() {
+	if (!iteration()) {
+	    VerilatedVpioRange* nextp = new VerilatedVpioRange(*this);
+	    nextp->iterationInc();
+	    return ((nextp)->castVpiHandle());
+	} else {
+	    return 0;  // End of list - only one deep
+	}
+    }
+};
+
+class VerilatedVpioScope : public VerilatedVpio {
+    const VerilatedScope*	m_scopep;
+public:
+    explicit VerilatedVpioScope(const VerilatedScope* scopep)
+	: m_scopep(scopep) {}
+    virtual ~VerilatedVpioScope() {}
+    static inline VerilatedVpioScope* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioScope*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiScope; }
+    const VerilatedScope* scopep() const { return m_scopep; }
+    virtual const char* name() { return m_scopep->name(); }
+    virtual const char* fullname() { return m_scopep->name(); }
+};
+
+class VerilatedVpioVar : public VerilatedVpio {
+    const VerilatedVar*		m_varp;
+    const VerilatedScope*	m_scopep;
+    vluint8_t*			m_prevDatap;	// Previous value of data, for cbValueChange
+    union {
+	vluint8_t u8[4];
+	vluint32_t u32;
+    } m_mask;                                   // memoized variable mask
+    vluint32_t			m_entSize;	// memoized variable size
+protected:
+    void*			m_varDatap;	// varp()->datap() adjusted for array entries
+    vlsint32_t			m_index;
+    const VerilatedRange&	get_range() const {
+	// Determine number of dimensions and return outermost
+	return (m_varp->dims()>1) ? m_varp->array() : m_varp->range();
+    }
+public:
+    VerilatedVpioVar(const VerilatedVar* varp, const VerilatedScope* scopep)
+	: m_varp(varp), m_scopep(scopep), m_index(0) {
+	m_prevDatap = NULL;
+	m_mask.u32 = VL_MASK_I(varp->range().elements());
+	m_entSize = varp->entSize();
+	m_varDatap = varp->datap();
+    }
+    virtual ~VerilatedVpioVar() {
+	if (m_prevDatap) { delete [] m_prevDatap; m_prevDatap = NULL; }
+    }
+    static inline VerilatedVpioVar* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioVar*>((VerilatedVpio*)h); }
+    const VerilatedVar* varp() const { return m_varp; }
+    const VerilatedScope* scopep() const { return m_scopep; }
+    vluint32_t mask() const { return m_mask.u32; }
+    vluint8_t mask_byte(int idx) { return m_mask.u8[idx & 3]; }
+    vluint32_t entSize() const { return m_entSize; }
+    const vluint32_t index() { return m_index; }
+    virtual const vluint32_t type() {
+      if (varp()->vldir() != vpiNoDirection) return vpiPort;
+      return (varp()->dims()>1) ? vpiMemory : vpiReg; /* but might be wire, logic */
+    }
+    virtual const vluint32_t size() const { return get_range().elements(); }
+    virtual const VerilatedRange* rangep() const { return &get_range(); }
+    virtual const char* name() { return m_varp->name(); }
+    virtual const char* fullname() {
+	VL_STATIC_OR_THREAD string out;
+	out = string(m_scopep->name())+"."+name();
+	return out.c_str();
+    }
+    void* prevDatap() const { return m_prevDatap; }
+    void* varDatap() const { return m_varDatap; }
+    void createPrevDatap() {
+	if (VL_UNLIKELY(!m_prevDatap)) {
+	    m_prevDatap = new vluint8_t [entSize()];
+	    memcpy(prevDatap(), varp()->datap(), entSize());
+	}
+    }
+};
+
+class VerilatedVpioMemoryWord : public VerilatedVpioVar {
+public:
+    VerilatedVpioMemoryWord(const VerilatedVar* varp, const VerilatedScope* scopep,
+			  vlsint32_t index, int offset)
+	: VerilatedVpioVar(varp, scopep) {
+	m_index = index;
+	m_varDatap = ((vluint8_t*)varp->datap()) + entSize()*offset;
+    }
+    virtual ~VerilatedVpioMemoryWord() {}
+    static inline VerilatedVpioMemoryWord* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioMemoryWord*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiMemoryWord; }
+    virtual const vluint32_t size() const { return varp()->range().elements(); }
+    virtual const VerilatedRange* rangep() const { return &(varp()->range()); }
+    virtual const char* fullname() {
+	VL_STATIC_OR_THREAD string out;
+	char num[20]; sprintf(num,"%d",m_index);
+	out = string(scopep()->name())+"."+name()+"["+num+"]";
+	return out.c_str();
+    }
+};
+
+class VerilatedVpioVarIter : public VerilatedVpio {
+    const VerilatedScope*	m_scopep;
+    VerilatedVarNameMap::iterator m_it;
+    bool m_started;
+public:
+    explicit VerilatedVpioVarIter(const VerilatedScope* scopep)
+	: m_scopep(scopep), m_started(false) {  }
+    virtual ~VerilatedVpioVarIter() {}
+    static inline VerilatedVpioVarIter* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioVarIter*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiIterator; }
+    virtual vpiHandle dovpi_scan() {
+	if (VL_LIKELY(m_scopep->varsp())) {
+	    VerilatedVarNameMap* varsp = m_scopep->varsp();
+	    if (VL_UNLIKELY(!m_started)) { m_it = varsp->begin(); m_started=true; }
+	    else if (VL_UNLIKELY(m_it == varsp->end())) return 0;
+	    else ++m_it;
+	    if (m_it == varsp->end()) return 0;
+	    return ((new VerilatedVpioVar(&(m_it->second), m_scopep))
+		    ->castVpiHandle());
+	} else {
+	    return 0;  // End of list - only one deep
+	}
+    }
+};
+
+class VerilatedVpioMemoryWordIter : public VerilatedVpio {
+    const vpiHandle		m_handle;
+    const VerilatedVar*		m_varp;
+    vlsint32_t                  m_iteration;
+    vlsint32_t                  m_direction;
+    bool                        m_done;
+public:
+    VerilatedVpioMemoryWordIter(const vpiHandle handle, const VerilatedVar* varp)
+	: m_handle(handle), m_varp(varp), m_iteration(varp->array().right()), m_direction(VL_LIKELY(varp->array().left()>varp->array().right())?1:-1), m_done(false) {  }
+    virtual ~VerilatedVpioMemoryWordIter() {}
+    static inline VerilatedVpioMemoryWordIter* castp(vpiHandle h) { return dynamic_cast<VerilatedVpioMemoryWordIter*>((VerilatedVpio*)h); }
+    virtual const vluint32_t type() { return vpiIterator; }
+    void iterationInc() { if (!(m_done = (m_iteration == m_varp->array().left()))) m_iteration+=m_direction; }
+    virtual vpiHandle dovpi_scan() {
+	vpiHandle result;
+	if (m_done) return 0;
+	result = vpi_handle_by_index(m_handle, m_iteration);
+	iterationInc();
+	return result;
+    }
+};
+
+//======================================================================
+
+struct VerilatedVpiTimedCbsCmp {
+    /// Ordering sets keyed by time, then callback descriptor
+    bool operator() (const pair<QData,VerilatedVpioCb*>& a,
+		     const pair<QData,VerilatedVpioCb*>& b) const {
+	if (a.first < b.first) return 1;
+	if (a.first > b.first) return 0;
+	return a.second < b.second;
+    }
+};
+
+class VerilatedVpiError;
+
+class VerilatedVpi {
+    enum { CB_ENUM_MAX_VALUE = cbAtEndOfSimTime+1 };	// Maxium callback reason
+    typedef list<VerilatedVpioCb*> VpioCbList;
+    typedef set<pair<QData,VerilatedVpioCb*>,VerilatedVpiTimedCbsCmp > VpioTimedCbs;
+
+    struct product_info {
+	PLI_BYTE8* product;
+    };
+
+    VpioCbList		m_cbObjLists[CB_ENUM_MAX_VALUE];	// Callbacks for each supported reason
+    VpioTimedCbs	m_timedCbs;	// Time based callbacks
+    VerilatedVpiError*  m_errorInfop;	// Container for vpi error info
+
+    static VerilatedVpi s_s;		// Singleton
+
+public:
+    VerilatedVpi() { m_errorInfop=NULL; }
+    ~VerilatedVpi() {}
+    static void cbReasonAdd(VerilatedVpioCb* vop) {
+	if (vop->reason() == cbValueChange) {
+	    if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(vop->cb_datap()->obj)) {
+		varop->createPrevDatap();
+	    }
+	}
+	if (VL_UNLIKELY(vop->reason() >= CB_ENUM_MAX_VALUE)) vl_fatal(__FILE__,__LINE__,"", "vpi bb reason too large");
+	s_s.m_cbObjLists[vop->reason()].push_back(vop);
+    }
+    static void cbTimedAdd(VerilatedVpioCb* vop) {
+	s_s.m_timedCbs.insert(make_pair(vop->time(), vop));
+    }
+    static void cbReasonRemove(VerilatedVpioCb* cbp) {
+	VpioCbList& cbObjList = s_s.m_cbObjLists[cbp->reason()];
+	// We do not remove it now as we may be iterating the list,
+	// instead set to NULL and will cleanup later
+	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end(); ++it) {
+            if (*it == cbp) *it = NULL;
+	}
+    }
+    static void cbTimedRemove(VerilatedVpioCb* cbp) {
+	VpioTimedCbs::iterator it=s_s.m_timedCbs.find(make_pair(cbp->time(),cbp));
+	if (VL_LIKELY(it != s_s.m_timedCbs.end())) {
+	    s_s.m_timedCbs.erase(it);
+	}
+    }
+    static void callTimedCbs() {
+	QData time = VL_TIME_Q();
+	for (VpioTimedCbs::iterator it=s_s.m_timedCbs.begin(); it!=s_s.m_timedCbs.end(); ) {
+	    if (VL_UNLIKELY(it->first <= time)) {
+		VerilatedVpioCb* vop = it->second;
+		++it;  // iterator may be deleted by callback
+		VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  timed_callback %p\n",vop););
+		(vop->cb_rtnp()) (vop->cb_datap());
+	    }
+	    else { ++it; }
+	}
+    }
+    static QData cbNextDeadline() {
+	VpioTimedCbs::iterator it=s_s.m_timedCbs.begin();
+	if (VL_LIKELY(it!=s_s.m_timedCbs.end())) {
+	    return it->first;
+	} else {
+	    return ~VL_ULL(0);  // maxquad
+	}
+    }
+    static void callCbs(vluint32_t reason) {
+	VpioCbList& cbObjList = s_s.m_cbObjLists[reason];
+	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end();) {
+	    if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
+		it = cbObjList.erase(it);
+		continue;
+	    }
+	    VerilatedVpioCb* vop = *it++;
+	    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  reason_callback %d %p\n",reason,vop););
+	    (vop->cb_rtnp()) (vop->cb_datap());
+	}
+    }
+    static void callValueCbs() {
+	VpioCbList& cbObjList = s_s.m_cbObjLists[cbValueChange];
+        set<VerilatedVpioVar*> update; // set of objects to update after callbacks
+	for (VpioCbList::iterator it=cbObjList.begin(); it!=cbObjList.end();) {
+	    if (VL_UNLIKELY(!*it)) { // Deleted earlier, cleanup
+		it = cbObjList.erase(it);
+		continue;
+	    }
+	    VerilatedVpioCb* vop = *it++;
+	    if (VerilatedVpioVar* varop = VerilatedVpioVar::castp(vop->cb_datap()->obj)) {
+		void* newDatap = varop->varDatap();
+		void* prevDatap = varop->prevDatap();  // Was malloced when we added the callback
+		VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  value_test %s v[0]=%d/%d %p %p\n",
+					  varop->fullname(), *((CData*)newDatap), *((CData*)prevDatap),
+					  newDatap, prevDatap););
+		if (memcmp(prevDatap, newDatap, varop->entSize())) {
+		    VL_DEBUG_IF_PLI(VL_PRINTF("-vltVpi:  value_callback %p %s v[0]=%d\n",
+					      vop,varop->fullname(), *((CData*)newDatap)););
+                    update.insert(varop);
+		    vpi_get_value(vop->cb_datap()->obj, vop->cb_datap()->value);
+		    (vop->cb_rtnp()) (vop->cb_datap());
+		}
+	    }
+	}
+	for (set<VerilatedVpioVar*>::iterator it=update.begin(); it!=update.end(); ++it) {
+	    memcpy((*it)->prevDatap(), (*it)->varDatap(), (*it)->entSize());
+	}
+    }
+
+    static VerilatedVpiError* error_info(); // getter for vpi error info
+};
+
+#define _VL_VPI_ERROR_SET \
+    do { \
+        va_list args; \
+        va_start(args, message); \
+        VL_VSNPRINTF(m_buff, sizeof(m_buff), message.c_str(), args); \
+        va_end(args); \
+    } while (0)
+
+class VerilatedVpiError {
+    //// Container for vpi error info
+
+    t_vpi_error_info m_errorInfo;
+    bool             m_flag;
+    char             m_buff[VL_VPI_LINE_SIZE];
+    void setError(PLI_BYTE8 *message, PLI_BYTE8 *code, PLI_BYTE8 *file, PLI_INT32 line) {
+	m_errorInfo.message = message;
+	m_errorInfo.file = file;
+	m_errorInfo.line = line;
+	m_errorInfo.code = code;
+	do_callbacks();
+    }
+    void do_callbacks() {
+        if (getError()->level >= vpiError && Verilated::fatalOnVpiError()) {
+          // Stop on vpi error/unsupported
+          vpi_unsupported();
+	}
+        // We need to run above code first because in the case that the callback executes further vpi
+        // functions we will loose the error as it will be overwritten.
+	VerilatedVpi::callCbs(cbPLIError);
+    }
+public:
+
+    VerilatedVpiError() : m_flag(false) {
+	m_buff[0] = '\0';
+	m_errorInfo.product = (PLI_BYTE8*)Verilated::productName();
+    }
+    ~VerilatedVpiError() {}
+    static void selfTest();
+    VerilatedVpiError* setMessage(PLI_INT32 level) {
+	m_flag=true;
+	m_errorInfo.level = level;
+        return this;
+    }
+    void setMessage(string file, PLI_INT32 line, string message, ...) {
+	static VL_THREAD string filehold;
+        _VL_VPI_ERROR_SET;
+        m_errorInfo.state = vpiPLI;
+	filehold = file;
+        setError((PLI_BYTE8*)m_buff, NULL, (PLI_BYTE8*)filehold.c_str(), line);
+    }
+    p_vpi_error_info getError() {
+	if (m_flag) return &m_errorInfo;
+	return NULL;
+    }
+    void resetError() {
+	m_flag=false;
+    }
+    static void vpi_unsupported() {
+	// Not supported yet
+	p_vpi_error_info error_info_p = VerilatedVpi::error_info()->getError();
+	if (error_info_p) {
+	    vl_fatal(error_info_p->file, error_info_p->line, "", error_info_p->message);
+	    return;
+	}
+        vl_fatal(__FILE__, __LINE__, "", "vpi_unsupported called without error info set");
+    }
+    static const char* strFromVpiVal(PLI_INT32 vpiVal);
+    static const char* strFromVpiObjType(PLI_INT32 vpiVal);
+    static const char* strFromVpiMethod(PLI_INT32 vpiVal);
+    static const char* strFromVpiCallbackReason(PLI_INT32 vpiVal);
+    static const char* strFromVpiProp(PLI_INT32 vpiVal);
+};
+
+//======================================================================
+
+#endif // Guard

include/verilatedos.h

@@ -1,7 +1,7 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -34,19 +34,38 @@
 // Compiler pragma abstraction
 
 #ifdef __GNUC__
-# define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
 # define VL_ATTR_ALIGNED(alignment) __attribute__ ((aligned (alignment)))
+# define VL_ATTR_ALWINLINE __attribute__ ((always_inline))
 # define VL_ATTR_NORETURN __attribute__ ((noreturn))
+# ifdef _WIN32
+#  define VL_ATTR_PRINTF(fmtArgNum)  // GCC with MS runtime will fool the print arg checker
+# else
+#  define VL_ATTR_PRINTF(fmtArgNum) __attribute__ ((format (printf, fmtArgNum, fmtArgNum+1)))
+# endif
 # define VL_ATTR_UNUSED __attribute__ ((unused))
+# define VL_FUNC  __func__
 # define VL_LIKELY(x)	__builtin_expect(!!(x), 1)
 # define VL_UNLIKELY(x)	__builtin_expect(!!(x), 0)
 # define VL_PREFETCH_RD(p) __builtin_prefetch((p),0)
 # define VL_PREFETCH_RW(p) __builtin_prefetch((p),1)
+#elif defined(_MSC_VER)
+# define VL_ATTR_ALIGNED(alignment)
+# define VL_ATTR_ALWINLINE
+# define VL_ATTR_NORETURN
+# define VL_ATTR_PRINTF(fmtArgNum)
+# define VL_ATTR_UNUSED
+# define VL_FUNC  __FUNCTION__
+# define VL_LIKELY(x)	(!!(x))
+# define VL_UNLIKELY(x)	(!!(x))
+# define VL_PREFETCH_RD(p)
+# define VL_PREFETCH_RW(p)
 #else
-# define VL_ATTR_PRINTF(fmtArgNum)	///< Function with printf format checking
 # define VL_ATTR_ALIGNED(alignment)	///< Align structure to specified byte alignment
+# define VL_ATTR_ALWINLINE		///< Inline, even when not optimizing
 # define VL_ATTR_NORETURN		///< Function does not ever return
+# define VL_ATTR_PRINTF(fmtArgNum)	///< Function with printf format checking
 # define VL_ATTR_UNUSED			///< Function that may be never used
+# define VL_FUNC "__func__"		///< Name of current function for error macros
 # define VL_LIKELY(x)	(!!(x))		///< Boolean expression more often true than false
 # define VL_UNLIKELY(x)	(!!(x))		///< Boolean expression more often false than true
 # define VL_PREFETCH_RD(p)		///< Prefetch data with read intent
@@ -59,8 +78,12 @@
 # else
 #  error "Unsupported compiler for VL_THREADED: No thread-local declarator"
 # endif
+# define VL_STATIC_OR_THREAD		///< Static if unthreaded, as some strings can be faster
+//					///< if non-dynamic and can't do "static VL_THREAD string"
 #else
 # define VL_THREAD			///< Storage class for thread-local storage
+# define VL_STATIC_OR_THREAD static	///< Static if unthreaded, as some strings can be faster
+//					///< if non-dynamic and can't do "static VL_THREAD string"
 #endif
 
 #ifdef _MSC_VER
@@ -72,40 +95,143 @@
 // 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
+
+#ifndef VL_WARNINGS
+# ifdef _MSC_VER
+#  pragma warning(disable:4099)	// C4099: type name first seen using 'class' now seen using 'struct' (V3AstNode)
+#  pragma warning(disable:4100)	// C4100: unreferenced formal parameter (L4)
+#  pragma warning(disable:4127)	// C4127: conditional expression is constant (L4)
+#  pragma warning(disable:4146)	// C4146: unary minus operator applied to unsigned type, result still unsigned
+#  pragma warning(disable:4189)	// C4189: local variable is initialized but not referenced (L4)
+#  pragma warning(disable:4244)	// C4244: conversion from 'uint64_t' to 'uint_32_t', possible loss of data
+#  pragma warning(disable:4245)	// C4245: conversion from 'int' to 'unsigned', signed/unsigned mismatch
+#  pragma warning(disable:4996)	// C4996: sscanf/fopen/etc may be unsafe
+# endif
+#endif
+
 //=========================================================================
 // Basic integer types
 
 #ifdef VL_UINTS_DEFINED
 #elif defined(__CYGWIN__)
+
 # include <stdint.h>
 typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward compatibility)
 typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
-typedef unsigned long           uint32_t;	///< 32-bit unsigned type (backward compatibility)
 typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
 typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-typedef long  			vlsint32_t;	///< 32-bit signed type
-typedef unsigned long           vluint32_t;	///< 32-bit unsigned type
+# 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
+typedef unsigned long		uint32_t;	///< 32-bit unsigned type (backward compatibility)
+typedef long			vlsint32_t;	///< 32-bit signed type
+typedef unsigned long		vluint32_t;	///< 32-bit unsigned type
+# endif
+# if defined(__WORDSIZE) && (__WORDSIZE == 64)
+typedef long			vlsint64_t;	///< 64-bit signed type
+typedef unsigned long		vluint64_t;	///< 64-bit unsigned type
+# else
 typedef long long		vlsint64_t;	///< 64-bit signed type
-typedef unsigned long long      vluint64_t;	///< 64-bit unsigned type
+typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
+# endif
+
 #elif defined(_WIN32) && defined(_MSC_VER)
-typedef unsigned char           uint8_t;	///< 8-bit unsigned type (backward compatibility)
-typedef unsigned short int      uint16_t;	///< 16-bit unsigned type (backward compatibility)
-typedef unsigned int		uint32_t;	///< 32-bit unsigned type (backward compatibility)
-typedef unsigned char           vluint8_t;	///< 8-bit unsigned type
-typedef unsigned short int      vluint16_t;	///< 16-bit unsigned type
-typedef int			vlsint32_t;	///< 32-bit signed type
-typedef unsigned int            vluint32_t;	///< 32-bit unsigned type
-typedef __int64			vlsint64_t;	///< 64-bit signed type
-typedef unsigned __int64        vluint64_t;	///< 64-bit unsigned type
+
+typedef unsigned __int8		uint8_t;	///< 8-bit unsigned type (backward compatibility)
+typedef unsigned __int16	uint16_t;	///< 16-bit unsigned type (backward compatibility)
+typedef unsigned __int32	uint32_t;	///< 32-bit unsigned type (backward compatibility)
+typedef unsigned __int8		vluint8_t;	///< 8-bit unsigned type
+typedef unsigned __int16	vluint16_t;	///< 16-bit unsigned type
+typedef signed   __int32	vlsint32_t;	///< 32-bit signed type
+typedef unsigned __int32	vluint32_t;	///< 32-bit unsigned type
+typedef signed   __int64	vlsint64_t;	///< 64-bit signed type
+typedef unsigned __int64	vluint64_t;	///< 64-bit unsigned type
+
+# ifndef _SSIZE_T_DEFINED
+#  ifdef  _WIN64
+typedef signed   __int64        ssize_t;        ///< signed size_t; returned from read()
+#  else
+typedef signed   __int32        ssize_t;        ///< signed size_t; returned from read()
+#  endif
+# endif
+
 #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
 typedef int			vlsint32_t;	///< 32-bit signed type
 typedef uint32_t		vluint32_t;	///< 32-bit signed type
+# if defined(__WORDSIZE) && (__WORDSIZE == 64)
+typedef long			vlsint64_t;	///< 64-bit signed type
+typedef unsigned long		vluint64_t;	///< 64-bit unsigned type
+# else
 typedef long long		vlsint64_t;	///< 64-bit signed type
 typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
+# endif
+#endif
+
+//=========================================================================
+// Printing printf/scanf formats
+// Alas cinttypes isn't that standard yet
+
+#ifdef _WIN32
+# define VL_PRI64 "I64"
+#else // Linux or compliant Unix flavors
+# if defined(__WORDSIZE) && (__WORDSIZE == 64)
+#  define VL_PRI64 "l"
+# else
+#  define VL_PRI64 "ll"
+# 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
 
 //=========================================================================
@@ -144,6 +270,18 @@ typedef unsigned long long	vluint64_t;	///< 64-bit unsigned type
 #define VL_BITBIT_I(bit)	((bit)&VL_SIZEBITS_I)	///< Bit number for a bit in a long
 #define VL_BITBIT_Q(bit)	((bit)&VL_SIZEBITS_Q)	///< Bit number for a bit in a quad
 
+//=========================================================================
+// Floating point
+// #defines, to avoid requiring math.h on all compile runs
+
+#ifdef _MSC_VER
+# define VL_TRUNC(n) (((n)<0) ? ceil((n))     : floor((n)))
+# define VL_ROUND(n) (((n)<0) ? ceil((n)-0.5) : floor((n)+0.5))
+#else
+# define VL_TRUNC(n) trunc(n)
+# define VL_ROUND(n) round(n)
+#endif
+
 //=========================================================================
 
 #endif /*guard*/

include/vltstd/svdpi.h

@@ -0,0 +1,495 @@
+/* -*- C -*-
+ *
+ * svdpi.h
+ *
+ * SystemVerilog Direct Programming Interface (DPI).
+ *
+ * This file contains the constant definitions, structure definitions,
+ * and routine declarations used by SystemVerilog DPI.
+ *
+ * This file is from the SystemVerilog IEEE 1800-2012 Annex I.
+ */
+
+#ifndef INCLUDED_SVDPI
+#define INCLUDED_SVDPI
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Define size-critical types on all OS platforms. */
+#if defined (_MSC_VER)
+typedef unsigned __int64 uint64_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int8 uint8_t;
+typedef signed __int64 int64_t;
+typedef signed __int32 int32_t;
+typedef signed __int8 int8_t;
+#elif defined(__MINGW32__)
+#include <stdint.h>
+#elif defined(__APPLE__)
+#include <stdint.h>
+#elif defined(__linux) || (defined(__APPLE__) && defined(__MACH__))
+#include <inttypes.h>
+#else
+#include <sys/types.h>
+#endif
+
+/* Use to import a symbol into dll */
+#ifndef DPI_DLLISPEC
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
+#define DPI_DLLISPEC __declspec(dllimport)
+#else
+#define DPI_DLLISPEC
+#endif
+#endif
+
+/* Use to export a symbol from dll */
+#ifndef DPI_DLLESPEC
+#if (defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN__))
+#define DPI_DLLESPEC __declspec(dllexport)
+#else
+#define DPI_DLLESPEC
+#endif
+#endif
+
+/* Use to mark a function as external */
+#ifndef DPI_EXTERN
+#define DPI_EXTERN
+#endif
+
+#ifndef DPI_PROTOTYPES
+#define DPI_PROTOTYPES
+/* object is defined imported by the application */
+#define XXTERN DPI_EXTERN DPI_DLLISPEC
+/* object is exported by the application */
+#define EETERN DPI_EXTERN DPI_DLLESPEC
+#endif
+
+/* canonical    representation */
+#define sv_0    0
+#define sv_1    1
+#define sv_z    2
+#define sv_x    3
+
+/* common type for 'bit' and 'logic' scalars. */
+typedef uint8_t svScalar;
+typedef svScalar svBit; /* scalar */
+typedef svScalar svLogic; /* scalar */
+
+/*
+ * DPI representation of packed arrays.
+ * 2-state and 4-state vectors, exactly the same as PLI's avalue/bvalue.
+ */
+#ifndef VPI_VECVAL
+#define VPI_VECVAL
+typedef struct t_vpi_vecval {
+    uint32_t aval;
+    uint32_t bval;
+} s_vpi_vecval, *p_vpi_vecval;
+#endif
+
+/* (a chunk of) packed logic array */
+typedef s_vpi_vecval svLogicVecVal;
+
+/* (a chunk of) packed bit array */
+typedef uint32_t svBitVecVal;
+
+/* Number of chunks required to represent the given width packed array */
+#define SV_PACKED_DATA_NELEMS(WIDTH) (((WIDTH) + 31) >> 5)
+
+/*
+ * Because the contents of the unused bits is undetermined,
+ * the following macros can be handy.
+ */
+#define SV_MASK(N) (~(-1 << (N)))
+
+#define SV_GET_UNSIGNED_BITS(VALUE, N) \
+    ((N) == 32 ? (VALUE) : ((VALUE) & SV_MASK(N)))
+
+#define SV_GET_SIGNED_BITS(VALUE, N) \
+    ((N) == 32 ? (VALUE) : \
+    (((VALUE) & (1 << (N))) ? ((VALUE) | ~SV_MASK(N)) : ((VALUE) & SV_MASK(N))))
+
+/*
+ * Implementation-dependent representation.
+ */
+/*
+ * Return implementation version information string ("1800-2005" or "SV3.1a").
+ */
+XXTERN const char* svDpiVersion();
+
+/* a handle to a scope (an instance of a module or interface) */
+XXTERN typedef void* svScope;
+
+/* a handle to a generic object (actually, unsized array) */
+XXTERN typedef void* svOpenArrayHandle;
+
+/*
+ * Bit-select utility functions.
+ *
+ * Packed arrays are assumed to be indexed n-1:0,
+ * where 0 is the index of LSB
+ */
+
+/* s=source, i=bit-index */
+XXTERN svBit svGetBitselBit(const svBitVecVal* s, int i);
+XXTERN svLogic svGetBitselLogic(const svLogicVecVal* s, int i);
+
+/* d=destination, i=bit-index, s=scalar */
+XXTERN void svPutBitselBit(svBitVecVal* d, int i, svBit s);
+XXTERN void svPutBitselLogic(svLogicVecVal* d, int i, svLogic s);
+
+/*
+ * Part-select utility functions.
+ *
+ * A narrow (<=32 bits) part-select is extracted from the
+ * source representation and written into the destination word.
+ *
+ * Normalized ranges and indexing [n-1:0] are used for both arrays.
+ *
+ * s=source, d=destination, i=starting bit index, w=width
+ * like for variable part-selects; limitations: w <= 32
+ */
+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);
+
+/*
+ * Open array querying functions
+ * These functions are modeled upon the SystemVerilog array
+ * querying functions and use the same semantics.
+ *
+ * If the dimension is 0, then the query refers to the
+ * packed part of an array (which is one-dimensional).
+ * Dimensions > 0 refer to the unpacked part of an array.
+ */
+/* h= handle to open array, d=dimension */
+XXTERN int svLeft(const svOpenArrayHandle h, int d);
+XXTERN int svRight(const svOpenArrayHandle h, int d);
+XXTERN int svLow(const svOpenArrayHandle h, int d);
+XXTERN int svHigh(const svOpenArrayHandle h, int d);
+XXTERN int svIncrement(const svOpenArrayHandle h, int d);
+XXTERN int svSize(const svOpenArrayHandle h, int d);
+XXTERN int svDimensions(const svOpenArrayHandle h);
+
+/*
+ * Pointer to the actual representation of the whole array of any type
+ * NULL if not in C layout
+ */
+XXTERN void *svGetArrayPtr(const svOpenArrayHandle);
+
+/* total size in bytes or 0 if not in C layout */
+XXTERN int svSizeOfArray(const svOpenArrayHandle);
+
+/*
+ * Return a pointer to an element of the array
+ * or NULL if index outside the range or null pointer
+ */
+XXTERN void *svGetArrElemPtr(const svOpenArrayHandle, int indx1, ...);
+
+/* specialized versions for 1-, 2- and 3-dimensional arrays: */
+XXTERN void *svGetArrElemPtr1(const svOpenArrayHandle, int indx1);
+XXTERN void *svGetArrElemPtr2(const svOpenArrayHandle, int indx1, int indx2);
+XXTERN void *svGetArrElemPtr3(const svOpenArrayHandle, int indx1, int indx2,
+        int indx3);
+
+/*
+ * Functions for copying between simulator storage and user space.
+ * These functions copy the whole packed array in either direction.
+ * The user is responsible for allocating an array to hold the
+ * canonical representation.
+ */
+
+/* s=source, d=destination */
+/* From user space into simulator storage */
+XXTERN void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+        int indx1, ...);
+XXTERN void svPutBitArrElem1VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+        int indx1);
+XXTERN void svPutBitArrElem2VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+        int indx1, int indx2);
+XXTERN void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
+        int indx1, int indx2, int indx3);
+
+XXTERN void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+        int indx1, ...);
+XXTERN void svPutLogicArrElem1VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+        int indx1);
+XXTERN void svPutLogicArrElem2VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+        int indx1, int indx2);
+XXTERN void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
+        int indx1, int indx2, int indx3);
+
+/* From simulator storage into user space */
+XXTERN void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
+        int indx1, ...);
+XXTERN void svGetBitArrElem1VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+        int indx1);
+XXTERN void svGetBitArrElem2VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+        int indx1, int indx2);
+XXTERN void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s,
+        int indx1, int indx2, int indx3);
+XXTERN void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+        int indx1, ...);
+XXTERN void svGetLogicArrElem1VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+        int indx1);
+XXTERN void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+        int indx1, int indx2);
+XXTERN void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
+        int indx1, int indx2, int indx3);
+
+XXTERN   svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...);
+XXTERN   svBit svGetBitArrElem1(const svOpenArrayHandle s, int indx1);
+XXTERN   svBit svGetBitArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
+XXTERN   svBit svGetBitArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
+          int indx3);
+XXTERN   svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...);
+XXTERN   svLogic svGetLogicArrElem1(const svOpenArrayHandle s, int indx1);
+XXTERN   svLogic svGetLogicArrElem2(const svOpenArrayHandle s, int indx1, int indx2);
+XXTERN   svLogic svGetLogicArrElem3(const svOpenArrayHandle s, int indx1, int indx2,
+          int indx3);
+XXTERN   void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1,
+          ...);
+XXTERN   void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1);
+XXTERN   void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1,
+          int indx2);
+XXTERN   void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1,
+          int indx2, int indx3);
+XXTERN   void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...);
+XXTERN   void svPutBitArrElem1(const svOpenArrayHandle d, svBit value, int indx1);
+XXTERN   void svPutBitArrElem2(const svOpenArrayHandle d, svBit value, int indx1,
+          int indx2);
+XXTERN   void svPutBitArrElem3(const svOpenArrayHandle d, svBit value, int indx1,
+          int indx2, int indx3);
+
+/* Functions for working with DPI context */
+
+/*
+ * Retrieve the active instance scope currently associated with the executing
+ * imported function. Unless a prior call to svSetScope has occurred, this
+ * is the scope of the function's declaration site, not call site.
+ * Returns NULL if called from C code that is *not* an imported function.
+ */
+XXTERN svScope svGetScope();
+
+/*
+ * Set context for subsequent export function execution.
+ * This function must be called before calling an export function, unless
+ * the export function is called while executing an import function. In that
+ * case the export function shall inherit the scope of the surrounding import
+ * function. This is known as the "default scope".
+ * The return is the previous active scope (per svGetScope)
+ */
+XXTERN svScope svSetScope(const svScope scope);
+
+/* Gets the fully qualified name of a scope handle */
+XXTERN const char* svGetNameFromScope(const svScope);
+
+/*
+ * Retrieve svScope to instance scope of an arbitrary function declaration.
+ * (can be either module, program, interface, or generate scope)
+ * The return value shall be NULL for unrecognized scope names.
+ */
+XXTERN svScope svGetScopeFromName(const char* scopeName);
+
+/*
+ * Store an arbitrary user data pointer for later retrieval by svGetUserData()
+ * The userKey is generated by the user. It must be guaranteed by the user to
+ * be unique from all other userKey's for all unique data storage requirements
+ * It is recommended that the address of static functions or variables in the
+ * user's C code be used as the userKey.
+ * It is illegal to pass in NULL values for either the scope or userData
+ * arguments. It is also an error to call svPutUserData() with an invalid
+ * svScope. This function returns -1 for all error cases, 0 upon success. It is
+ * suggested that userData values of 0 (NULL) not be used as otherwise it can
+ * be impossible to discern error status returns when calling svGetUserData()
+ */
+XXTERN int svPutUserData(const svScope scope, void *userKey, void* userData);
+
+/*
+ * Retrieve an arbitrary user data pointer that was previously
+ * stored by a call to svPutUserData(). See the comment above
+ * svPutUserData() for an explanation of userKey, as well as
+ * restrictions on NULL and illegal svScope and userKey values.
+ * This function returns NULL for all error cases, 0 upon success.
+ * This function also returns NULL in the event that a prior call
+ * to svPutUserData() was never made.
+ */
+XXTERN void* svGetUserData(const svScope scope, void* userKey);
+
+/*
+ * Returns the file and line number in the SV code from which the import call
+ * was made. If this information available, returns TRUE and updates fileName
+ * and lineNumber to the appropriate values. Behavior is unpredictable if
+ * fileName or lineNumber are not appropriate pointers. If this information is
+ * not available return FALSE and contents of fileName and lineNumber not
+ * modified. Whether this information is available or not is implementation-
+ * specific. Note that the string provided (if any) is owned by the SV
+ * implementation and is valid only until the next call to any SV function.
+ * Applications must not modify this string or free it
+ */
+XXTERN int svGetCallerInfo(const char** fileName, int *lineNumber);
+
+/*
+ * Returns 1 if the current execution thread is in the disabled state.
+ * Disable protocol must be adhered to if in the disabled state.
+ */
+XXTERN int svIsDisabledState();
+
+/*
+ * Imported functions call this API function during disable processing to
+ * acknowledge that they are correctly participating in the DPI disable protocol.
+ * This function must be called before returning from an imported function that is
+ * in the disabled state.
+ */
+XXTERN void svAckDisabledState();
+
+/*
+ **********************************************************
+ * DEPRECATED PORTION OF FILE STARTS FROM HERE.
+ * IEEE-1800-compliant tools may not provide
+ * support for the following functionality.
+ **********************************************************
+ */
+
+/*
+ * Canonical representation of packed arrays
+ * 2-state and 4-state vectors, modeled upon PLI's avalue/bvalue
+ */
+#define SV_CANONICAL_SIZE(WIDTH) (((WIDTH)+31)>>5)
+typedef unsigned int svBitVec32;/* (a chunk of) packed bit array */
+typedef struct { unsigned int c; unsigned int d;}
+svLogicVec32; /* (a chunk of) packed logic array */
+
+/* reference to a standalone packed array */
+typedef void* svBitPackedArrRef;
+typedef void* svLogicPackedArrRef;
+
+/*
+ * total size in bytes of the simulator's representation of a packed array
+ * width in bits
+ */
+XXTERN int svSizeOfBitPackedArr(int width);
+XXTERN int svSizeOfLogicPackedArr(int width);
+
+/* Translation between the actual representation and the canonical representation */
+
+/* s=source, d=destination, w=width */
+/* actual <-- canonical */
+XXTERN void svPutBitVec32(svBitPackedArrRef d, const svBitVec32* s, int w);
+XXTERN void svPutLogicVec32(svLogicPackedArrRef d, const svLogicVec32* s, int w);
+
+/* canonical <-- actual */
+XXTERN void svGetBitVec32(svBitVec32* d, const svBitPackedArrRef s, int w);
+XXTERN void svGetLogicVec32(svLogicVec32* d, const svLogicPackedArrRef s, int w);
+
+/*
+ * Bit-select functions
+ * Packed arrays are assumed to be indexed n-1:0,
+ * where 0 is the index of LSB
+ */
+
+/* s=source, i=bit-index */
+XXTERN svBit svGetSelectBit(const svBitPackedArrRef s, int i);
+XXTERN svLogic svGetSelectLogic(const svLogicPackedArrRef s, int i);
+
+/* d=destination, i=bit-index, s=scalar */
+XXTERN void svPutSelectBit(svBitPackedArrRef d, int i, svBit s);
+XXTERN void svPutSelectLogic(svLogicPackedArrRef d, int i, svLogic s);
+
+/*
+ * functions for part-select
+ *
+ * a narrow (<=32 bits) part-select is copied between
+ * the implementation representation and a single chunk of
+ * canonical representation
+ * Normalized ranges and indexing [n-1:0] are used for both arrays:
+ * the array in the implementation representation and the canonical array.
+ *
+ * s=source, d=destination, i=starting bit index, w=width
+ * like for variable part-selects; limitations: w <= 32
+ */
+
+/* canonical <-- actual */
+XXTERN void svGetPartSelectBit(svBitVec32* d, const svBitPackedArrRef s,
+        int i, int w);
+XXTERN svBitVec32 svGetBits(const svBitPackedArrRef s, int i, int w);
+XXTERN svBitVec32 svGet32Bits(const svBitPackedArrRef s, int i); /* 32-bits */
+
+XXTERN uint64_t svGet64Bits(const svBitPackedArrRef s, int i);
+
+/* 64-bits */
+XXTERN void svGetPartSelectLogic(svLogicVec32* d, const svLogicPackedArrRef s,
+        int i, int w);
+/* actual <-- canonical */
+XXTERN void svPutPartSelectBit(svBitPackedArrRef d, const svBitVec32 s,
+        int i, int w);
+XXTERN void svPutPartSelectLogic(svLogicPackedArrRef d, const svLogicVec32* s,
+        int i, int w);
+
+/*
+ * Functions for open array translation between simulator and canonical
+ * representations. These functions copy the whole packed array in either
+ * direction. The user is responsible for allocating an array in the
+ * canonical representation.
+ */
+
+/* s=source, d=destination */
+/* actual <-- canonical */
+XXTERN void svPutBitArrElemVec32(const svOpenArrayHandle d, const svBitVec32* s,
+        int indx1, ...);
+XXTERN void svPutBitArrElem1Vec32(const svOpenArrayHandle d, const svBitVec32* s,
+        int indx1);
+XXTERN void svPutBitArrElem2Vec32(const svOpenArrayHandle d, const svBitVec32* s,
+        int indx1, int indx2);
+XXTERN void svPutBitArrElem3Vec32(const svOpenArrayHandle d, const svBitVec32* s,
+        int indx1, int indx2, int indx3);
+XXTERN void svPutLogicArrElemVec32(const svOpenArrayHandle d, const svLogicVec32* s,
+        int indx1, ...);
+XXTERN void svPutLogicArrElem1Vec32(const svOpenArrayHandle d, const svLogicVec32* s,
+        int indx1);
+XXTERN void svPutLogicArrElem2Vec32(const svOpenArrayHandle d, const svLogicVec32* s,
+        int indx1, int indx2);
+XXTERN void svPutLogicArrElem3Vec32(const svOpenArrayHandle d, const svLogicVec32* s,
+        int indx1, int indx2, int indx3);
+
+/* canonical <-- actual */
+XXTERN void svGetBitArrElemVec32(svBitVec32* d, const svOpenArrayHandle s,
+        int indx1, ...);
+XXTERN void svGetBitArrElem1Vec32(svBitVec32* d, const svOpenArrayHandle s,
+        int indx1);
+XXTERN void svGetBitArrElem2Vec32(svBitVec32* d, const svOpenArrayHandle s,
+        int indx1, int indx2);
+XXTERN void svGetBitArrElem3Vec32(svBitVec32* d, const svOpenArrayHandle s,
+        int indx1, int indx2, int indx3);
+XXTERN void svGetLogicArrElemVec32(svLogicVec32* d, const svOpenArrayHandle s,
+        int indx1, ...);
+XXTERN void svGetLogicArrElem1Vec32(svLogicVec32* d, const svOpenArrayHandle s,
+        int indx1);
+XXTERN void svGetLogicArrElem2Vec32(svLogicVec32* d, const svOpenArrayHandle s,
+        int indx1, int indx2);
+XXTERN void svGetLogicArrElem3Vec32(svLogicVec32* d, const svOpenArrayHandle s,
+        int indx1, int indx2, int indx3);
+
+/*
+ **********************************************************
+ * DEPRECATED PORTION OF FILE ENDS HERE.
+ **********************************************************
+ */
+
+#undef DPI_EXTERN
+
+#ifdef DPI_PROTOTYPES
+#undef DPI_PROTOTYPES
+#undef XXTERN
+#undef EETERN
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

internals.pod

@@ -0,0 +1,794 @@
+# DESCRIPTION: DOCUMENT source run through perl to produce internals.txt file
+# Use 'make internals.txt' to produce the output file
+
+=pod
+
+=head1 NAME
+
+Verilator Internals
+
+=head1 INTRODUCTION
+
+This file discusses internal and programming details for Verilator.  It's
+the first for reference for developers and debugging problems.
+
+See also the Verilator internals presentation at http://www.veripool.org.
+
+=head1 CODE FLOWS
+
+=head2 Verilator Flow
+
+The main flow of Verilator can be followed by reading the Verilator.cpp
+process() function:
+
+First, the files specified on the command line are read.  Reading involves
+preprocessing, then lexical analysis with Flex and parsing with Bison.
+This produces an abstract syntax tree (AST) representation of the design,
+which is what is visible in the .tree files described below.
+
+Verilator then makes a series of passes over the AST, progressively refining
+and optimizing it.
+
+Cells in the AST first linked, which will read and parse additional files as
+above.
+
+Functions, variable and other references are linked to their definitions.
+
+Parameters are resolved and the design is elaborated.
+
+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 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
+each variable.  A module that occurs twice will have a scope for each
+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 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).
+
+Verilator orders the code.  Best case, this results in a single "eval"
+function which has all always statements flowing from top to bottom with no
+loops.
+
+Verilator mostly removes the flattening, so that code may be shared between
+multiple invocations of the same module.  It localizes variables, combines
+identical functions, expands macros to C primitives, adds branch prediction
+hints, and performs additional constant propagation.
+
+Verilator finally writes the C++ modules.
+
+=head2 Key Classes Used in the Verilator Flow
+
+=over 4
+
+=item C<AstNode>
+
+The AST is represented at the top level by the class C<AstNode>. This abstract
+class has derived classes for the individual components (e.g. C<AstGenerate>
+for a generate block) or groups of components (e.g. C<AstNodeFTask> for
+functions and tasks, which in turn has C<AstFunc> and C<AstTask> as derived
+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<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.
+
+C<AstNode> has the concept of a next and previous AST - for example the
+next and previous statements in a block. Pointers to the AST for these
+statements (if they exist) can be obtained using the C<back> and C<next>
+methods.
+
+It is useful to remember that the derived class C<AstNetlist> is at the top
+of the tree, so checking for this class is the standard way to see if you
+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<AstNVisitor>
+
+The passes are implemented by AST visitor classes (see L</Visitor
+Functions>). These are implemented by subclasses of the abstract class,
+C<AstNVisitor>. Each pass creates an instance of the visitor class, which
+in turn implements a method to perform the pass.
+
+=item C<V3Graph>
+
+A number of passes use graph algorithms, and the class C<V3Graph> is provided
+to represent those graphs. Graphs are directed, and algorithms are provided to
+manipulate the graphs and to output them in I<GraphViz> dot format (see
+L<http://www.graphviz.org/>). C<V3Graph.h> provides documentation of this
+class.
+
+=item C<V3GraphVertex>
+
+This is the base class for vertices in a graph. Vertices have an associated
+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 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
+the form:
+
+    for (V3GraphEdge *edgep = vertexp->inBeginp();
+         edgep;
+         edgep = edgep->inNextp()) {
+
+=item C<V3GraphEdge>
+
+This is the base class for directed edges between pairs of vertices. Edges
+have an associated C<weight> and may also be made C<cutable>. A generic
+C<user>/C<userp> member variable is also provided.
+
+Accessors, C<fromp> and C<top> return the "from" and "to" vertices
+respectively.
+
+Virtual methods are provided to specify the label, color and style to be
+used in dot output. Typically users provided derived classes from
+C<V3GraphEdge> which will reimplement these methods.
+
+=item C<V3GraphAlg>
+
+This is the base class for graph algorithms. It implements a C<bool> method,
+C<followEdge> which algorithms can use to decide whether an edge is
+followed. This method returns true if the graph edge has weight greater than
+one and a user function, C<edgeFuncp> (supplied in the constructor) returns
+C<true>.
+
+A number of predefined derived algorithm classes and access methods are
+provided and documented in C<V3GraphAlg.cpp>.
+
+=back
+
+=head2 Verilated Flow
+
+The evaluation loop outputted by Verilator is designed to allow a single
+function to perform evaluation under most situations.
+
+On the first evaluation, the Verilated code calls initial blocks, and then
+"settles" the modules, by evaluating functions (from always statements)
+until all signals are stable.
+
+On other evaluations, the Verilated code detects what input signals have
+changes.  If any are clocks, it calls the appropriate sequential functions
+(from always @ posedge statements).  Interspersed with sequential functions
+it calls combo functions (from always @*).  After this is complete, it
+detects any changes due to combo loops or internally generated clocks, and
+if one is found must reevaluate the model again.
+
+For SystemC code, the eval() function is wrapped in a SystemC SC_METHOD,
+sensitive to all inputs.  (Ideally it would only be sensitive to clocks and
+combo inputs, but tracing requires all signals to cause evaluation, and the
+performance difference is small.)
+
+If tracing is enabled, a callback examines all variables in the design for
+changes, and writes the trace for each change.  To accelerate this process
+the evaluation process records a bitmask of variables that might have
+changed; if clear, checking those signals for changes may be skipped.
+
+=head1 CODING CONVENTIONS
+
+=head2 Indentation style
+
+To match the indentation of Verilator C++ sources, use 4 spaces per level,
+and leave tabs at 8 columns, so every other indent level is a tab stop.
+
+All files should contain the magic header to insure standard indentation:
+
+    // -*- mode: C++; c-file-style: "cc-mode" -*-
+
+This sets indentation to the cc-mode defaults.  (Verilator predates a
+CC-mode change of several years ago which overrides the defaults with GNU
+style indentation; the c-set-style undoes that.)
+
+=head2 The C<astgen> script
+
+Some of the code implementing passes is extremely repetitive, and must be
+implemented for each sub-class of C<AstNode>. However, while repetitive,
+there is more variability than can be handled in C++ macros.
+
+In Verilator this is implemented by using a Perl script, C<astgen> to
+pre-process the C++ code. For example in C<V3Const.cpp> this is used to
+implement the C<visit()> functions for each binary operation using the
+TREEOP macro.
+
+The original C++ source code is transformed into C++ code in the C<obj_opt>
+and C<obj_dbg> sub-directories (the former for the optimized version of
+Verilator, the latter for the debug version). So for example C<V3Const.cpp>
+into C<V3Const__gen.cpp>.
+
+=head2 Visitor Functions
+
+Verilator uses the I<Visitor> design pattern to implement its refinement
+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
+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
+instance (i.e. C<this>).
+
+One possible difficulty is that a call to C<accept> may perform an edit
+which destroys the node it receives as argument. The
+C<acceptSubtreeReturnEdits> method of C<AstNode> is provided to apply
+C<accept> and return the resulting node, even if the original node is
+destroyed (if it is not destroyed it will just return the original node).
+
+The behavior of the visitor classes is achieved by overloading the C<visit>
+function for the different C<AstNode> derived classes. If a specific
+implementation is not found, the system will look in turn for overloaded
+implementations up the inheritance hierarchy. For example calling C<accept>
+on C<AstIf> will look in turn for:
+
+  void visit (AstIf* nodep, AstNUser* vup)
+  void visit (AstNodeIf* nodep, AstNUser* vup)
+  void visit (AstNodeStmt* nodep, AstNUser* vup)
+  void visit (AstNode* nodep, AstNUser* vup)
+
+There are three ways data is passed between visitor functions.
+
+=over 4
+
+=item 1.
+
+A visitor-class member variable.  This is generally for passing "parent"
+information down to children.  C<m_modp> is a common example.  It's set to
+NULL in the constructor, where that node (C<AstModule> visitor) sets it,
+then the children are iterated, then it's cleared.  Children under an
+C<AstModule> will see it set, while nodes elsewhere will see it clear.  If
+there can be nested items (for example an C<AstFor> under an C<AstFor>) the
+variable needs to be save-set-restored in the C<AstFor> visitor, otherwise
+exiting the lower for will lose the upper for's setting.
+
+=item 2.
+
+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
+technique lifted from graph traversal packages).
+
+A visitor first clears the one it wants to use by calling
+C<AstNode::user#ClearTree()>, then it can mark any node's user() with whatever
+data it wants.  Readers just call C<< nodep->user() >>, but may need to cast
+appropriately, so you'll often see C<< nodep->userp()->castSOMETYPE() >>.  At
+the top of each visitor are comments describing how the C<user()> stuff
+applies to that visitor class.  For example:
+
+    // NODE STATE
+    // Cleared entire netlist
+    //   AstModule::user1p()     // bool. True to inline this module
+
+This says that at the C<AstNetlist> C<user1ClearTree()> is called.  Each
+C<AstModule>'s C<user1()> is used to indicate if we're going to inline it.
+
+These comments are important to make sure a C<user#()> on a given C<AstNode>
+type is never being used for two different purposes.
+
+Note that calling C<user#ClearTree> is fast, it doesn't walk the tree, so
+it's ok to call fairly often.  For example, it's commonly called on every
+module.
+
+=item 3.
+
+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
+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.)
+
+=back
+
+=head2 Iterators
+
+C<AstNode> provides a set of iterators to facilitate walking over the
+tree. Each takes two arguments, a visitor, C<v>, of type C<AstNVisitor> and
+an optional pointer user data, C<vup>, of type C<AstNUser*>. The second is
+one of the ways to pass parameters to visitors described in L</Visitor
+Functions>, but its use is now deprecated and should I<not> be used for new
+visitor classes.
+
+=over 4
+
+=item C<iterate()>
+
+This just applies the C<accept> method of the C<AstNode> to the visitor
+function.
+
+=item C<iterateAndNextIgnoreEdit>
+
+Applies the C<accept> method of each C<AstNode> in a list (i.e. connected
+by C<nextp> and C<backp> pointers).
+
+=item C<iterateAndNext>
+
+Applies the C<accept> method of each C<AstNode> in a list. If a node is
+edited by the call to C<accept>, apply C<accept> again, until the node does
+not change.
+
+=item C<iterateListBackwards>
+
+Applies the C<accept> method of each C<AstNode> in a list, starting with
+the last one.
+
+=item C<iterateChildren>
+
+Apply the C<iterateAndNext> method on each child C<op1p> through C<op4p> in
+turn.
+
+=item C<iterateChildrenBackwards>
+
+Apply the C<iterateListBackwards> method on each child C<op1p> through
+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
+dealing with. For example a visitor might not implement separate C<visit>
+methods for C<AstIf> and C<AstGenIf>, but just a single method for the base
+class:
+
+  void visit (AstNodeIf* nodep, AstNUser* vup)
+
+However that method might want to specify additional code if it is called
+for C<AstGenIf>. Verilator does this by providing a C<castSOMETYPE()>
+method for each possible node type, using C++ C<dynamic_cast>. This either
+returns a pointer to the object cast to that type (if it is of class
+C<SOMETYPE>, or a derived class of C<SOMETYPE>) or else NULL. So our
+C<visit> method could use:
+
+  if (nodep->castAstGenIf()) {
+      <code specific to AstGenIf>
+  }
+
+A common test is for C<AstNetlist>, which is the node at the root of the
+AST.
+
+=head1 TESTING
+
+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 convention have the suffix C<_bad> in their name,
+and include C<fails =E<gt> 1> in either their C<compile> or C<execute> step as
+appropriate.
+
+=head2 Preparing to Run Tests
+
+For all tests to pass you must install the following packages:
+
+* SystemC to compile the SystemC outputs, see http://systemc.org
+
+* Parallel::Forker from CPAN to run tests in parallel, you can install this
+with e.g. "sudo cpan install Parallel::Forker".
+
+* vcddiff to find differences in VCD outputs. See the readme at
+https://github.com/veripool/vcddiff
+
+=head2 Controlling the Test Driver
+
+Test drivers are written in PERL. All invoke the main test driver script,
+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
+
+=item --enable-ccwarn
+
+Causes the build to stop on warnings as well as errors. A good way to
+ensure no sloppy code gets added, however it can be painful when it comes
+to testing, since third party code used in the tests (e.g. SystemC) may not
+be warning free.
+
+=item --enable-longtests
+
+In addition to the standard C, SystemC tests also run the tests in the
+C<test_verilated> and C<test_regress> directories when using I<make test>.
+This is disabled by default as SystemC installation problems would
+otherwise falsely indicate a Verilator problem.
+
+=back
+
+When enabling the long tests, some additional PERL modules are needed, which
+you can install using cpan.
+
+    cpan install Unix::Processors
+
+There are some traps to avoid when running regression tests
+
+=over 4
+
+=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.
+
+=item *
+
+Not all Linux systems install Perldoc by default. This is needed for the
+I<--help> option to Verilator, and also for regression testing. This can be
+installed using cpan:
+
+    cpan install Pod::Perldoc
+
+Many Linux systems also offer a standard package for this. Red
+Hat/Fedora/Centos offer I<perl-Pod-Perldoc>, while Debian/Ubuntu/Linux Mint
+offer I<perl-doc>.
+
+=item *
+
+Running regression may exhaust resources on some Linux systems, particularly
+file handles and user processes. Increase these to respectively 16,384 and
+4,096. The method of doing this is system dependent, but on Fedora Linux it
+would require editing the C</etc/security/limits.conf> file as root.
+
+=back
+
+=head1 DEBUGGING
+
+=head2 --debug
+
+When you run with --debug there are two primary output file types placed into
+the obj_dir, .tree and .dot files.
+
+=head2 .dot output
+
+Dot files are dumps of internal graphs in Graphviz
+L<http://www.graphviz.org/> dot format.  When a dot file is dumped,
+Verilator will also print a line on stdout that can be used to format the
+output, for example:
+
+    dot -Tps -o ~/a.ps obj_dir/Vtop_foo.dot
+
+You can then print a.ps.  You may prefer gif format, which doesn't get
+scaled so can be more useful with large graphs.
+
+For dynamic graph viewing consider ZGRViewer
+L<http://zvtm.sourceforge.net/zgrviewer.html>.  If you know of better
+viewers let us know; ZGRViewer isn't great for large graphs.
+
+=head2 .tree output
+
+Tree files are dumps of the AST Tree and are produced between every major
+algorithmic stage.  An example:
+
+     NETLIST 0x90fb00 <e1> {a0}
+    1: MODULE 0x912b20 <e8822> {a8}  top  L2 [P]
+   *1:2: VAR 0x91a780 <e74#> {a22} @dt=0xa2e640(w32)  out_wide [O] WIRE
+    1:2:1: BASICDTYPE 0xa2e640 <e2149> {e24} @dt=this(sw32)  integer kwd=integer range=[31:0]
+
+=over 4
+
+The following summarizes the above example dump, with more detail on each
+field in the section below.
+
+"1:2:" indicates the hierarchy of the C<VAR> is the C<op2p> pointer under
+the C<MODULE>, which in turn is the C<op1p> pointer under the C<NETLIST>
+
+"VAR" is the AstNodeType.
+
+"0x91a780" is the address of this node.
+
+"<e74>" means the 74th edit to the netlist was the last modification to
+this node.
+
+"{a22}" indicates this node is related to line 22 in the source filename
+"a", where "a" is the first file read, "z" the 26th, and "aa" the 27th.
+
+"@dt=0x..." indicates the address of the data type this node contains.
+
+"w32" indicates the width is 32 bits.
+
+"out_wide" is the name of the node, in this case the name of the variable.
+
+"[O]" are flags which vary with the type of node, in this case it means the
+variable is an output.
+
+=back
+
+In more detail the following fields are dumped common to all nodes. They
+are produced by the C<AstNode::dump()> method:
+
+=over 4
+
+=item Tree Hierarchy
+
+The dump lines begin with numbers and colons to indicate the child node
+hierarchy.  As noted above in L</Key Classes Used in the Verilator Flow>,
+C<AstNode> has lists of items at the same level in the AST, connected by
+the C<nextp()> and C<prevp()> pointers. These appear as nodes at the same
+level. For example after inlining:
+
+     NETLIST 0x929c1c8 <e1> {a0} w0
+    1: MODULE 0x92bac80 <e3144> {e14} w0  TOP_t  L1 [P]
+    1:1: CELLINLINE 0x92bab18 <e3686#> {e14} w0  v -> t
+    1:1: CELLINLINE 0x92bc1d8 <e3688#> {e24} w0  v__DOT__i_test_gen -> test_gen
+    ...
+    1: MODULE 0x92b9bb0 <e503> {e47} w0  test_gen  L3
+    ...
+
+=item AstNode type
+
+The textual name of this node AST type (always in capitals). Many of these
+correspond directly to Verilog entities (for example C<MODULE> and
+C<TASK>), but others are internal to Verialtor (for example C<NETLIST> and
+C<BASICDTYPE>).
+
+=item Address of the node
+
+A hexadecimal address of the node in memory. Useful for examining with the
+debugger.
+
+=item Last edit number
+
+Of the form C<< <ennnn> >> or C<< <ennnn#> >> , where C<nnnn> is the number
+of the last edit to modify this node. The trailing C<#> indicates the node
+has been edited since the last tree dump (which typically means in the last
+refinement or optimization pass). GDB can watch for this, see L</Debugging
+with GDB>.
+
+=item Source file and line
+
+Of the form C<< {xxnnnn} >>, where C{xx} is the filename letter (or
+letters) and C<nnnn> is the line number within that file. The first file is
+C<a>, the 26th is C<z>, the 27th is C<aa> and so on.
+
+=item User pointers
+
+Shows the value of the node's user1p...user5p, if non-NULL.
+
+=item Data type
+
+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 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.
+
+C<d> if the node is a double (i.e a floating point entity).
+
+C<w> always present, indicating this is the width field.
+
+C<u> if the node is unsized.
+
+C</nnnn> if the node is unsized, where C<nnnn> is the minimum width.
+
+=item Name of the entity represented by the node if it exists
+
+For example for a C<VAR> it is the name of the variable.
+
+=back
+
+Many nodes follow these fields with additional node specific
+information. Thus the C<VARREF> node will print either C<[LV]> or C<[RV]>
+to indicate a left value or right value, followed by the node of the
+variable being referred to. For example:
+
+    1:2:1:1: VARREF 0x92c2598 <e509> {e24} w0  clk [RV] <- VAR 0x92a2e90 <e79> {e18} w0  clk [I] INPUT
+
+In general, examine the C<dump()> method in C<V3AstNodes.cpp> of the node
+type in question to determine additional fields that may be printed.
+
+The C<MODULE> has a list of C<CELLINLINE> nodes referred to by its
+C<op1p()> pointer, connected by C<nextp()> and C<prevp()> pointers.
+
+Similarly the C<NETLIST> has a list of modules referred to by its C<op1p()>
+pointer.
+
+=head2 Debugging with GDB
+
+The test_regress/driver.pl script accepts --debug --gdb to start Verilator
+under gdb and break when an error is hit or the program is about to exit.
+You can also use --debug --gdbbt to just backtrace and then exit gdb. To
+debug the Verilated executable, use --gdbsim.
+
+If you wish to start Verilator under GDB (or another debugger), then you
+can use --debug and look at the underlying invocation of verilator_dgb. For
+example
+
+  t/t_alw_dly.pl --debug
+
+shows it invokes the command:
+
+  ../verilator_bin_dbg --prefix Vt_alw_dly --x-assign unique --debug
+    -cc -Mdir obj_dir/t_alw_dly --debug-check -f input.vc t/t_alw_dly.v
+
+Start GDB, then C<start> with the remaining arguments.
+
+  gdb ../verilator_bin_dbg
+  ...
+  (gdb) start --prefix Vt_alw_dly --x-assign unique --debug -cc -Mdir
+            obj_dir/t_alw_dly --debug-check  -f input.vc t/t_alw_dly.v
+            > obj_dir/t_alw_dly/vlt_compile.log
+  ...
+  Temporary breakpoint 1, main (argc=13, argv=0xbfffefa4, env=0xbfffefdc)
+      at ../Verilator.cpp:615
+  615         ios::sync_with_stdio();
+  (gdb) 
+
+You can then continue execution with breakpoints as required.
+
+To break at a specific edit number which changed a node (presumably to find
+what made a <e####> line in the tree dumps):
+
+   watch AstNode::s_editCntGbl==####
+
+To print a node:
+
+   pn nodep
+   # or: call nodep->dumpGdb() # aliased to "pn" in src/.gdbinit
+   pnt nodep
+   # or: call nodep->dumpTreeGdb()  # aliased to "pnt" in src/.gdbinit
+
+When GDB halts, it is useful to understand that the backtrace will commonly
+show the iterator functions between each invocation of C<visit> in the
+backtrace. You will typically see a frame sequence something like
+
+  ...
+  visit()
+  iterateChildren()
+  iterateAndNext()
+  accept()
+  visit()
+  ...
+
+=head1 ADDING A NEW FEATURE
+
+Generally what would you do to add a new feature?
+
+=over 4
+
+=item 1.
+
+File a bug (if there isn't already) so others know what you're working on.
+
+=item 2.
+
+Make a testcase in the test_regress/t/t_EXAMPLE format, see L<TESTING>.
+
+=item 3.
+
+If grammar changes are needed, look at the git version of VerilogPerl's
+src/VParseGrammar.y, as this grammar supports the full SystemVerilog
+language and has a lot of back-and-forth with Verilator's grammar.  Copy
+the appropriate rules to src/verilog.y and modify the productions.
+
+=item 4.
+
+If a new Ast type is needed, add it to V3AstNodes.h.
+
+=back
+
+Now you can run "test_regress/t/t_{new testcase}.pl --debug" and it'll
+probably fail but you'll see a test_regress/obj_dir/t_{newtestcase}/*.tree
+file which you can examine to see if the parsing worked. See also the
+sections above on debugging.
+
+Modify the later visitor functions to process the new feature as needed.
+
+=head2 Adding a new pass
+
+For more substantial changes you may need to add a new pass. The simplest way
+to do this is to copy the C<.cpp> and C<.h> files from an existing
+pass. You'll need to add a call into your pass from the C<process()> function
+in C<src/verilator.cpp>.
+
+To get your pass to build you'll need to add its binary filename to the list
+in C<src/Makefile_obj.in> and reconfigure.
+
+=head1 DISTRIBUTION
+
+The latest version is available from L<http://www.veripool.org/>.
+
+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.
+
+=cut
+
+######################################################################

nodist/bisondiff

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2009 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.
@@ -81,5 +81,5 @@ sub prep {
 }
 
 # Local Variables:
-# compile-command: "./bisondiff --unsup $WUP/Verilog/Parser/VParseBison.y ../src/verilog.y"
+# compile-command: "./bisondiff --unsup $VP/Parser/VParseBison.y ../src/verilog.y"
 # End:

nodist/bisonreader

@@ -1,7 +1,7 @@
 #!/usr/bin/perl -w
 ######################################################################
 #
-# Copyright 2007-2009 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

@@ -38,7 +38,7 @@ cwrite ("graph_export.cpp");
 #----------------------------------------------------------------------
 
 sub usage {
-    pod2usage(-verbose=>2, -exitval => 2);
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
     exit (1);
 }
 
@@ -143,7 +143,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2009 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

@@ -43,7 +43,7 @@ dotwrite();
 #----------------------------------------------------------------------
 
 sub usage {
-    pod2usage(-verbose=>2, -exitval => 2);
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
     exit (1);
 }
 
@@ -184,7 +184,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2009 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-2009 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.
@@ -48,7 +48,10 @@ sub prep {
 
     while (defined(my $line = $fh->getline)) {
 	# Productions
-	$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+	#$line =~ s/[ \t]{[^}]*?}/\t{}/g;
+	$line =~ s/StashPrefix;//g;
+	$line =~ s/VALTEXT;//g;
+	$line =~ s/CALLBACK\([^)]*\);//g;
 	push @lines, $line;
     }
 
@@ -57,5 +60,5 @@ sub prep {
 }
 
 # Local Variables:
-# compile-command: "./flexdiff $WUP/Verilog/Parser/VParseLex.l ../src/verilog.l"
+# compile-command: "./flexdiff $VP/Parser/VParseLex.l ../src/verilog.l"
 # End:

nodist/install_test

@@ -0,0 +1,202 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+use Getopt::Long;
+use Cwd;
+use IO::File;
+use Pod::Usage;
+use strict;
+use vars qw ($Debug);
+
+#======================================================================
+# main
+
+our $Opt_Stage = 0;
+our $Opt_Jobs = calc_jobs();
+
+autoflush STDOUT 1;
+autoflush STDERR 1;
+Getopt::Long::config ("no_auto_abbrev");
+if (! GetOptions (
+	  "debug"	=> sub { $Debug = 1; },
+	  "<>"		=> sub { die "%Error: Unknown parameter: $_[0]\n"; },
+	  "stage=i"	=> \$Opt_Stage,
+	  "j=i"		=> \$Opt_Jobs,
+    )) {
+    die "%Error: Bad usage, try 'install_test --help'\n";
+}
+
+test();
+exit(0);
+
+#######################################################################
+
+sub test {
+    -r "nodist/install_test" or die "%Error: Run from the top of the verilator kit,";
+
+    cleanenv();
+    $ENV{VERILATOR_NO_OPT_BUILD} = 1;   # Don't build optimized executables; just slows this down
+    run("make distclean") if -r "Makefile";
+
+    # Try building from a scratch area
+    my $srcdir = getcwd();
+    my $blddir  = $srcdir."/test_regress/obj_dir/install_test_bld";
+    my $prefix  = $srcdir."/test_regress/obj_dir/install_test_prefix";
+    my $testdirp= $srcdir."/test_regress/obj_dir/install_test_testp";
+    my $testdirn= $srcdir."/test_regress/obj_dir/install_test_testn";
+
+    if ($Opt_Stage <= 0) {
+	run("/bin/rm -rf $blddir");
+	run("/bin/mkdir -p $blddir");
+	run("cd $blddir && $srcdir/configure --prefix $prefix");
+	run("cd $blddir && make -j $Opt_Jobs");
+    }
+
+    # Install it under the prefix
+    if ($Opt_Stage <= 1) {
+	run("/bin/rm -rf $prefix");
+	run("/bin/mkdir -p $prefix");
+	run("cd $blddir && make install");
+	run("test -e $prefix/share/man/man1/verilator.1");
+	run("test -e $prefix/share/verilator/examples/test_c/Makefile");
+	run("test -e $prefix/share/verilator/include/verilated.h");
+	run("test -e $prefix/bin/verilator");
+	run("test -e $prefix/bin/verilator_bin");
+	run("test -e $prefix/bin/verilator_bin_dbg");
+	run("test -e $prefix/bin/verilator_profcfunc");
+    }
+
+    # Run a test using just the path
+    if ($Opt_Stage <= 2) {
+	my $dir = $testdirp;
+	run("/bin/rm -rf   $dir");
+	run("/bin/mkdir -p $dir");
+	my $bin1 = $prefix."/bin";
+	my $bin2 = $prefix."/share/bin";
+	write_verilog($dir);
+	run("cd $dir && PATH=$bin1:$bin2:\$PATH verilator --cc foo.v --exe foo.cpp");
+	run("cd $dir/obj_dir && PATH=$bin1:$bin2:\$PATH make -f Vfoo.mk");
+	run("cd $dir && PATH=$bin1:$bin2:\$PATH obj_dir/Vfoo");
+    }
+
+    # Run a test using exact path to binary
+    if ($Opt_Stage <= 3) {
+	my $dir = $testdirn;
+	run("/bin/rm -rf   $dir");
+	run("/bin/mkdir -p $dir");
+	write_verilog($dir);
+	my $bin1 = $prefix."/bin";
+	my $bin2 = $prefix."/share/bin";
+	run("cd $dir && $bin1/verilator --cc foo.v --exe foo.cpp");
+	run("cd $dir/obj_dir && make -f Vfoo.mk");
+	run("cd $dir/obj_dir && ./Vfoo");
+    }
+}
+
+sub write_verilog {
+    my $dir = shift;
+    IO::File->new(">$dir/foo.v")->print('module t; initial begin $display("HELLO WORLD"); $finish; end endmodule'."\n");
+    my $fh = IO::File->new(">$dir/foo.cpp");
+    $fh->print('#include "Vfoo.h"'		,"\n");
+    $fh->print('unsigned int main_time = 0;'	,"\n");
+    $fh->print('double sc_time_stamp () {'	,"\n");
+    $fh->print('    return main_time;'		,"\n");
+    $fh->print('}'				,"\n");
+    $fh->print('int main() {'			,"\n");
+    $fh->print('    Vfoo *top = new Vfoo;'	,"\n");
+    $fh->print('    while (!Verilated::gotFinish()) {',"\n");
+    $fh->print('	top->eval();'		,"\n");
+    $fh->print('	main_time++;'		,"\n");
+    $fh->print('    }'				,"\n");
+    $fh->print('    top->final();'		,"\n");
+    $fh->print('}'				,"\n");
+}
+
+sub cleanenv {
+    foreach my $var (keys %ENV) {
+	if ($var eq "VERILATOR_ROOT") {
+	    print "unset $var # Was '$ENV{$var}'\n";
+	    delete $ENV{$var}
+	}
+    }
+}
+
+#######################################################################
+
+sub calc_jobs {
+    my $ok = eval "
+	use Unix::Processors;
+	return Unix::Processors->new->max_online;
+    ";
+    $ok && !$@ or return 1;
+    print "driver.pl: Found $ok cores, using -j ",$ok+1,"\n" if $Debug;
+    return $ok + 1;
+}
+
+sub run {
+    # Run a system command, check errors
+    my $command = shift;
+    print "\t$command\n";
+    system "$command";
+    my $status = $?;
+    ($status == 0) or die "%Error: Command Failed $command, $status, stopped";
+}
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+install_test - Build and install Verilator several ways
+
+=head1 SYNOPSIS
+
+  install_test
+
+=head1 DESCRIPTION
+
+install_test performs several make-and-install iterations to verify the
+kit.  It isn't part of the normal "make test" due to the number of builds
+required.
+
+=head1 ARGUMENTS
+
+=over 4
+
+=item --help
+
+Displays this message and program version and exits.
+
+=item -j I<jobs>
+
+Specify make -j flag.  Defaults to number of cores + 1 if Perl's
+Unix::Processors is installed, else 1.
+
+=item -stage I<stage>
+
+Runs a specific test stage (see the script).
+
+=back
+
+=head1 DISTRIBUTION
+
+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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "cd .. ; nodist/install_test "
+### End:

nodist/invoke_atsim

@@ -0,0 +1,47 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+require 5.006_001;
+use strict;
+
+#======================================================================
+# main
+
+eval `modulecmd perl add axiom-athdl`;
+exec('atsim',@ARGV);
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+invoke_atsim - Invoke tool under "modules" command
+
+=head1 SYNOPSIS
+
+  invoke_atsim  {ncv arguments}
+
+=head1 DESCRIPTION
+
+=head1 DISTRIBUTION
+
+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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./invoke_atsim -help"
+### End:

nodist/invoke_iccr

@@ -8,21 +8,9 @@ use strict;
 #======================================================================
 # main
 
-delete $ENV{MODULE_VERSION};
-_setup_modules();
-module('add','cadence_verif');
+eval `modulecmd perl add cds-ius`;
 exec('iccr',@ARGV);
 
-#######################################################################
-# Modules package
-
-sub _setup_modules {
-    # Load the 'module' command into the environment
-    my $init = "/sicortex/$ENV{DIRPROJECT_ARCH}/lib/Modules/default/init/perl";
-    (-f $init) or die "%Error: Script not found: $init,";
-    require $init;
-}
-
 #######################################################################
 __END__
 
@@ -40,7 +28,7 @@ invoke_iccr - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2007-2009 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

@@ -8,21 +8,9 @@ use strict;
 #======================================================================
 # main
 
-delete $ENV{MODULE_VERSION};
-_setup_modules();
-module('add','cadence_verif');
+eval `modulecmd perl add cds-ius`;
 exec('ncverilog',@ARGV);
 
-#######################################################################
-# Modules package
-
-sub _setup_modules {
-    # Load the 'module' command into the environment
-    my $init = "/sicortex/$ENV{DIRPROJECT_ARCH}/lib/Modules/default/init/perl";
-    (-f $init) or die "%Error: Script not found: $init,";
-    require $init;
-}
-
 #######################################################################
 __END__
 
@@ -40,7 +28,7 @@ invoke_ncverilog - Invoke tool under "modules" command
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2009 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

@@ -0,0 +1,47 @@
+#!/usr/bin/perl -w
+# See copyright, etc in below POD section.
+######################################################################
+
+require 5.006_001;
+use strict;
+
+#======================================================================
+# main
+
+eval `modulecmd perl add synopsys-vcs_mx`;
+exec('vcs',@ARGV);
+
+#######################################################################
+__END__
+
+=pod
+
+=head1 NAME
+
+invoke_vcs - Invoke tool under "modules" command
+
+=head1 SYNOPSIS
+
+  invoke_vcs  {ncv arguments}
+
+=head1 DESCRIPTION
+
+=head1 DISTRIBUTION
+
+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.
+
+=head1 AUTHORS
+
+Wilson Snyder <[email protected]>
+
+=head1 SEE ALSO
+
+=cut
+
+######################################################################
+### Local Variables:
+### compile-command: "./invoke_vcs -help"
+### End:

nodist/leakchecking.txt

@@ -1,4 +1,4 @@
 export GLIBCPP_FORCE_NEW=1
 compile with -DVL_LEAK_CHECKS
-valgrind --tool=memcheck --leak-check=yes /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg -MMD --bin /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg --cc -f /home/wsnyder/src/verilator/v4/verilator/test_c/../test_v/input.vc top.v --no-skip-identical 2>&1 | tee ~/d/aa
-valgrind --tool=memcheck --leak-check=yes /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg -MMD --bin /home/wsnyder/src/verilator/v4/verilator/verilator_bin_dbg --cc /home/wsnyder/src/verilator/v4/verilator/test_regress/t/t_case_huge.v --no-skip-identical -I/home/wsnyder/src/verilator/v4/verilator/test_regress/t 2>&1 | tee ~/d/aa
+valgrind --tool=memcheck --leak-check=yes $VERILATOR_ROOT/verilator_bin_dbg -MMD --bin $VERILATOR_ROOT/verilator_bin_dbg --cc -f $VERILATOR_ROOT/test_c/../test_v/input.vc top.v --no-skip-identical 2>&1 | tee ~/d/aa
+valgrind --tool=memcheck --leak-check=yes $VERILATOR_ROOT/verilator_bin_dbg -MMD --bin $VERILATOR_ROOT/verilator_bin_dbg --cc $VERILATOR_ROOT/test_regress/t/t_case_huge.v --no-skip-identical -I$VERILATOR_ROOT/test_regress/t 2>&1 | tee ~/d/aa

nodist/vtree_importer

@@ -40,7 +40,7 @@ print '(query-replace-regexp "(\\([0-9a-z_]+\\))" "\\1" nil nil nil)',"\n";
 #----------------------------------------------------------------------
 
 sub usage {
-    pod2usage(-verbose=>2, -exitval => 2);
+    pod2usage(-verbose=>2, -exitval=>2, -output=>\*STDOUT);
     exit (1);
 }
 
@@ -256,7 +256,7 @@ sub gentree {
   'TRACE'	=> sub { p "TRACE what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
   'UCFUNC'	=> sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ")"; },
   'UCSTMT'	=> sub { p '$c(';p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p ");";nl; },
-  'UNARYMIN'	=> sub { p " -";p1; },
+  'NEGATE'	=> sub { p " -";p1; },
   'VAR'		=> sub { p_var(); },
   'VARPIN'	=> sub { p "VARPIN what{";p1;p ",";p2;p ",";p3;p ",";p4;p ",";p5;p "}";nl; },
   'VARREF'	=> sub { a1; },
@@ -331,7 +331,7 @@ Displays this message and program version and exits.
 
 =head1 DISTRIBUTION
 
-Copyright 2005-2009 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.
 

readme.texi

@@ -1,197 +0,0 @@
-\input texinfo @c -*-texinfo-*-
-@c %**start of header
-@setfilename readme.info
-@settitle Verilator Installation
-@c %**end of header
-
-@c DESCRIPTION: TexInfo: DOCUMENT source run through texinfo to produce README file
-@c Use 'make README' to produce the output file
-@c Before release, run C-u C-c C-u C-a (texinfo-all-menus-update)
-
-@node Top, Copyright, (dir), (dir)
-@chapter Verilator
-
-This is the Verilator Package.
-
-@menu
-* Copyright::
-* Description::
-* Obtaining Distribution::
-* Directory Structure::
-* Supported Systems::
-* Installation::
-* Limitations::
-@end menu
-
-@node Copyright, Description, Top, Top
-@section Copyright
-
-This package is Copyright 2003-2009 by Wilson Snyder @email{wsnyder@@wsnyder.org}.
-
-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.  (See the
-documentation for more details.)
-
-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.
-
-@node Description, Obtaining Distribution, Copyright, Top
-@section Description
-
-Verilator converts synthesizable (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.
-
-The resulting files are then compiled with C++.  The user writes a little
-C++ wrapper file, which instantiates the top level module.  This is
-compiled in C++, and linked with the Verilated files.
-
-The resulting executable will perform the actual simulation.
-
-@node Obtaining Distribution, Directory Structure, Description, Top
-@section Obtaining Distribution
-
-The latest version is available at
-@uref{http://www.veripool.org/verilator}
-
-Download the latest package from that site, and decompress.
-@samp{tar xvzf verilator_version.tgz}
-
-@node Directory Structure, Supported Systems, Obtaining Distribution, Top
-@section Directory Structure
-
-The directories after de-taring are as follows:
-
-@itemize @bullet
-@item bin/verilator	     => Compiler Wrapper invoked on user Verilog code
-@item include/		     => Files that should be in your -I compiler path
-@item include/verilated.cpp   => Global routines to link into your simulator
-@item include/verilated.h     => Global headers
-@item include/verilated.v     => Stub defines for linting
-@item include/verilated.mk    => Common makefile
-@item src/		     => Translator source code
-@item test_v		     => Example Verilog code for other test dirs
-@item test_c		     => Example Verilog->C++ conversion
-@item test_sc		     => Example Verilog->SystemC conversion
-@item test_sp		     => Example Verilog->SystemPerl conversion
-@item test_vcs		     => Example Verilog->VCS conversion (test the test)
-@item test_verilated	     => Internal tests
-@item test_regress	     => Internal tests
-@end itemize
-
-@node Supported Systems, Installation, Directory Structure, Top
-@section Supported Systems
-
-This version of verilator has been built and tested on:
-
-@itemize @bullet
-@item SuSE AMD64 i686-linux-2.6.5
-@end itemize
-
-Other users report success with Redhat Linux 2.4, Windows under
-Cygwin, HPUX and Solaris.  It should run with minor porting on any
-Unix system.
-
-@node Installation, Limitations, Supported Systems, Top
-@section Installation
-
-@enumerate
-@item
-If you will be using SystemC (vs straight C++ output), download
-SystemC 2.0.1 from @url{http://www.systemc.org}.  Follow their
-installation instructions.  As described in the System-Perl README,
-you will need to set SYSTEMC and/or SYSTEMC_KIT to point to this
-download.  Also, set SYSTEMC_ARCH to the architecture name you used
-with SystemC, generally 'linux' or 'cygwin'.
-
-@item
-If you will be using SystemC, download and install Verilog-Perl,
-@url{http://search.cpan.org/search?module=Verilog::Language}.
-
-@item
-If you will be using SystemC, download and install System-Perl,
-@url{http://search.cpan.org/search?module=SystemC::Netlist}.  Note
-you'll need to set a @samp{SYSTEMPERL} environment variable to point
-to the downloaded kit.  Optionally also set @samp{SYSTEMPERL_INCLUDE}
-to point to the installed headers.
-
-@item
-@code{cd} to the Verilator directory containing this README.
-
-@item
-Type @samp{./configure} to configure Verilator for your system.
-
-If you are configuring Verilator to be part of a RPM or other
-distribution package system, you may want to use the --enable-defenv
-configure flag.  This will take the current value of VERILATOR_ROOT,
-SYSTEMC, SYSTEMC_ARCH, SYSTEMPERL, and SYSTEMPERL_INCLUDE and build
-them as defaults into the executable.
-
-@item
-Type @samp{make} to compile Verilator.
-
-On Cygwin (Windows) you may get a error about libperl.a not being
-found.  You need to copy your perl libraries as follows.
-
-  @enumerate
-  @item
-  Type @samp{perl -MExtUtils::Embed -e ldopts}
-  @item
-  It will show a directory name ending in /CORE.  cd to that directory.
-  @item
-  @samp{cp libperl5_6_1.a libperl.a}
-  @item
-  @samp{cp libperl5_6_1.dll libperl.dll}
-  @item
-  @samp{cp libperl5_6_1.def libperl.def}
-  @end enumerate
-
-@item
-Type @samp{make test} to check the compilation.
-
-You may get a error about the Bit::Vector perl package.  You will need to install
-it if you want the tests to pass.  (Try @samp{make test_c} for a smaller test that
-doesn't require it.)
-
-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 unsigned long uint32_t;}.
-
-If you get warnings, you might want to edit @samp{include/verilated.mk} to delete the
-lines that define VK_CPPFLAGS_WALL.
-
-@item
-
-There is no installation at present; this package runs from the
-distribution directory.  Programs should set the environment variable
-VERILATOR_ROOT to point to this distribution, then execute
-$VERILATOR_ROOT/bin/verilator, which will find the path to all needed
-files.
-
-Verilator assumes you did a make in the SystemC kit directory.  If not, you will need
-to populate @samp{$SYSTEMC/include} and @samp{$SYSTEMC/lib-linux} appropriately.
-
-If you will be modifying Verilator, you will probably want a second
-stable copy of this kit for others to use while you experiment.
-
-@item
-Detailed documentation and the man page can be seen by running:
-
-    bin/verilator --help
-
-or reading verilator.txt in the same directory as this README.
-
-@end enumerate
-
-@node Limitations,  , Installation, Top
-@section Limitations
-
-See verilator.txt (or execute @samp{bin/verilator --help}) for limitations.
-

src/.gdbinit

@@ -0,0 +1,34 @@
+# DESCRIPTION: Verilator: GDB startup file with useful defines
+#
+# 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.
+
+define pn
+  call $arg0->dumpGdb()
+end
+document pn
+  Verilator: Print single AstNode NODEP
+end
+
+define pnt
+  call $arg0->dumpTreeGdb()
+end
+document pnt
+  Verilator: Print AstNode NODEP's tree
+end
+
+define dtf
+  call AstNode::dumpTreeFileGdb(0)
+end
+document dtf
+  Verilator: Dump AstNode tree to file
+end
+
+define watchedit
+   watch AstNode::s_editCntGbl==$arg0
+end
+document watchedit
+  Verilator: Create watch on where a edit number is made
+end

src/0CodeNotes.pod

@@ -1,70 +0,0 @@
-=pod
-
-=head1 NAME
-
-Verilator Source Code Notes
-
-=head1 INTRODUCTION
-
-See also the Verilator internals presentation at http://www.veripool.org.
-
-=head1 VISITOR FUNCTIONS
-
-=head2 Passing Variables
-
-There's three ways data is passed between visitor functions.
-
-1. A visitor-class member variable.  This is generally for passing "parent"
-information down to children.  m_modp is a common example.  It's set to
-NULL in the constructor, where that node (AstModule visitor) sets it, then
-the children are iterated, then it's cleared.  Children under an AstModule
-will see it set, while nodes elsewhere will see it clear.  If there can be
-nested items (for example an AstFor under an AstFor) the variable needs to
-be save-set-restored in the AstFor visitor, otherwise exiting the lower for
-will loose the upper for's setting.
-
-2. User() attributes.  Each node has 4 ->user() number or ->userp() pointer
-utility values (a common technique lifted from graph traversal packages).
-A visitor first clears the one it wants to use by calling
-AstNode::user#ClearTree(), then it can mark any node's user() with whatever
-data it wants.  Readers just call nodep->user(), but may need to cast
-appropriately, so you'll often see nodep->userp()->castSOMETYPE().  At the
-top of each visitor are comments describing how the user() stuff applies to
-that visitor class.  For example:
-
-    // NODE STATE
-    // Cleared entire netlist
-    //   AstModule::user1p()     // bool. True to inline this module
-
-This says that at the AstNetlist user1ClearTree() is called.  Each
-AstModule's is user1() is used to indicate if we're going to inline it.
-
-These comments are important to make sure a user#() on a given AstNode type
-is never being used for two different purposes.
-
-Note that calling user#ClearTree is fast, it doesn't walk the tree, so it's
-ok to call fairly often.  For example, it's commonly called on every
-module.
-
-3. Parameters can be passed between the visitors in close to the "normal"
-function caller to callee way.  This is the second "vup" parameter 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.)
-
-=head1 DEBUGGING WITH GDB
-
-The test_regress/driver.pl script accepts --gdb to start Verilator under
-gdb.
-
-To break at a specific edit number which changed a node (presumably to find
-what made a <e####> line in the tree dumps):
-
-   watch AstNode::s_editCntGbl==####
-
-=head1 DISTRIBUTION
-
-Copyright 2008-2009 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/Makefile.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2009 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.
@@ -24,6 +24,7 @@
 srcdir = @srcdir@
 VPATH = @srcdir@
 PERL = @PERL@
+EXEEXT = @EXEEXT@
 
 #### End of system configuration section. ####
 
@@ -32,22 +33,11 @@ default: dbg opt
 debug: dbg
 optimize: opt
 
-ifeq ($(OBJCACHE_HOSTS),)
- ifneq ($(SLCHOOSED_HOST),)
-  ifeq ($(VERILATOR_AUTHOR_SITE),1)
-export OBJCACHE_HOSTS := $(shell rschedule --no-allow-reserved --similar hostnames)
-  endif
- endif
+ifneq ($(words $(CURDIR)),1)
+ $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
-ifeq ($(OBJCACHE_HOSTS),)
-export OBJCACHE :=
-else
-export OBJCACHE_JOBS := -j $(shell objcache --jobs "$(OBJCACHE_HOSTS)")
-export OBJCACHE := @objcache --read --write
-endif
-
-UNDER_GIT = $(wildcard ../.git/logs/HEAD)
+UNDER_GIT = $(wildcard ${srcdir}/../.git/logs/HEAD)
 
 #*********************************************************************
 
@@ -56,31 +46,37 @@ 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
 ../verilator_bin: ../verilator_bin_dbg
-	cp -p $< $@
-	@-cp -p $<.exe $@.exe
+	-rm -rf $@ $@.exe
+	-cp -p $<$(EXEEXT) $@$(EXEEXT)
 else
 ../verilator_bin: obj_opt prefiles
-	cd obj_opt && $(MAKE)                  TGT=../$@ -f ../Makefile_obj serial
-	cd obj_opt && $(MAKE) $(OBJCACHE_JOBS) TGT=../$@ -f ../Makefile_obj
+	cd obj_opt && $(MAKE) -j 1  TGT=../$@ -f ../Makefile_obj serial
+	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)                  TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj serial
-	cd obj_dbg && $(MAKE) $(OBJCACHE_JOBS) TGT=../$@ VL_DEBUG=1 -f ../Makefile_obj
+	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::
-
-ifneq ($(UNDER_GIT),)	# If local git tree... Else don't burden users
 prefiles:: config_rev.h
-# This output goes into srcdir, as we need to distribute it as part of the kit.
-config_rev.h:	config_rev.pl ../.git/logs/HEAD
-	$(PERL) config_rev.pl . >$@
+ifneq ($(UNDER_GIT),)	# If local git tree... Else don't burden users
+# This output goes into srcdir if locally configured, as we need to distribute it as part of the kit.
+config_rev.h:	${srcdir}/config_rev.pl ${srcdir}/../.git/logs/HEAD
+	$(PERL) ${srcdir}/config_rev.pl ${srcdir} >$@
+else
+config_rev.h:	${srcdir}/config_rev.pl
+	$(PERL) ${srcdir}/config_rev.pl ${srcdir} >$@
 endif
 
 maintainer-copy::
@@ -92,3 +88,6 @@ clean mostlyclean distclean maintainer-clean::
 
 distclean maintainer-clean::
 	-rm -f Makefile Makefile_obj config_build.h
+
+maintainer-clean::
+	-rm -f config_rev.h

src/Makefile_obj.in

@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2009 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,8 +21,22 @@
 
 #### Start of system configuration section. ####
 
-srcdir = ..
-incdir = ../../include
+# Unfortunately configure uses relative paths, and this makefile is called
+# from a level lower, so we need to move up if it's relative, not if absolute.
+config_srcdir = @srcdir@
+ifeq ($(config_srcdir),.)
+ srcdir = ..
+else  # Run an experiment
+ ifeq ($(wildcard $(config_srcdir)/../Makefile_obj.in),)
+   srcdir = $(config_srcdir)
+ else
+   srcdir = $(config_srcdir)/..
+ endif
+endif
+
+incdir = $(srcdir)/../include
+# Bldsrc may differ from srcdir if configure wan't run from the kit top
+bldsrc = ..
 
 # Programs
 CC = @CC@
@@ -43,13 +57,17 @@ datarootdir = @datarootdir@
 pkgdatadir = @pkgdatadir@
 
 # Compile options
+CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
-CPPFLAGSNOWALL += @CPPFLAGS@
+CPPFLAGS += @CPPFLAGS@
 LDFLAGS += @LDFLAGS@
+EXEEXT = @EXEEXT@
+CFG_CXXFLAGS_SRC = @CFG_CXXFLAGS_SRC@
+CFG_CXXFLAGS_PARSER = @CFG_CXXFLAGS_PARSER@
 
 #### End of system configuration section. ####
 
-VPATH += . $(srcdir)
+VPATH += . $(bldsrc) $(srcdir)
 TGT = ../../verilator_bin
 
 #################
@@ -68,19 +86,22 @@ endif
 #LIBS += -ldl
 #CCMALLOC = /usr/local/lib/ccmalloc-gcc.o -lccmalloc -ldl
 
-LIBS = -lm -lfl
+# -lfl not needed as Flex invoked with %nowrap option
+# -lstdc++ needed for clang, believed harmless with gcc
+LIBS = -lm -lstdc++
 
-CPPFLAGSNOWALL += -MMD
-CPPFLAGSNOWALL += -I. -I$(srcdir) -I$(incdir)
-CPPFLAGSNOWALL += -DYYDEBUG 	# Required to get nice error messages
-#CPPFLAGSNOWALL += -DVL_LEAK_CHECKS 	# If running valgrind or other hunting tool
-CPPFLAGSNOWALL += $(COPT)
-CPPFLAGS = $(CPPFLAGSNOWALL)
-ifeq ($(VERILATOR_AUTHOR_SITE),1)	# Local... Else don't burden users
-CPPFLAGSNOWALL += -MP	# Only works on recent GCC versions
-CPPFLAGS += -W -Wall -Wno-unused-parameter -Wno-char-subscripts -Werror
+CPPFLAGS += -MMD
+CPPFLAGS += -I. -I$(bldsrc) -I$(srcdir) -I$(incdir)
+CPPFLAGS += -DYYDEBUG 	# Required to get nice error messages
+#CPPFLAGS += -DVL_LEAK_CHECKS 	# If running valgrind or other hunting tool
+CPPFLAGS += $(COPT)
+CPPFLAGS += -MP # Only works on recent GCC versions
+ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
+CPPFLAGS += -W -Wall $(CFG_CXXFLAGS_SRC) -Werror
 #CPPFLAGS += -pedantic-errors
 endif
+CPPFLAGSWALL   = $(CPPFLAGS)
+CPPFLAGSPARSER = $(CPPFLAGS) $(CFG_CXXFLAGS_PARSER)
 
 ifneq ($(SYSTEMPERL),)	# Intuit SYSTEMPERL_INCLUDE as it's new
  SYSTEMPERL_INCLUDE ?= $(SYSTEMPERL)/src
@@ -93,6 +114,8 @@ endif
 ifeq ($(CFG_WITH_DEFENV),yes)
  CPPFLAGS += -DDEFENV_SYSTEMC=\"$(SYSTEMC)\"
  CPPFLAGS += -DDEFENV_SYSTEMC_ARCH=\"$(SYSTEMC_ARCH)\"
+ CPPFLAGS += -DDEFENV_SYSTEMC_INCLUDE=\"$(SYSTEMC_INCLUDE)\"
+ CPPFLAGS += -DDEFENV_SYSTEMC_LIBDIR=\"$(SYSTEMC_LIBDIR)\"
  CPPFLAGS += -DDEFENV_SYSTEMPERL=\"$(SYSTEMPERL)\"
  CPPFLAGS += -DDEFENV_SYSTEMPERL_INCLUDE=\"$(SYSTEMPERL_INCLUDE)\"
  ifeq ($(VERILATOR_ROOT),)	# Use what we're given, or intuit
@@ -106,6 +129,8 @@ HEADERS = $(wildcard V*.h v*.h)
 
 ASTGEN = $(srcdir)/astgen
 BISONPRE = $(srcdir)/bisonpre
+FLEXFIX = $(srcdir)/flexfix
+VLCOVGEN = $(srcdir)/vlcovgen
 
 ######################################################################
 #### Top level
@@ -141,11 +166,13 @@ RAW_OBJS = \
 	V3Broken.o \
 	V3Case.o \
 	V3Cast.o \
+	V3Cdc.o \
 	V3Changed.o \
 	V3Clean.o \
 	V3ClkGater.o \
 	V3Clock.o \
 	V3Combine.o \
+	V3Config.o \
 	V3Const__gen.o \
 	V3Coverage.o \
 	V3CoverageJoin.o \
@@ -159,9 +186,11 @@ RAW_OBJS = \
 	V3EmitCSyms.o \
 	V3EmitMk.o \
 	V3EmitV.o \
+	V3EmitXml.o \
 	V3Error.o \
 	V3Expand.o \
 	V3File.o \
+	V3FileLine.o \
 	V3Gate.o \
 	V3GenClk.o \
 	V3Graph.o \
@@ -174,11 +203,11 @@ RAW_OBJS = \
 	V3Inst.o \
 	V3Life.o \
 	V3LifePost.o \
-	V3Link.o \
 	V3LinkCells.o \
 	V3LinkDot.o \
-	V3LinkLevel.o \
+	V3LinkJump.o \
 	V3LinkLValue.o \
+	V3LinkLevel.o \
 	V3LinkParse.o \
 	V3LinkResolve.o \
 	V3Localize.o \
@@ -186,51 +215,57 @@ RAW_OBJS = \
 	V3Number.o \
 	V3Options.o \
 	V3Order.o \
+	V3Os.o \
 	V3Param.o \
 	V3PreShell.o \
 	V3Premit.o \
 	V3Scope.o \
-	V3Signed.o \
+	V3Slice.o \
 	V3Split.o \
 	V3SplitAs.o \
 	V3Stats.o \
 	V3StatsReport.o \
+	V3String.o \
 	V3Subst.o \
 	V3Table.o \
 	V3Task.o \
 	V3Trace.o \
 	V3TraceDecl.o \
 	V3Tristate.o \
+	V3Undriven.o \
 	V3Unknown.o \
 	V3Unroll.o \
 	V3Width.o \
 	V3WidthSel.o \
 
 # Non-concatable
-OBJS += \
-	V3Parse.o \
+NC_OBJS += \
+	V3ParseImp.o \
+	V3ParseGrammar.o \
+	V3ParseLex.o \
 	V3PreProc.o \
-	V3Read.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}
-	@-(cp [email protected] $@ || true)
-# ok if cp failes on linux, it's there to insure executable works on NT
 
 V3Number_test: V3Number_test.o
 	${LINK} ${LDFLAGS} -o $@ $^ ${LIBS}
@@ -241,24 +276,33 @@ V3Number_test: V3Number_test.o
 	$(PERL) $(ASTGEN) -I$(srcdir) $*.cpp
 
 %.o:	%.cpp
-	$(OBJCACHE) ${CXX} ${CPPFLAGS} -c $<
+	$(OBJCACHE) ${CXX} ${CPPFLAGSWALL} -c $<
 %.o:	%.c
-	$(OBJCACHE) ${CC}  ${CPPFLAGS} -c $<
+	$(OBJCACHE) ${CC}  ${CPPFLAGSWALL} -c $<
 
-V3Read.o:	V3Read.cpp V3Lexer.yy.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+V3ParseLex.o:	V3ParseLex.cpp V3Lexer.yy.cpp V3ParseBison.c
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
 
-V3Parse.o:	V3Parse.cpp V3ParseBison.c
-	$(OBJCACHE) ${CXX} ${CPPFLAGSNOWALL} -c $<
+V3ParseGrammar.o:	V3ParseGrammar.cpp V3ParseBison.c
+	$(OBJCACHE) ${CXX} ${CPPFLAGSPARSER} -c $<
+
+V3ParseImp.o:	V3ParseImp.cpp V3ParseBison.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
 
@@ -273,15 +317,15 @@ V3Lexer_pregen.yy.cpp:	verilog.l V3ParseBison.h $(HEADERS)
 	${LEX} --version
 	${LEX} ${LFLAGS} -o$@ $<
 
-V3Lexer.yy.cpp:	V3Lexer_pregen.yy.cpp
-	$(PERL) $(srcdir)/flexfix <$< >$@
+V3Lexer.yy.cpp:	V3Lexer_pregen.yy.cpp $(FLEXFIX)
+	$(PERL) $(FLEXFIX) V3Lexer <$< >$@
 
 V3PreLex_pregen.yy.cpp:	V3PreLex.l $(HEADERS)
 	${LEX} --version
 	${LEX} ${LFLAGS} -o$@ $<
 
-V3PreLex.yy.cpp:	V3PreLex_pregen.yy.cpp
-	$(PERL) $(srcdir)/flexfix <$< >$@
+V3PreLex.yy.cpp: V3PreLex_pregen.yy.cpp $(FLEXFIX)
+	$(PERL) $(FLEXFIX) V3PreLex <$< >$@
 
 ######################################################################
 ######################################################################

src/V3Active.cpp

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity active domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -84,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*) { }
@@ -148,7 +147,11 @@ public:
     }
 public:
     // CONSTUCTORS
-    ActiveNamer() {}
+    ActiveNamer() {
+	m_scopep = NULL;
+	m_iActivep = NULL;
+	m_cActivep = NULL;
+    }
     virtual ~ActiveNamer() {}
     void main(AstScope* nodep) {
 	nodep->accept(*this);
@@ -159,27 +162,67 @@ public:
 // Active AssignDly replacement functions
 
 class ActiveDlyVisitor : public ActiveBaseVisitor {
+public:
+    enum CheckType { CT_SEQ, CT_COMBO, CT_INITIAL, CT_LATCH };
 private:
+    CheckType 	m_check;	// Combo logic or other
+    AstNode*	m_alwaysp;	// Always we're under
+    AstNode*	m_assignp;	// In assign
     // VISITORS
     virtual void visit(AstAssignDly* nodep, AstNUser*) {
-	// Convert to a non-delayed assignment
-	UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
-	nodep->v3warn(COMBDLY,"Delayed assignments (<=) in non-clocked (non flop or latch) blocks should be non-delayed assignments (=).");
-	AstNode* newp = new AstAssign (nodep->fileline(),
-				       nodep->lhsp()->unlinkFrBack(),
-				       nodep->rhsp()->unlinkFrBack());
-	nodep->replaceWith(newp);
-	nodep->deleteTree(); nodep = NULL;
+	if (m_check != CT_SEQ) {
+	    // Convert to a non-delayed assignment
+	    UINFO(5,"    ASSIGNDLY "<<nodep<<endl);
+	    if (m_check == CT_INITIAL) {
+		nodep->v3warn(INITIALDLY,"Delayed assignments (<=) in initial or final block; suggest blocking assignments (=).");
+	    } else if (m_check == CT_LATCH) {
+		// Suppress. Shouldn't matter that the interior of the latch races 
+	    } else {
+		nodep->v3warn(COMBDLY,"Delayed assignments (<=) in non-clocked (non flop or latch) block; suggest blocking assignments (=).");
+	    }
+	    AstNode* newp = new AstAssign (nodep->fileline(),
+					   nodep->lhsp()->unlinkFrBack(),
+					   nodep->rhsp()->unlinkFrBack());
+	    nodep->replaceWith(newp);
+	    nodep->deleteTree(); VL_DANGLING(nodep);
+	}
+    }
+    virtual void visit(AstAssign* nodep, AstNUser*) {
+	if (m_check == CT_SEQ) {
+	    AstNode* las = m_assignp;
+	    m_assignp = nodep;
+	    nodep->lhsp()->iterateAndNext(*this);
+	    m_assignp = las;
+	}
+    }
+    virtual void visit(AstVarRef* nodep, AstNUser*) {
+	AstVar* varp=nodep->varp();
+	if (m_check == CT_SEQ
+	    && m_assignp
+	    && !varp->isUsedLoopIdx() // Ignore loop indicies
+	    && !varp->isTemp()
+	    ) {
+	    // Allow turning off warnings on the always, or the variable also
+	    if (!m_alwaysp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+		&& !m_assignp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+		&& !varp->fileline()->warnIsOff(V3ErrorCode::BLKSEQ)
+		) {
+		m_alwaysp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);  // Complain just once for the entire always
+		varp->fileline()->modifyWarnOff(V3ErrorCode::BLKSEQ, true);
+		nodep->v3warn(BLKSEQ,"Blocking assignments (=) in sequential (flop or latch) block; suggest delayed assignments (<=).");
+	    }
+	}
     }
-    // Empty visitors, speed things up
-    virtual void visit(AstNodeMath* nodep, AstNUser*) {}
     //--------------------
     virtual void visit(AstNode* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    ActiveDlyVisitor(AstNode* nodep) {
+    ActiveDlyVisitor(AstNode* nodep, CheckType check) {
+	m_alwaysp = nodep;
+	m_check = check;
+	m_assignp = NULL;
 	nodep->accept(*this);
     }
     virtual ~ActiveDlyVisitor() {}
@@ -197,7 +240,6 @@ private:
     // STATE
     ActiveNamer	m_namer;	// Tracking of active names
     AstCFunc*   m_scopeFinalp;	// Final function for this scope
-    AstAlways*	m_alwaysp;	// Under always
     bool	m_itemCombo;	// Found a SenItem combo
     bool	m_itemSequent;	// Found a SenItem sequential
 
@@ -216,6 +258,7 @@ private:
     virtual void visit(AstInitial* nodep, AstNUser*) {
 	// Relink to IACTIVE, unless already under it
 	UINFO(4,"    INITIAL "<<nodep<<endl);
+	ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_INITIAL);
 	AstActive* wantactivep = m_namer.getIActive(nodep->fileline());
 	nodep->unlinkFrBack();
 	wantactivep->addStmtsp(nodep);
@@ -245,13 +288,14 @@ 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->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign()+"\n"));
 	    m_scopeFinalp->dontCombine(true);
 	    m_scopeFinalp->formCallTree(true);
 	    m_scopeFinalp->slow(true);
@@ -260,46 +304,34 @@ 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
-    virtual void visit(AstAlways* nodep, AstNUser*) {
+    void visitAlways(AstNode* nodep, AstSenTree* oldsensesp, VAlwaysKwd kwd) {
 	// Move always to appropriate ACTIVE based on its sense list
-	UINFO(4,"    ALW   "<<nodep<<endl);
-	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
-
-	if (!nodep->bodysp()) {
-	    // Empty always.  Kill it.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
-	    return;
-	}
-	if (nodep->sensesp()
-	    && nodep->sensesp()->sensesp()
-	    && nodep->sensesp()->sensesp()->castSenItem()
-	    && nodep->sensesp()->sensesp()->castSenItem()->isNever()) {
+	if (oldsensesp
+	    && oldsensesp->sensesp()
+	    && oldsensesp->sensesp()->castSenItem()
+	    && oldsensesp->sensesp()->castSenItem()->isNever()) {
 	    // Never executing.  Kill it.
-	    if (nodep->sensesp()->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    if (oldsensesp->sensesp()->nextp()) nodep->v3fatalSrc("Never senitem should be alone, else the never should be eliminated.");
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	    return;
 	}
 
 	// Read sensitivitues
-	m_alwaysp = nodep;
 	m_itemCombo = false;
 	m_itemSequent = false;
-	nodep->sensesp()->iterateAndNext(*this);
-	m_alwaysp = NULL;
+	oldsensesp->iterateAndNext(*this);
 	bool combo = m_itemCombo;
 	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) {
@@ -311,15 +343,15 @@ private:
 	    // always (posedge RESET) { if (RESET).... }  we know RESET is true.
 	    // Summarize a long list of combo inputs as just "combo"
 #ifndef __COVERITY__ // Else dead code on next line.
-	    if (combo) nodep->sensesp()->addSensesp
+	    if (combo) oldsensesp->addSensesp
 			   (new AstSenItem(nodep->fileline(),AstSenItem::Combo()));
 #endif
-	    wantactivep = m_namer.getActive(nodep->fileline(), nodep->sensesp());
+	    wantactivep = m_namer.getActive(nodep->fileline(), oldsensesp);
 	}
 
 	// Delete sensitivity list
-	if (AstNode* oldsense = nodep->sensesp()) {
-	    oldsense->unlinkFrBackWithNext()->deleteTree(); oldsense=NULL;
+	if (oldsensesp) {
+	    oldsensesp->unlinkFrBackWithNext()->deleteTree(); VL_DANGLING(oldsensesp);
 	}
 
 	// Move node to new active
@@ -328,27 +360,52 @@ private:
 
 	// Warn and/or convert any delayed assignments
 	if (combo && !sequent) {
-	    ActiveDlyVisitor dlyvisitor (nodep);
+	    if (kwd == VAlwaysKwd::ALWAYS_LATCH) {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_LATCH);
+	    } else {
+		ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_COMBO);
+	    }
 	}
+	else if (!combo && sequent) {
+	    ActiveDlyVisitor dlyvisitor (nodep, ActiveDlyVisitor::CT_SEQ);
+	}
+    }
+    virtual void visit(AstAlways* nodep, AstNUser*) {
+	// Move always to appropriate ACTIVE based on its sense list
+	UINFO(4,"    ALW   "<<nodep<<endl);
+	//if (debug()>=9) nodep->dumpTree(cout,"  Alw: ");
+
+	if (!nodep->bodysp()) {
+	    // Empty always.  Kill it.
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
+	    return;
+	}
+	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(), VAlwaysKwd::ALWAYS);
     }
     virtual void visit(AstSenGate* nodep, AstNUser*) {
 	AstSenItem* subitemp = nodep->sensesp();
-	if (subitemp->edgeType() != AstEdgeType::ANYEDGE
-	    && subitemp->edgeType() != AstEdgeType::POSEDGE
-	    && subitemp->edgeType() != AstEdgeType::NEGEDGE) {
+	if (subitemp->edgeType() != AstEdgeType::ET_ANYEDGE
+	    && subitemp->edgeType() != AstEdgeType::ET_POSEDGE
+	    && subitemp->edgeType() != AstEdgeType::ET_NEGEDGE) {
 	    nodep->v3fatalSrc("Strange activity type under SenGate");
 	}
 	nodep->iterateChildren(*this);
     }
     virtual void visit(AstSenItem* nodep, AstNUser*) {
-	if (nodep->edgeType() == AstEdgeType::ANYEDGE) {
+	if (nodep->edgeType() == AstEdgeType::ET_ANYEDGE) {
 	    m_itemCombo = true;
 	    // Delete the sensitivity
 	    // We'll add it as a generic COMBO SenItem in a moment.
-	    nodep->unlinkFrBack()->deleteTree(); nodep=NULL;
+	    nodep->unlinkFrBack()->deleteTree(); VL_DANGLING(nodep);
 	} else if (nodep->varrefp()) {
 	    // V3LinkResolve should have cleaned most of these up
-	    if (nodep->varrefp()->width()>1) nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
+	    if (!nodep->varrefp()->width1()) nodep->v3error("Unsupported: Non-single bit wide signal pos/negedge sensitivity: "
 							    <<nodep->varrefp()->prettyName());
 	    m_itemSequent = true;
 	    nodep->varrefp()->varp()->usedClock(true);
@@ -364,9 +421,8 @@ private:
     }
 public:
     // CONSTUCTORS
-    ActiveVisitor(AstNetlist* nodep) {
+    explicit ActiveVisitor(AstNetlist* nodep) {
 	m_scopeFinalp = NULL;
-	m_alwaysp = NULL;
 	m_itemCombo = false;
 	m_itemSequent = false;
 	nodep->accept(*this);
@@ -380,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity block domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity active domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -72,7 +71,7 @@ private:
 	nodep->iterateChildren(*this);
 	m_topscopep = NULL;
     }
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	// Create required actives and add to module
 	// We can start ordering at a module, or a scope
 	UINFO(4," MOD   "<<nodep<<endl);
@@ -88,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
@@ -133,6 +132,9 @@ private:
     virtual void visit(AstAlways* nodep, AstNUser*) {
 	nodep->v3fatalSrc("Node should have been under ACTIVE");
     }
+    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+	nodep->v3fatalSrc("Node should have been under ACTIVE");
+    }
     virtual void visit(AstFinal* nodep, AstNUser*) {
 	nodep->v3fatalSrc("Node should have been deleted");
     }
@@ -145,7 +147,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    ActiveTopVisitor(AstNetlist* nodep) {
+    explicit ActiveTopVisitor(AstNetlist* nodep) {
 	m_topscopep = NULL;
 	nodep->accept(*this);
     }
@@ -158,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity block domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Collect and print statistics
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2005-2009 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.
@@ -44,7 +43,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // STATE
-    AstModule*	m_modp;		// Last module
+    AstNodeModule*	m_modp;		// Last module
     AstBegin*	m_beginp;	// Last begin
     V3Double0	m_statAsCover;	// Statistic tracking
     V3Double0	m_statAsPsl;	// Statistic tracking
@@ -57,47 +56,40 @@ private:
 		+":"+cvtToStr(nodep->fileline()->lineno())
 		+": Assertion failed in %m"
 		+((message != "")?": ":"")+message
-		+"\\n");
+		+"\n");
     }
     void replaceDisplay(AstDisplay* nodep, const string& prefix) {
-	nodep->displayType(AstDisplayType::WRITE);
-	nodep->text(assertDisplayMessage(nodep, prefix, nodep->text()));
-	AstNode* timesp = nodep->exprsp(); if (timesp) timesp->unlinkFrBack();
-	timesp = timesp->addNext(new AstTime(nodep->fileline()));
-	nodep->exprsp(timesp);
-	if (!nodep->scopeNamep()
-	    && (nodep->name().find("%m") != string::npos
-		|| nodep->name().find("%M") != string::npos)) {
-	    nodep->scopeNamep(new AstScopeName(nodep->fileline()));
+	nodep->displayType(AstDisplayType::DT_WRITE);
+	nodep->fmtp()->text(assertDisplayMessage(nodep, prefix, nodep->fmtp()->text()));
+	// 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()));
 	}
     }
 
     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(), V3Number(nodep->fileline(), 1, 0)))),
-			  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(), V3Number(nodep->fileline(), 1, 1)))
-			   : (AstNode*)(new AstConst(nodep->fileline(), V3Number(nodep->fileline(), 1, 0)))),
-			  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) {
-	AstDisplay* dispp = new AstDisplay (nodep->fileline(), AstDisplayType::ERROR, message, NULL, NULL);
+	AstDisplay* dispp = new AstDisplay (nodep->fileline(), AstDisplayType::DT_ERROR, message, NULL, NULL);
 	AstNode* bodysp = dispp;
 	replaceDisplay(dispp, "%%Error");   // Convert to standard DISPLAY format
 	bodysp->addNext(new AstStop (nodep->fileline()));
@@ -124,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::UNLIKELY);
+	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 	//
 	AstNode* newp = new AstAlways (nodep->fileline(),
+				       VAlwaysKwd::ALWAYS,
 				       sentreep,
 				       bodysp);
 	// Install it
@@ -151,7 +138,7 @@ private:
 	    nodep->replaceWith(newp);
 	}
 	// Bye
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     void newVAssertion(AstVAssert* nodep, AstNode* propp) {
@@ -168,35 +155,90 @@ private:
 
 	AstIf* ifp = new AstIf (nodep->fileline(), propp, passsp, failsp);
 	AstNode* newp = ifp;
-	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::UNLIKELY);
+	if (nodep->castVAssert()) ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 	//
 	// 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
     virtual void visit(AstCase* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	if (!nodep->user1()) {
-	    nodep->user1(true);
+	if (!nodep->user1SetOnce()) {
 	    bool has_default=false;
 	    for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 		if (itemp->isDefault()) has_default=true;
 	    }
-	    if (nodep->fullPragma()) {
+	    if (nodep->fullPragma() || nodep->priorityPragma()) {
 		// Simply need to add a default if there isn't one already
-		m_statAsFull++;
+		++m_statAsFull;
 		if (!has_default) {
 		    nodep->addItemsp(new AstCaseItem(nodep->fileline(), NULL/*DEFAULT*/,
 						     newFireAssert(nodep, "synthesis full_case, but non-match found")));
 		}
 	    }
-	    if (nodep->parallelPragma()) {
+	    if (nodep->parallelPragma() || nodep->uniquePragma() || nodep->unique0Pragma()) {
 		// Need to check that one, and only one of the case items match at any moment
 		// If there's a default, we allow none to match, else exactly one must match
-		m_statAsFull++;
+		++m_statAsFull;
 		if (!has_default && !nodep->itemsp()) {
 		    // Not parallel, but harmlessly so.
 		} else {
@@ -210,14 +252,15 @@ private:
 			    else propp = onep;
 			}
 		    }
-		    AstNode* ohot = (has_default
+		    bool allow_none = has_default || nodep->unique0Pragma();
+		    AstNode* ohot = (allow_none
 				     ? (new AstOneHot0(nodep->fileline(), propp))->castNode()
 				     : (new AstOneHot (nodep->fileline(), propp))->castNode());
 		    AstIf* ifp = new AstIf (nodep->fileline(),
 					    new AstLogNot (nodep->fileline(), ohot),
 					    newFireAssert(nodep, "synthesis parallel_case, but multiple matches found"),
 					    NULL);
-		    ifp->branchPred(AstBranchPred::UNLIKELY);
+		    ifp->branchPred(AstBranchPred::BP_UNLIKELY);
 		    nodep->addNotParallelp(ifp);
 		}
 	    }
@@ -228,12 +271,12 @@ private:
     virtual void visit(AstDisplay* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	// Replace the special types with standard text
-	if (nodep->displayType()==AstDisplayType::INFO) {
+	if (nodep->displayType()==AstDisplayType::DT_INFO) {
 	    replaceDisplay(nodep, "-Info");
-	} else if (nodep->displayType()==AstDisplayType::WARNING) {
+	} else if (nodep->displayType()==AstDisplayType::DT_WARNING) {
 	    replaceDisplay(nodep, "%%Warning");
-	} else if (nodep->displayType()==AstDisplayType::ERROR
-		   || nodep->displayType()==AstDisplayType::FATAL) {
+	} else if (nodep->displayType()==AstDisplayType::DT_ERROR
+		   || nodep->displayType()==AstDisplayType::DT_FATAL) {
 	    replaceDisplay(nodep, "%%Error");
 	}
     }
@@ -242,22 +285,16 @@ 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;
-	m_statAsCover++;
-    }
-    virtual void visit(AstPslAssert* nodep, AstNUser*) {
-	nodep->iterateChildren(*this);
-	newPslAssertion(nodep, nodep->propp(), nodep->sentreep(),
-			NULL, nodep->name()); nodep=NULL;
-	m_statAsPsl++;
+			nodep->stmtsp(), nodep->name()); VL_DANGLING(nodep);
+	++m_statAsCover;
     }
     virtual void visit(AstVAssert* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
-	newVAssertion(nodep, nodep->propp()); nodep=NULL;
-	m_statAsSV++;
+	newVAssertion(nodep, nodep->propp()); VL_DANGLING(nodep);
+	++m_statAsSV;
     }
 
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	m_modp = nodep;
 	//
 	nodep->iterateChildren(*this);
@@ -275,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
@@ -308,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Assertion expansion
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2005-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Collect and print statistics
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2005-2009 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.
@@ -74,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
@@ -92,7 +83,7 @@ private:
 	} else {
 	    nodep->unlinkFrBack();
 	}
-	pushDeletep(nodep); nodep=NULL;
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
 
     virtual void visit(AstPslCover* nodep, AstNUser*) {
@@ -102,17 +93,10 @@ 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) {
-	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion\n");
+	    nodep->v3error("Unsupported: Only one PSL clock allowed per assertion");
 	}
 	// Block is the new expression to evaluate
 	AstNode* blockp = nodep->propp()->unlinkFrBack();
@@ -125,9 +109,9 @@ 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(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	// Reset defaults
 	m_seniDefaultp = NULL;
@@ -138,7 +122,7 @@ private:
 
 public:
     // CONSTRUCTORS
-    AssertPreVisitor(AstNetlist* nodep) {
+    explicit AssertPreVisitor(AstNetlist* nodep) {
 	m_seniDefaultp = NULL;
 	clearAssertInfo();
 	// Process
@@ -153,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Assertion pre-expansion
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2005-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Ast node structures
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -29,6 +28,7 @@
 #include "V3File.h"
 #include "V3Global.h"
 #include "V3Broken.h"
+#include "V3String.h"
 
 //======================================================================
 // Statics
@@ -44,11 +44,16 @@ uint32_t AstUser1InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
 uint32_t AstUser2InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
 uint32_t AstUser3InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
 uint32_t AstUser4InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
+uint32_t AstUser5InUse::s_userCntGbl=0;	// Hot cache line, leave adjacent
 
 bool AstUser1InUse::s_userBusy=false;
 bool AstUser2InUse::s_userBusy=false;
 bool AstUser3InUse::s_userBusy=false;
 bool AstUser4InUse::s_userBusy=false;
+bool AstUser5InUse::s_userBusy=false;
+
+int AstNodeDType::s_uniqueNum = 0;
+
 
 //######################################################################
 // V3AstType
@@ -69,12 +74,12 @@ void AstNode::init() {
     m_op3p = NULL;
     m_op4p = NULL;
     m_iterpp = NULL;
+    m_dtypep = NULL;
     m_clonep = NULL;
     m_cloneCnt = 0;
     // Attributes
-    m_signed = false;
-    m_width = 0;
-    m_widthMin = 0;
+    m_didWidth = false;
+    m_doingWidth = false;
     m_user1p = NULL;
     m_user1Cnt = 0;
     m_user2p = NULL;
@@ -83,6 +88,8 @@ void AstNode::init() {
     m_user3Cnt = 0;
     m_user4p = NULL;
     m_user4Cnt = 0;
+    m_user5p = NULL;
+    m_user5Cnt = 0;
 }
 
 string AstNode::encodeName(const string& namein) {
@@ -109,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;
 }
 
@@ -140,7 +151,7 @@ string AstNode::dedotName(const string& namein) {
 }
 
 string AstNode::vcdName(const string& namein) {
-    // VCD tracing expects space to separate hiearchy
+    // VCD tracing expects space to separate hierarchy
     // Dots are reserved for dots the user put in the name
     string pretty = namein;
     string::size_type pos;
@@ -170,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;
@@ -188,6 +203,7 @@ string AstNode::prettyName(const string& namein) {
 	}
     }
     if (pretty.substr(0,4) == "TOP.") pretty.replace(0,4,"");
+    if (pretty.substr(0,5) == "TOP->") pretty.replace(0,5,"");
     return pretty;
 }
 
@@ -196,40 +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;
-}
-
-int AstNode::widthPow2() const {
-    // I.e.  width 30 returns 32, width 32 returns 32.
-    uint32_t width = this->width();
-    for (int p2=30; p2>=0; p2--) {
-	if (width > (1UL<<p2)) return (1UL<<(p2+1));
-    }
-    return 1;
-}
-
 //######################################################################
 // Insertion
 
@@ -238,9 +220,12 @@ inline void AstNode::debugTreeChange(const char* prefix, int lineno, bool next)
     // Called on all major tree changers.
     // Only for use for those really nasty bugs relating to internals
     // Note this may be null.
-    //if (debug()) cout<<"-treeChange: V3Ast.cpp:"<<lineno<<" Tree Change for "<<prefix<<": "<<(void*)this<<endl;
+    //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);
@@ -423,7 +408,7 @@ void AstNode::replaceWith(AstNode* newp) {
     repHandle.relink(newp);
 }
 
-void AstNRelinker::dump(ostream& str) {
+void AstNRelinker::dump(ostream& str) const {
     str<<" BK="<<(uint32_t*)m_backp;
     str<<" ITER="<<(uint32_t*)m_iterpp;
     str<<" CHG="<<(m_chg==RELINK_NEXT?"[NEXT] ":"");
@@ -563,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;
@@ -693,14 +678,17 @@ AstNode::~AstNode() {
 
 void AstNode::deleteTreeIter() {
     if (!this) return;
-    // MUST be depth first!
-    this->m_op1p->deleteTreeIter();
-    this->m_op2p->deleteTreeIter();
-    this->m_op3p->deleteTreeIter();
-    this->m_op4p->deleteTreeIter();
-    this->m_nextp->deleteTreeIter();
-    this->m_backp = NULL;
-    deleteNode();
+    for (AstNode* nodep=this, *nnextp; nodep; nodep=nnextp) {
+	nnextp = nodep->m_nextp;
+	// MUST be depth first!
+	nodep->m_op1p->deleteTreeIter();
+	nodep->m_op2p->deleteTreeIter();
+	nodep->m_op3p->deleteTreeIter();
+	nodep->m_op4p->deleteTreeIter();
+	nodep->m_nextp = NULL;
+	nodep->m_backp = NULL;
+	nodep->deleteNode();
+    }
 }
 
 void AstNode::deleteTree() {
@@ -709,6 +697,7 @@ void AstNode::deleteTree() {
     if (!this) return;
     UASSERT(m_backp==NULL,"Delete called on node with backlink still set\n");
     this->debugTreeChange("-delTree:  ", __LINE__, true);
+    this->editCountInc();
     // MUST be depth first!
     deleteTreeIter();
 }
@@ -748,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,
@@ -756,18 +759,24 @@ void AstNode::iterateAndNext(AstNVisitor& v, AstNUser* vup) {
     // Future versions of this function may require the node to have a back to be iterated;
     // there's no lower level reason yet though the back must exist.
     AstNode* nodep=this;
+#ifdef VL_DEBUG  // Otherwise too hot of a function for debug
     if (VL_UNLIKELY(nodep && !nodep->m_backp)) nodep->v3fatalSrc("iterateAndNext node has no back");
+#endif
     while (nodep) {
-	AstNode* niterp = 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) return;
+	//if (niterp != nodep) UINFO(1,"iterateAndNext edited "<<(void*)nodep<<" now into "<<(void*)niterp<<endl);  // niterp maybe NULL, so need cast
+	if (!niterp) return;  // Perhaps node deleted inside accept
 	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;
 	}
     }
@@ -793,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;
     }
@@ -806,7 +816,7 @@ void AstNode::iterateAndNextIgnoreEdit(AstNVisitor& v, AstNUser* vup) {
 AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
     // Some visitors perform tree edits (such as V3Const), and may even
     // replace/delete the exact nodep that the visitor is called with.  If
-    // this happens, the parent will loose the handle to the node that was
+    // this happens, the parent will lose the handle to the node that was
     // processed.
     // To solve this, this function returns the pointer to the replacement node,
     // which in many cases is just the same node that was passed in.
@@ -818,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;
@@ -832,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
     }
@@ -843,36 +853,46 @@ AstNode* AstNode::acceptSubtreeReturnEdits(AstNVisitor& v, AstNUser* vup) {
 
 void AstNode::cloneRelinkTree() {
     if (!this) return;
-    this->cloneRelink();
-    m_op1p->cloneRelinkTree();
-    m_op2p->cloneRelinkTree();
-    m_op3p->cloneRelinkTree();
-    m_op4p->cloneRelinkTree();
-    m_nextp->cloneRelinkTree();  // Tail recursion
+    for (AstNode* nodep=this; nodep; nodep=nodep->m_nextp) {
+	if (m_dtypep && m_dtypep->clonep()) {
+	    m_dtypep = m_dtypep->clonep()->castNodeDType();
+	}
+	nodep->cloneRelink();
+	nodep->m_op1p->cloneRelinkTree();
+	nodep->m_op2p->cloneRelinkTree();
+	nodep->m_op3p->cloneRelinkTree();
+	nodep->m_op4p->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->width() != node2p->width()
-	|| this->isSigned() != node2p->isSigned()
-	|| !this->same(node2p)) {
+	|| this->dtypep() != node2p->dtypep()
+	|| !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))
 	);
 }
 
@@ -886,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);
 }
@@ -936,7 +956,35 @@ void AstNode::checkTree() {
     }
 }
 
-void AstNode::dumpPtrs(ostream& os) {
+void AstNode::dumpGdb() {  // For GDB only
+    if (!this) { cout<<"This=NULL"<<endl; return; }
+    dumpGdbHeader();
+    cout<<"  "; dump(cout); cout<<endl;
+}
+void AstNode::dumpGdbHeader() const {  // For GDB only
+    if (!this) { cout<<"This=NULL"<<endl; return; }
+    dumpPtrs(cout);
+    cout<<"  Fileline = "<<fileline()<<endl;
+}
+void AstNode::dumpTreeGdb() {  // For GDB only
+    if (!this) { cout<<"This=NULL"<<endl; return; }
+    dumpGdbHeader();
+    dumpTree(cout);
+}
+void AstNode::dumpTreeFileGdb(const char* filenamep) {  // For GDB only
+    string filename = filenamep ? filenamep : v3Global.debugFilename("debug.tree",98);
+    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();
     if (nextp()) os<<" next="<<(void*)nextp();
@@ -950,6 +998,7 @@ void AstNode::dumpPtrs(ostream& os) {
     if (user2p()) os<<" user2p="<<(void*)user2p();
     if (user3p()) os<<" user3p="<<(void*)user3p();
     if (user4p()) os<<" user4p="<<(void*)user4p();
+    if (user5p()) os<<" user5p="<<(void*)user5p();
     if (m_iterpp) {
 	os<<" iterpp="<<(void*)m_iterpp;
 	os<<"*="<<(void*)*m_iterpp;
@@ -978,14 +1027,16 @@ 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
-	    const auto_ptr<ofstream> logsp (V3File::new_ofstream(filename, append));
+	    UINFO(2,"Dumping "<<filename<<endl);
+	    const VL_UNIQUE_PTR<ofstream> logsp (V3File::new_ofstream(filename, append));
 	    if (logsp->fail()) v3fatalSrc("Can't write "<<filename);
-	    *logsp<<"Tree Dump from <e"<<dec<<editCountLast()<<">";
+	    *logsp<<"Verilator Tree Dump (format 0x3900) from <e"<<dec<<editCountLast()<<">";
 	    *logsp<<" to <e"<<dec<<editCountGbl()<<">"<<endl;
-	    if (editCountGbl()==editCountLast()) {
+	    if (editCountGbl()==editCountLast()
+		&& !(v3Global.opt.dumpTree()>=9)) {
 		*logsp<<endl;
 		*logsp<<"No changes since last dump!\n";
 	    } else {
@@ -1010,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 {
@@ -1018,6 +1069,64 @@ void AstNode::v3errorEnd(ostringstream& str) const {
     }
 }
 
+string AstNode::warnMore() const {
+    if (this) return this->fileline()->warnMore();
+    else return V3Error::warnMore();
+}
+
+//======================================================================
+// Data type conversion
+
+void AstNode::dtypeChgSigned(bool flag) {
+    if (!dtypep()) this->v3fatalSrc("No dtype when changing to (un)signed");
+    dtypeChgWidthSigned(dtypep()->width(), dtypep()->widthMin(),
+			flag ? AstNumeric::SIGNED : AstNumeric::UNSIGNED);
+}
+void AstNode::dtypeChgWidth(int width, int widthMin) {
+    if (!dtypep()) this->v3fatalSrc("No dtype when changing width");  // Use ChgWidthSigned(...UNSIGNED) otherwise
+    dtypeChgWidthSigned(width, widthMin, dtypep()->numeric());
+}
+
+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);
+    } else {
+	if (width==dtypep()->width()
+	    && widthMin==dtypep()->widthMin()
+	    && numeric==dtypep()->numeric()) return;  // Correct already
+	// FUTURE: We may be pointing at a two state data type, and this may
+	// convert it to logic.  Since the AstVar remains correct, we
+	// work OK but this assumption may break in the future.
+	// Note we can't just clone and do a widthForce, as if it's a BasicDType
+	// the msb() indications etc will be incorrect.
+	dtypeSetLogicSized(width, widthMin, numeric);
+    }
+}
+
+AstNodeDType* AstNode::findBasicDType(AstBasicDTypeKwd kwd) const {
+    // For 'simple' types we use the global directory.  These are all unsized.
+    // More advanced types land under the module/task/etc
+    return v3Global.rootp()->typeTablep()
+	->findBasicDType(fileline(), kwd);
+}
+AstNodeDType* AstNode::findBitDType(int width, int widthMin, AstNumeric numeric) const {
+    return v3Global.rootp()->typeTablep()
+	->findLogicBitDType(fileline(), AstBasicDTypeKwd::BIT, width, widthMin, numeric);
+}
+AstNodeDType* AstNode::findLogicDType(int width, int widthMin, AstNumeric numeric) const {
+    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);
+}
+
 //######################################################################
 // AstNVisitor
 

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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Ast node structures
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -36,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(); }
@@ -47,43 +60,128 @@ int AstNodeSel::bitConst() const {
     AstConst* constp=bitp()->castConst(); return (constp?constp->toSInt():0);
 }
 
+void AstNodeClassDType::repairMemberCache() {
+    clearCache();
+    for (AstMemberDType* itemp = membersp(); itemp; itemp=itemp->nextp()->castMemberDType()) {
+	if (m_members.find(itemp->name())!=m_members.end()) { itemp->v3error("Duplicate declaration of member name: "<<itemp->prettyName()); }
+	else m_members.insert(make_pair(itemp->name(), itemp));
+    }
+}
+
+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 (VL_UNLIKELY(exists.find(it->second) == exists.end())) {
+	    this->v3error("Internal: Structure member broken: "<<it->first);
+	    return "member broken";
+	}
+    }
+    return NULL;
+}
+
+int AstBasicDType::widthAlignBytes() const {
+    if (width()<=8) return 1;
+    else if (width()<=16) return 2;
+    else if (isQuad()) return 8;
+    else return 4;
+}
+
+int AstBasicDType::widthTotalBytes() const {
+    if (width()<=8) return 1;
+    else if (width()<=16) return 2;
+    else if (isQuad()) return 8;
+    else return widthWords()*(VL_WORDSIZE/8);
+}
+
+int AstNodeClassDType::widthTotalBytes() const {
+    if (width()<=8) return 1;
+    else if (width()<=16) return 2;
+    else if (isQuad()) return 8;
+    else return widthWords()*(VL_WORDSIZE/8);
+}
+
+int AstNodeClassDType::widthAlignBytes() const {
+    // Could do max across members but that would be slow,
+    // instead intuit based on total structure size
+    if (width()<=8) return 1;
+    else if (width()<=16) return 2;
+    else if (width()<=32) return 4;
+    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());
+    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
+    // when we combine wires cross-hierarchy we need a union of all characteristics.
     if (type == AstVarType::SUPPLY0) type = AstVarType::WIRE;
     if (type == AstVarType::SUPPLY1) type = AstVarType::WIRE;
     m_varType=type; 	// For debugging prints only
     // These flags get combined with the existing settings of the flags.
     if (type==AstVarType::INPUT || type==AstVarType::INOUT)
 	m_input = true;
-    if (type==AstVarType::OUTPUT || type==AstVarType::INOUT)
+    if (type==AstVarType::OUTPUT || type==AstVarType::INOUT) {
 	m_output = true;
-    if (type==AstVarType::INOUT || type==AstVarType::TRIWIRE)
+	m_declOutput = true;
+    }
+    if (type==AstVarType::INOUT || type==AstVarType::TRIWIRE
+	|| type==AstVarType::TRI0 || type==AstVarType::TRI1)
 	m_tristate = true;
-}
-
-int AstVar::widthAlignBytes() const {
-    if (width()<=8) return 1;
-    else if (width()<=16) return 2;
-    else if (isSc() ? isScQuad() : isQuad()) return 8;
-    else return 4;
-}
-
-int AstVar::widthTotalBytes() const {
-    if (width()<=8) return 1;
-    else if (width()<=16) return 2;
-    else if (isSc() ? isScQuad() : isQuad()) return 8;
-    else return widthWords()*(VL_WORDSIZE/8);
+    if (type==AstVarType::TRI0)
+	m_isPulldown = true;
+    if (type==AstVarType::TRI1)
+	m_isPullup = true;
 }
 
 string AstVar::verilogKwd() const {
@@ -93,31 +191,149 @@ string AstVar::verilogKwd() const {
 	return "input";
     } else if (isOutput()) {
 	return "output";
-    } else if (isInteger()) {
-	return "integer";
     } else if (isTristate()) {
 	return "tri";
     } else if (varType()==AstVarType::WIRE) {
 	return "wire";
     } else {
-	return "reg";
+	return dtypep()->name();
     }
 }
 
-string AstVar::cType() const {
-    if (widthMin() == 1) {
-	return "bool";
+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;
+    if (isWide() && isInOnly()) arg += "const ";
+    AstBasicDType* bdtypep = basicp();
+    bool strtype = bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::STRING;
+    if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::CHARPTR) {
+	arg += "const char*";
+    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::SCOPEPTR) {
+	arg += "const VerilatedScope*";
+    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::DOUBLE) {
+	arg += "double";
+    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::FLOAT) {
+	arg += "float";
+    } else if (strtype) {
+	if (isInOnly()) arg += "const ";
+	arg += "string";
+    } else if (widthMin() <= 8) {
+	arg += "CData";
+    } else if (widthMin() <= 16) {
+	arg += "SData";
     } else if (widthMin() <= VL_WORDSIZE) {
-	return "uint32_t";
+	arg += "IData";
+    } else if (isQuad()) {
+	arg += "QData";
     } else if (isWide()) {
-	return "uint32_t";  // []'s added later
-    } else {
-	return "uint64_t";
+	arg += "WData";  // []'s added later
     }
+    if (isWide() && !strtype) {
+	arg += " (& "+name();
+	arg += ")["+cvtToStr(widthWords())+"]";
+    } else {
+	if (forFunc && (isOutput() || (strtype && isInput()))) arg += "&";
+	if (named) arg += " "+name();
+    }
+    return arg;
+}
+
+string AstVar::vlEnumType() const {
+    string arg;
+    AstBasicDType* bdtypep = basicp();
+    bool strtype = bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::STRING;
+    if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::CHARPTR) {
+	return "VLVT_PTR";
+    } else if (bdtypep && bdtypep->keyword()==AstBasicDTypeKwd::SCOPEPTR) {
+	return "VLVT_PTR";
+    } else if (strtype) {
+	arg += "VLVT_STRING";
+    } else if (widthMin() <= 8) {
+	arg += "VLVT_UINT8";
+    } else if (widthMin() <= 16) {
+	arg += "VLVT_UINT16";
+    } else if (widthMin() <= VL_WORDSIZE) {
+	arg += "VLVT_UINT32";
+    } else if (isQuad()) {
+	arg += "VLVT_UINT64";
+    } else if (isWide()) {
+	arg += "VLVT_WDATA";
+    }
+    // else return "VLVT_UNKNOWN"
+    return arg;
+}
+
+string AstVar::vlEnumDir() const {
+    if (isInout()) {
+	return "VLVD_INOUT";
+    } else if (isInOnly()) {
+	return "VLVD_IN";
+    } else if (isOutOnly()) {
+	return "VLVD_OUT";
+    } else {
+	return "VLVD_NODIR";
+    }
+}
+
+string AstVar::cPubArgType(bool named, bool forReturn) const {
+    if (forReturn) named=false;
+    string arg;
+    if (isWide() && isInOnly()) arg += "const ";
+    if (widthMin() == 1) {
+	arg += "bool";
+    } else if (widthMin() <= VL_WORDSIZE) {
+	arg += "uint32_t";
+    } else if (isWide()) {
+	arg += "uint32_t";  // []'s added later
+    } else {
+	arg += "vluint64_t";
+    }
+    if (isWide()) {
+	if (forReturn) v3error("Unsupported: Public functions with >64 bit outputs; make an output of a public task instead");
+	arg += " (& "+name();
+	arg += ")["+cvtToStr(widthWords())+"]";
+    } else {
+	if (isOutput() && !forReturn) arg += "&";
+	if (named) arg += " "+name();
+    }
+    return arg;
+}
+
+string AstVar::dpiArgType(bool named, bool forReturn) const {
+    if (forReturn) named=false;
+    string arg;
+    if (!basicp()) arg = "UNKNOWN";
+    if (basicp()->isBitLogic()) {
+	if (widthMin() == 1) {
+	    arg = "unsigned char";
+	    if (!forReturn && isOutput()) arg += "*";
+	} else {
+	    if (forReturn) {
+		arg = "svBitVecVal";
+	    } else if (isInOnly()) {
+		arg = "const svBitVecVal*";
+	    } else {
+		arg = "svBitVecVal*";
+	    }
+	}
+    } else {
+	arg = basicp()->keyword().dpiType();
+	if (basicp()->keyword().isDpiUnsignable() && !basicp()->isSigned()) {
+	    arg = "unsigned "+arg;
+	}
+	if (!forReturn && isOutput()) arg += "*";
+    }
+    if (named) arg += " "+name();
+    return arg;
 }
 
 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";
@@ -130,50 +346,129 @@ string AstVar::scType() const {
 	    return "uint32_t";
 	}
     } else {
-	return "uint64_t";
+	return "vluint64_t";
     }
 }
 
-AstRange* AstVar::arrayp(int dimension) const {
-    for (AstRange* arrayp=this->arraysp(); arrayp; arrayp = arrayp->nextp()->castRange()) {
-	if ((dimension--)==0) return arrayp;
+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;
 }
 
-int AstVar::arrayDimensions() const {
-    int  entries=0;
-    for (AstRange* arrayp=this->arraysp(); arrayp; arrayp = arrayp->nextp()->castRange()) {
-	entries++;
-    }
-    return entries;
-}
-
-uint32_t AstVar::arrayElements() const {
-    uint32_t entries=1;
-    for (AstRange* arrayp=this->arraysp(); arrayp; arrayp = arrayp->nextp()->castRange()) {
-	entries *= arrayp->elementsConst();
-    }
-    return entries;
-}
-
-// Special operators
-int AstArraySel::dimension(AstNode* nodep) {	///< How many dimensions is this reference from the base variable?
-    // Only called after V3Param; so only ArraySel's need to be recursed
+AstNodeDType* AstNodeDType::dtypeDimensionp(int dimension) {
+    // dimension passed from AstArraySel::dimension
+    // Dimension 0 means the VAR itself, 1 is the closest SEL to the AstVar,
+    // which is the lowest in the dtype list.
+    //     ref order:   a[1][2][3][4]
+    //     Created as:  reg [4] a [1][2][3];
+    //        *or*      reg a [1][2][3][4];
+    //     		// The bit select is optional; used only if "leftover" []'s
+    //	   SEL:	        SEL4(SEL3(SEL2(SEL1(VARREF0 a))))
+    //	   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;
-    while (nodep) {
-	if (nodep->castNodeSel()) { dim++; nodep=nodep->castNodeSel()->fromp(); continue; }
-	if (nodep->castNodePreSel()) { dim++; nodep=nodep->castNodePreSel()->fromp(); continue; }
+    for (AstNodeDType* dtypep=this; dtypep; ) {
+	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
+	if (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
+	    if ((dim++)==dimension) {
+		return dtypep;
+	    }
+	    dtypep = adtypep->subDTypep();
+	    continue;
+	}
+	else if (AstBasicDType* adtypep = dtypep->castBasicDType()) {
+	    // AstBasicDType - nothing below, return null
+	    if (adtypep->isRanged()) {
+		if ((dim++) == dimension) {
+		    return adtypep;
+		}
+	    }
+	    return NULL;
+	}
+	else if (AstNodeClassDType* adtypep = dtypep->castNodeClassDType()) {
+	    if (adtypep->packed()) {
+		if ((dim++) == dimension) {
+		    return adtypep;
+		}
+	    }
+	    return NULL;
+	}
+	// Node no ->next in loop; use continue where necessary
 	break;
     }
-    return dim;
+    return NULL;
 }
+
+uint32_t AstNodeDType::arrayUnpackedElements() {
+    uint32_t entries=1;
+    for (AstNodeDType* dtypep=this; dtypep; ) {
+	dtypep = dtypep->skipRefp();  // Skip AstRefDType/AstTypedef, or return same node
+	if (AstUnpackArrayDType* adtypep = dtypep->castUnpackArrayDType()) {
+	    entries *= adtypep->elementsConst();
+	    dtypep = adtypep->subDTypep();
+	}
+	else {
+	    // AstBasicDType - nothing below, 1
+	    break;
+	}
+    }
+    return entries;
+}
+
+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 (AstNodeArrayDType* adtypep = dtypep->castNodeArrayDType()) {
+	    if (adtypep->castPackArrayDType()) packed++;
+	    else unpacked++;
+	    dtypep = adtypep->subDTypep();
+	    continue;
+	}
+	else if (AstBasicDType* adtypep = dtypep->castBasicDType()) {
+	    if (includeBasic && adtypep->isRanged()) packed++;
+	}
+	break;
+    }
+    return make_pair(packed, unpacked);
+}
+
+int AstNodeDType::widthPow2() const {
+    // I.e.  width 30 returns 32, width 32 returns 32.
+    uint32_t width = this->width();
+    for (int p2=30; p2>=0; p2--) {
+	if (width > (1UL<<p2)) return (1UL<<(p2+1));
+    }
+    return 1;
+}
+
 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 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()) {
@@ -188,25 +483,57 @@ 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() {
     if (m_aboveScopep && m_aboveScopep->clonep()) m_aboveScopep->clonep()->castScope();
     if (m_aboveCellp && m_aboveCellp->clonep()) m_aboveCellp->clonep()->castCell();
-    if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep()->castModule();
+    if (m_modp && ((AstNode*)m_modp)->clonep()) ((AstNode*)m_modp)->clonep()->castNodeModule();
 }
 
 string AstScope::nameDotless() const {
-    string dotless = shortName();
+    string out = shortName();
     string::size_type pos;
-    while ((pos=dotless.find(".")) != string::npos) {
-	dotless.replace(pos, 1, "__");
+    while ((pos=out.find(".")) != string::npos) {
+	out.replace(pos, 1, "__");
     }
-    return dotless;
+    return out;
+}
+
+string AstScopeName::scopePrettyNameFormatter(AstText* scopeTextp) const {
+    string out;
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
+	out += textp->text();
+    }
+    // TOP will be replaced by top->name()
+    if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
+    if (out.substr(0,7) == "__DOT__") out.replace(0,7,"");
+    if (out.substr(0,1) == ".") out.replace(0,1,"");
+    return AstNode::prettyName(out);
+}
+
+string AstScopeName::scopeNameFormatter(AstText* scopeTextp) const {
+    string out;
+    for (AstText* textp=scopeTextp; textp; textp=textp->nextp()->castText()) {
+	out += textp->text();
+    }
+    if (out.substr(0,10) == "__DOT__TOP") out.replace(0,10,"");
+    if (out.substr(0,7) == "__DOT__") out.replace(0,7,"");
+    if (out.substr(0,1) == ".") out.replace(0,1,"");
+    string::size_type pos;
+    while ((pos=out.find(".")) != string::npos) {
+	out.replace(pos, 1, "__");
+    }
+    while ((pos=out.find("__DOT__")) != string::npos) {
+	out.replace(pos, 7, "__");
+    }
+    return out;
 }
 
 bool AstSenTree::hasClocked() {
@@ -238,6 +565,96 @@ bool AstSenTree::hasCombo() {
     return false;
 }
 
+void AstTypeTable::clearCache() {
+    // When we mass-change widthMin in V3WidthCommit, we need to correct the table.
+    // Just clear out the maps; the search functions will be used to rebuild the map
+    for (int i=0; i<(int)(AstBasicDTypeKwd::_ENUM_MAX); ++i) {
+	m_basicps[i] = NULL;
+    }
+    for (int isbit=0; isbit<_IDX0_MAX; ++isbit) {
+	for (int numer=0; numer<AstNumeric::_ENUM_MAX; ++numer) {
+	    LogicMap& mapr = m_logicMap[isbit][numer];
+	    mapr.clear();
+	}
+    }
+    m_detailedMap.clear();
+    // Clear generic()'s so dead detection will work
+    for (AstNode* nodep = typesp(); nodep; nodep=nodep->nextp()) {
+	if (AstBasicDType* bdtypep = nodep->castBasicDType()) {
+	    bdtypep->generic(false);
+	}
+    }
+}
+
+void AstTypeTable::repairCache() {
+    // After we mass-change widthMin in V3WidthCommit, we need to correct the table.
+    clearCache();
+    for (AstNode* nodep = typesp(); nodep; nodep=nodep->nextp()) {
+	if (AstBasicDType* bdtypep = nodep->castBasicDType()) {
+	    (void)findInsertSameDType(bdtypep);
+	}
+    }
+}
+
+AstBasicDType* AstTypeTable::findBasicDType(FileLine* fl, AstBasicDTypeKwd kwd) {
+    if (m_basicps[kwd]) return m_basicps[kwd];
+    //
+    AstBasicDType* new1p = new AstBasicDType(fl, kwd);
+    // Because the detailed map doesn't update this map,
+    // check the detailed map for this same node
+    // Also adds this new node to the detailed map
+    AstBasicDType* newp = findInsertSameDType(new1p);
+    if (newp != new1p) new1p->deleteTree();
+    else addTypesp(newp);
+    //
+    m_basicps[kwd] = newp;
+    return newp;
+}
+
+AstBasicDType* AstTypeTable::findLogicBitDType(FileLine* fl, AstBasicDTypeKwd kwd,
+					       int width, int widthMin, AstNumeric numeric) {
+    int idx = IDX0_LOGIC;
+    if (kwd == AstBasicDTypeKwd::LOGIC) idx = IDX0_LOGIC;
+    else if (kwd == AstBasicDTypeKwd::BIT) idx = IDX0_BIT;
+    else fl->v3fatalSrc("Bad kwd for findLogicBitDType");
+    pair<int,int> widths = make_pair(width,widthMin);
+    LogicMap& mapr = m_logicMap[idx][(int)numeric];
+    LogicMap::const_iterator it = mapr.find(widths);
+    if (it != mapr.end()) return it->second;
+    //
+    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
+    AstBasicDType* newp = findInsertSameDType(new1p);
+    if (newp != new1p) new1p->deleteTree();
+    else addTypesp(newp);
+    //
+    mapr.insert(make_pair(widths,newp));
+    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());
+    DetailedMap& mapr = m_detailedMap;
+    DetailedMap::const_iterator it = mapr.find(key);
+    if (it != mapr.end()) return it->second;
+    mapr.insert(make_pair(key,nodep));
+    nodep->generic(true);
+    // No addTypesp; the upper function that called new() is responsible for adding
+    return nodep;
+}
+
 //======================================================================
 // Special walking tree inserters
 
@@ -303,23 +720,51 @@ void AstWhile::addNextStmt(AstNode* newp, AstNode* belowp) {
 //======================================================================
 // Per-type Debugging
 
-void AstNode::dump(ostream& os) {
-    os<<typeName()<<" "<<(void*)this
+void AstNode::dump(ostream& str) {
+    str<<typeName()<<" "<<(void*)this
 	//<<" "<<(void*)this->m_backp
-      <<" <e"<<dec<<editCount()
-      <<((editCount()>=editCountLast())?"#>":">")
-      <<" {"<<dec<<fileline()->lineno()<<"}"
-      <<" "<<(isSigned()?"s":"")
-      <<"w"<<(widthSized()?"":"u")<<width();
-    if (!widthSized()) os<<"/"<<widthMin();
-    if (name()!="") os<<"  "<<AstNode::quoteName(name());
+       <<" <e"<<dec<<editCount()
+       <<((editCount()>=editCountLast())?"#>":">")
+       <<" {"<<fileline()->filenameLetters()<<dec<<fileline()->lineno()<<"}";
+    if (user1p()) str<<" u1="<<(void*)user1p();
+    if (user2p()) str<<" u2="<<(void*)user2p();
+    if (user3p()) str<<" u3="<<(void*)user3p();
+    if (user4p()) str<<" u4="<<(void*)user4p();
+    if (user5p()) str<<" u5="<<(void*)user5p();
+    if (hasDType()) {
+	if (dtypep()==this) str<<" @dt="<<"this@";
+	else str<<" @dt="<<(void*)dtypep()<<"@";  // Final @ so less likely to by accident think it's nodep
+	if (AstNodeDType* dtp = dtypep()) {
+	    dtp->dumpSmall(str);
+	}
+    } else { // V3Broken will throw an error
+	if (dtypep()) str<<" %Error-dtype-exp=null,got="<<(void*)dtypep();
+    }
+    if (name()!="") {
+	if (castConst()) str<<"  "<<name();  // Already quoted
+	else str<<"  "<<V3Number::quoteNameControls(name());
+    }
 }
 
+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()<<"]";
+}
 void AstAttrOf::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" ["<<attrType().ascii()<<"]";
 }
-void AstCast::dump(ostream& str) {
+void AstBasicDType::dump(ostream& str) {
+    this->AstNodeDType::dump(str);
+    str<<" kwd="<<keyword().ascii();
+    if (isRanged() && !rangep()) str<<" range=["<<left()<<":"<<right()<<"]";
+}
+void AstCCast::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" sz"<<size();
 }
@@ -336,40 +781,173 @@ void AstDisplay::dump(ostream& str) {
     this->AstNode::dump(str);
     //str<<" "<<displayType().ascii();
 }
+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]";
 }
-void AstVarXRef::dump(ostream& str) {
-    this->AstNode::dump(str);
-    if (lvalue()) str<<" [LV] => ";
-    else          str<<" [RV] <- ";
-    str<<dotted()<<". - ";
-    if (inlinedDots()!="") str<<" flat.="<<inlinedDots()<<" - ";
-    if (varScopep()) { varScopep()->dump(str); }
-    else if (varp()) { varp()->dump(str); }
-    else { str<<"UNLINKED"; }
+void AstRefDType::dump(ostream& str) {
+    this->AstNodeDType::dump(str);
+    if (defp()) { str<<" -> "; defp()->dump(str); }
+    else { str<<" -> UNLINKED"; }
 }
-void AstModule::dump(ostream& str) {
+void AstNodeClassDType::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (packed()) str<<" [PACKED]";
+}
+void AstNodeDType::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (generic()) str<<" [GENERIC]";
+    if (AstNodeDType* dtp = virtRefDTypep()) {
+	str<<" refdt="<<(void*)(dtp);
+	dtp->dumpSmall(str);
+    }
+}
+void AstNodeDType::dumpSmall(ostream& str) {
+    str<<"("
+       <<(generic()?"G/":"")
+       <<((isSigned()&&!isDouble())?"s":"")
+       <<(isNosign()?"n":"")
+       <<(isDouble()?"d":"")
+       <<(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();
     if (modPublic()) str<<" [P]";
     if (inLibrary()) str<<" [LIB]";
+    if (dead()) str<<" [DEAD]";
 }
+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) {
+	if (AstBasicDType* subnodep=m_basicps[i]) {
+	    str<<endl;  // Newline from caller, so newline first
+	    str<<"\t\t"<<setw(8)<<AstBasicDTypeKwd(i).ascii();
+	    str<<"  -> ";
+	    subnodep->dump(str);
+	}
+    }
+    for (int isbit=0; isbit<2; ++isbit) {
+	for (int issigned=0; issigned<AstNumeric::_ENUM_MAX; ++issigned) {
+	    LogicMap& mapr = m_logicMap[isbit][issigned];
+	    for (LogicMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
+		AstBasicDType* dtypep = it->second;
+		str<<endl;  // Newline from caller, so newline first
+		stringstream nsstr;
+		nsstr<<(isbit?"bw":"lw")
+		     <<it->first.first<<"/"<<it->first.second;
+		str<<"\t\t"<<setw(8)<<nsstr.str();
+		if (issigned) str<<" s"; else str<<" u";
+		str<<"  ->  ";
+		dtypep->dump(str);
+	    }
+	}
+    }
+    {
+	DetailedMap& mapr = m_detailedMap;
+	for (DetailedMap::const_iterator it = mapr.begin(); it != mapr.end(); ++it) {
+	    AstBasicDType* dtypep = it->second;
+	    str<<endl;  // Newline from caller, so newline first
+	    str<<"\t\tdetailed  ->  ";
+	    dtypep->dump(str);
+	}
+    }
+    // Note get newline from caller too.
+}
+
 void AstVarScope::dump(ostream& str) {
     this->AstNode::dump(str);
     if (isCircular()) str<<" [CIRC]";
     if (varp()) { str<<" -> "; varp()->dump(str); }
     else { str<<" ->UNLINKED"; }
 }
+void AstVarXRef::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    if (lvalue()) str<<" [LV] => ";
+    else          str<<" [RV] <- ";
+    str<<dotted()<<". - ";
+    if (inlinedDots()!="") str<<" inline.="<<inlinedDots()<<" - ";
+    if (varScopep()) { varScopep()->dump(str); }
+    else if (varp()) { varp()->dump(str); }
+    else { str<<"UNLINKED"; }
+}
 void AstVarRef::dump(ostream& str) {
     this->AstNode::dump(str);
+    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     if (lvalue()) str<<" [LV] => ";
     else          str<<" [RV] <- ";
     if (varScopep()) { varScopep()->dump(str); }
@@ -385,8 +963,12 @@ void AstVar::dump(ostream& str) {
 	else if (isInput()) str<<" [I]";
 	else if (isOutput()) str<<" [O]";
     }
-    if (isUsedClock()) str<<" [C]";
+    if (isConst()) str<<" [CONST]";
+    if (isPullup()) str<<" [PULLUP]";
+    if (isPulldown()) str<<" [PULLDOWN]";
+    if (isUsedClock()) str<<" [CLK]";
     if (isSigPublic()) str<<" [P]";
+    if (isUsedLoopIdx()) str<<" [LOOP]";
     if (attrClockEn()) str<<" [aCLKEN]";
     if (attrIsolateAssign()) str<<" [aISO]";
     if (attrFileDescr()) str<<" [aFD]";
@@ -406,6 +988,16 @@ void AstParseRef::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" ["<<expect().ascii()<<"]";
 }
+void AstPackageRef::dump(ostream& str) {
+    this->AstNode::dump(str);
+    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
+    str<<" -> ";
+    if (packagep()) { packagep()->dump(str); }
+    else { str<<"UNLINKED"; }
+}
+void AstDot::dump(ostream& str) {
+    this->AstNode::dump(str);
+}
 void AstActive::dump(ostream& str) {
     this->AstNode::dump(str);
     str<<" => ";
@@ -414,6 +1006,7 @@ void AstActive::dump(ostream& str) {
 }
 void AstNodeFTaskRef::dump(ostream& str) {
     this->AstNode::dump(str);
+    if (packagep()) { str<<" pkg="<<(void*)packagep(); }
     str<<" -> ";
     if (dotted()!="") { str<<dotted()<<". - "; }
     if (taskp()) { taskp()->dump(str); }
@@ -422,10 +1015,16 @@ void AstNodeFTaskRef::dump(ostream& str) {
 void AstNodeFTask::dump(ostream& str) {
     this->AstNode::dump(str);
     if (taskPublic()) str<<" [PUBLIC]";
+    if (prototype()) str<<" [PROTOTYPE]";
+    if (dpiImport()) str<<" [DPII]";
+    if (dpiExport()) str<<" [DPIX]";
+    if ((dpiImport() || dpiExport()) && cname()!=name()) str<<" [c="<<cname()<<"]";
 }
 void AstBegin::dump(ostream& str) {
     this->AstNode::dump(str);
     if (unnamed()) str<<" [UNNAMED]";
+    if (generate()) str<<" [GEN]";
+    if (genforp()) str<<" [GENFOR]";
 }
 void AstCoverDecl::dump(ostream& str) {
     this->AstNode::dump(str);
@@ -448,6 +1047,17 @@ void AstTraceInc::dump(ostream& str) {
     if (declp()) { declp()->dump(str); }
     else { str<<"%Error:UNLINKED"; }
 }
+void AstNodeText::dump(ostream& str) {
+    this->AstNode::dump(str);
+    string out = text();
+    string::size_type pos;
+    if ((pos = out.find("\n")) != string::npos) {
+	out.erase(pos,out.length()-pos);
+	out += "...";
+    }
+    str<<" \""<<out<<"\"";
+}
+
 void AstCFile::dump(ostream& str) {
     this->AstNode::dump(str);
     if (source()) str<<" [SRC]";
@@ -463,4 +1073,8 @@ void AstCCall::dump(ostream& str) {
 void AstCFunc::dump(ostream& str) {
     this->AstNode::dump(str);
     if (slow()) str<<" [SLOW]";
+    if (pure()) str<<" [PURE]";
+    if (dpiImport()) str<<" [DPII]";
+    if (dpiExport()) str<<" [DPIX]";
+    if (dpiExportWrapper()) str<<" [DPIXWR]";
 }

src/V3Begin.cpp

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Removal of named begin blocks
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -45,14 +44,37 @@
 
 //######################################################################
 
+class BeginState {
+private:
+    // NODE STATE
+    //Entire netlist:
+    // AstNodeFTask::user1	-> bool, 1=processed
+    AstUser1InUse	m_inuser1;
+    bool		m_anyFuncInBegin;
+public:
+    BeginState() {
+	m_anyFuncInBegin = false;
+    }
+    ~BeginState() {}
+    void userMarkChanged(AstNodeFTask* nodep) {
+	nodep->user1(true);
+	m_anyFuncInBegin = true;
+    }
+    bool anyFuncInBegin() const { return m_anyFuncInBegin; }
+};
+
+//######################################################################
+
 class BeginVisitor : public AstNVisitor {
 private:
     // STATE
-    AstModule*		m_modp;		// Current module
+    BeginState*		m_statep;	// Current global state
+    AstNodeModule*	m_modp;		// Current module
     AstNodeFTask* 	m_ftaskp;	// Current function/task
     string		m_namedScope;	// Name of begin blocks above us
     string		m_unnamedScope;	// Name of begin blocks, including unnamed blocks
     int			m_repeatNum;	// Repeat counter
+    int			m_ifDepth;	// Current if depth
 
     // METHODS
     static int debug() {
@@ -62,16 +84,34 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	m_modp = nodep;
 	m_repeatNum = 0;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
     }
     virtual void visit(AstNodeFTask* nodep, AstNUser*) {
-	m_ftaskp = nodep;
-	nodep->iterateChildren(*this);
-	m_ftaskp = NULL;
+	UINFO(8,"  "<<nodep<<endl);
+	// Rename it
+	if (m_unnamedScope != "") {
+	    nodep->name(m_unnamedScope+"__DOT__"+nodep->name());
+	    UINFO(8,"     rename to "<<nodep->name()<<endl);
+	    m_statep->userMarkChanged(nodep);
+	}
+	// BEGIN wrapping a function rename that function, but don't affect the inside function's variables
+	// We then restart with empty naming; so that any begin's inside the function will rename inside the function
+	// Process children
+	string oldScope = m_namedScope;
+	string oldUnnamed = m_unnamedScope;
+	{
+	    m_namedScope = "";
+	    m_unnamedScope = "";
+	    m_ftaskp = nodep;
+	    nodep->iterateChildren(*this);
+	    m_ftaskp = NULL;
+	}
+	m_namedScope = oldScope;
+	m_unnamedScope = oldUnnamed;
     }
     virtual void visit(AstBegin* nodep, AstNUser*) {
 	// Begin blocks were only useful in variable creation, change names and delete
@@ -79,7 +119,7 @@ private:
 	string oldScope = m_namedScope;
 	string oldUnnamed = m_unnamedScope;
 	{
-	    //UINFO(8,"nname "<<m_namedScope<<endl);
+	    UINFO(8,"nname "<<m_namedScope<<endl);
 	    if (nodep->name() != "") {  // Else unneeded unnamed block
 		// Create data for dotted variable resolution
 		string dottedname = nodep->name() + "__DOT__";  // So always found
@@ -94,25 +134,33 @@ private:
 		    if (m_unnamedScope=="") m_unnamedScope = ident;
 		    else m_unnamedScope = m_unnamedScope + "__DOT__"+ident;
 		    // Create CellInline for dotted var resolution
-		    AstCellInline* inlinep = new AstCellInline(nodep->fileline(),
-							       m_unnamedScope, "__BEGIN__");
-		    m_modp->addInlinesp(inlinep);  // Must be parsed before any AstCells
+		    if (!m_ftaskp) {
+			AstCellInline* inlinep = new AstCellInline(nodep->fileline(),
+								   m_unnamedScope, "__BEGIN__");
+			m_modp->addInlinesp(inlinep);  // Must be parsed before any AstCells
+		    }
 		}
 	    }
 
 	    // Remap var names and replace lower Begins
-	    nodep->iterateChildren(*this);
-
-	    if (AstNode* stmtsp = nodep->stmtsp()) {
-		stmtsp->unlinkFrBackWithNext();
-		nodep->replaceWith(stmtsp);
-	    } else {
-		nodep->unlinkFrBack();
-	    }
-	    pushDeletep(nodep); nodep=NULL;
+	    nodep->stmtsp()->iterateAndNext(*this);
+	    if (nodep->genforp()) nodep->v3fatalSrc("GENFORs should have been expanded earlier");
 	}
 	m_namedScope = oldScope;
 	m_unnamedScope = oldUnnamed;
+
+	// Cleanup
+	AstNode* addsp = NULL;
+	if (AstNode* stmtsp = nodep->stmtsp()) {
+	    stmtsp->unlinkFrBackWithNext();
+	    if (addsp) { addsp = addsp->addNextNull(stmtsp); } else { addsp = stmtsp; }
+	}
+	if (addsp) {
+	    nodep->replaceWith(addsp);
+	} else {
+	    nodep->unlinkFrBack();
+	}
+	pushDeletep(nodep); VL_DANGLING(nodep);
     }
     virtual void visit(AstVar* nodep, AstNUser*) {
 	if (m_unnamedScope != "") {
@@ -135,62 +183,15 @@ private:
 	    m_modp->addStmtp(nodep);
 	}
     }
-    virtual void visit(AstFor* nodep, AstNUser*) {
-	// So later optimizations don't need to deal with them,
-	//    FOR(init,cond,assign,body) -> init,WHILE(cond) { body, assign }
-	AstNode* initsp = nodep->initsp(); if (initsp) initsp->unlinkFrBackWithNext();
-	AstNode* condp = nodep->condp(); if (condp) condp->unlinkFrBackWithNext();
-	AstNode* incsp = nodep->incsp(); if (incsp) incsp->unlinkFrBackWithNext();
-	AstNode* bodysp = nodep->bodysp(); if (bodysp) bodysp->unlinkFrBackWithNext();
-	bodysp = bodysp->addNext(incsp);
-	AstNode* newp = new AstWhile(nodep->fileline(),
-				     condp,
-				     bodysp);
-	initsp = initsp->addNext(newp);
-	newp = initsp;
-	nodep->replaceWith(newp);
-	nodep->deleteTree(); nodep=NULL;
-    }
-    virtual void visit(AstRepeat* nodep, AstNUser*) {
-	// So later optimizations don't need to deal with them,
-	//    REPEAT(count,body) -> loop=count,WHILE(loop>0) { body, loop-- }
-	// Note var can be signed or unsigned based on original number.
-	AstNode* countp = nodep->countp()->unlinkFrBackWithNext();
-   	string name = string("__Vrepeat")+cvtToStr(m_repeatNum++);
-	AstVar* varp = new AstVar(nodep->fileline(), AstVarType::BLOCKTEMP, name,
-				  new AstRange(nodep->fileline(), countp->width()-1, 0));
-	m_modp->addStmtp(varp);
-	AstNode* initsp = new AstAssign(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, true),
-					countp);
-	AstNode* decp = new AstAssign(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, true),
-				      new AstSub(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
-						 new AstConst(nodep->fileline(), 1)));
-	AstNode* condp;
-	if (countp->isSigned()) {
-	    condp = new AstGtS(nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
-			       new AstConst(nodep->fileline(), 0));
-	} else {
-	    condp = new AstGt (nodep->fileline(), new AstVarRef(nodep->fileline(), varp, false),
-			       new AstConst(nodep->fileline(), 0));
-	}
-	AstNode* bodysp = nodep->bodysp(); if (bodysp) bodysp->unlinkFrBackWithNext();
-	bodysp = bodysp->addNext(decp);
-	AstNode* newp = new AstWhile(nodep->fileline(),
-				     condp,
-				     bodysp);
-	initsp = initsp->addNext(newp);
-	newp = initsp;
-	nodep->replaceWith(newp);
-	nodep->deleteTree(); nodep=NULL;
-    }
     virtual void visit(AstScopeName* nodep, AstNUser*) {
 	// If there's a %m in the display text, we add a special node that will contain the name()
 	// Similar code in V3Inline
+	if (nodep->user1SetOnce()) return;  // Don't double-add text's
 	if (m_namedScope != "") {
 	    // To keep correct visual order, must add before other Text's
 	    AstNode* afterp = nodep->scopeAttrp();
 	    if (afterp) afterp->unlinkFrBackWithNext();
-	    nodep->scopeAttrp(new AstText(nodep->fileline(), (string)"."+AstNode::prettyName(m_namedScope)));
+	    nodep->scopeAttrp(new AstText(nodep->fileline(), (string)"__DOT__"+m_namedScope));
 	    if (afterp) nodep->scopeAttrp(afterp);
 	}
 	nodep->iterateChildren(*this);
@@ -200,24 +201,75 @@ private:
 	// any BEGINs, but V3Coverage adds them all under the module itself.
 	nodep->iterateChildren(*this);
     }
+    // VISITORS - LINT CHECK
+    virtual void visit(AstIf* nodep, AstNUser*) { // Note not AstNodeIf; other types don't get covered
+	// Check IFDEPTH warning - could be in other transform files if desire
+	int prevIfDepth = m_ifDepth;
+	if (m_ifDepth == -1 || v3Global.opt.ifDepth()<1) { // Turned off
+	} else if (nodep->uniquePragma() || nodep->unique0Pragma() || nodep->priorityPragma()) {
+	    m_ifDepth = -1;
+	} else if (++m_ifDepth > v3Global.opt.ifDepth()) {
+	    nodep->v3warn(IFDEPTH,"Deep 'if' statement; suggest unique/priority to avoid slow logic");
+	    nodep->fileline()->modifyWarnOff(V3ErrorCode::IFDEPTH, true);  // Warn only once
+	    m_ifDepth = -1;
+	}
+	nodep->iterateChildren(*this);
+	m_ifDepth = prevIfDepth;
+     }
     virtual void visit(AstNode* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
     }
 public:
     // CONSTUCTORS
-    BeginVisitor(AstNetlist* nodep) {
+    BeginVisitor(AstNetlist* nodep, BeginState* statep) {
+	m_statep = statep;
 	m_modp = NULL;
 	m_ftaskp = NULL;
 	m_repeatNum = 0;
+	m_ifDepth = 0;
 	nodep->accept(*this);
     }
     virtual ~BeginVisitor() {}
 };
 
+//######################################################################
+
+class BeginRelinkVisitor : public AstNVisitor {
+    // Replace tasks with new pointer
+private:
+    // NODE STATE
+    //  Input:
+    //   AstNodeFTask::user1p		// Node replaced, rename it
+
+    // VISITORS
+    virtual void visit(AstNodeFTaskRef* nodep, AstNUser*) {
+	if (nodep->taskp()->user1()) { // It was converted
+	    UINFO(9, "    relinkFTask "<<nodep<<endl);
+	    nodep->name(nodep->taskp()->name());
+	}
+	nodep->iterateChildren(*this);
+    }
+    //--------------------
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+public:
+    // CONSTUCTORS
+    BeginRelinkVisitor(AstNetlist* nodep, BeginState*) {
+	nodep->accept(*this);
+    }
+    virtual ~BeginRelinkVisitor() {}
+};
+
 //######################################################################
 // Task class functions
 
 void V3Begin::debeginAll(AstNetlist* nodep) {
     UINFO(2,__FUNCTION__<<": "<<endl);
-    BeginVisitor bvisitor (nodep);
+    BeginState state;
+    { BeginVisitor bvisitor (nodep,&state); }
+    if (state.anyFuncInBegin()) {
+	BeginRelinkVisitor brvisitor (nodep,&state);
+    }
+    V3Global::dumpCheckGlobalTree("begin.tree", 0, v3Global.opt.dumpTreeLevel(__FILE__) >= 3);
 }

src/V3Begin.h

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Removal of named begin blocks
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Branch prediction
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -22,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
 //
 //*************************************************************************
 
@@ -41,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() {
@@ -56,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*) {
@@ -76,28 +93,45 @@ private:
 	    // Compute
 	    int likeness = ifLikely - ifUnlikely - (elseLikely - elseUnlikely);
 	    if (likeness>0) {
-		nodep->branchPred(AstBranchPred::LIKELY);
+		nodep->branchPred(AstBranchPred::BP_LIKELY);
 	    } else if (likeness<0) {
-		nodep->branchPred(AstBranchPred::UNLIKELY);
+		nodep->branchPred(AstBranchPred::BP_UNLIKELY);
 	    } // else leave unknown
 	}
 	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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Branch prediction
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Find broken links in tree
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -38,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 {
@@ -48,15 +50,16 @@ 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
+    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) {
 	// Called by operator delete on any node - only if VL_LEAK_CHECKS
-	if (debug()) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
+	if (debug()>=9) cout<<"-nodeDel:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter==s_nodes.end() || !(iter->second & FLAG_ALLOCATED)) {
 	    ((AstNode*)(nodep))->v3fatalSrc("Deleting AstNode object that was never tracked or already deleted\n");
@@ -65,13 +68,23 @@ public:
     }
     static void addNewed(const AstNode* nodep) {
 	// Called by operator new on any node - only if VL_LEAK_CHECKS
-	if (debug()) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
+	if (debug()>=9) cout<<"-nodeNew:  "<<(void*)(nodep)<<endl;
 	NodeMap::iterator iter = s_nodes.find(nodep);
 	if (iter!=s_nodes.end() || (iter->second & FLAG_ALLOCATED)) {
 	    ((AstNode*)(nodep))->v3fatalSrc("Newing AstNode object that is already allocated\n");
 	}
 	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) {
+	// Called by BrokenCheckVisitor when each node entered/exited
+	if (!okIfLinkedTo(nodep)) return;
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter!=s_nodes.end()) {
+	    iter->second &= ~FLAG_UNDER_NOW;
+	    if (flag) iter->second |=  FLAG_UNDER_NOW;
 	}
     }
     static void addInTree(AstNode* nodep, bool linkable) {
@@ -111,6 +124,14 @@ public:
 	if (!(iter->second & FLAG_LINKABLE)) return false;
 	return true;
     }
+    static bool okIfBelow(const AstNode* nodep) {
+	// Must be linked to and below current node
+	if (!okIfLinkedTo(nodep)) return false;
+	NodeMap::iterator iter = s_nodes.find(nodep);
+	if (iter == s_nodes.end()) return false;
+	if (!(iter->second & FLAG_UNDER_NOW)) return false;
+	return true;
+    }
     static void prepForTree() {
 #ifndef VL_LEAK_CHECKS
 	s_nodes.clear();
@@ -129,7 +150,7 @@ public:
 		    && (it->first->backp() ? backs==1 : backs==0)) {
 		    // Use only AstNode::dump instead of the virtual one, as there
 		    // may be varp() and other cross links that are bad.
-		    if (debug()) {
+		    if (v3Global.opt.debugCheck()) {
 			cerr<<"%Error: LeakedNode"<<(it->first->backp()?"Back: ":": ");
 			((AstNode*)(it->first))->AstNode::dump(cerr);
 			cerr<<endl;
@@ -152,6 +173,10 @@ bool AstNode::brokeExists() const {
     // Called by node->broken() routines to do table lookup
     return BrokenTable::okIfLinkedTo(this);
 }
+bool AstNode::brokeExistsAbove() const {
+    // Called by node->broken() routines to do table lookup
+    return BrokenTable::okIfBelow(this);
+}
 
 //######################################################################
 
@@ -161,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() {}
@@ -179,23 +208,40 @@ public:
 
 class BrokenCheckVisitor : public AstNVisitor {
 private:
+    void checkWidthMin(AstNode* nodep) {
+	if (nodep->width() != nodep->widthMin()
+	    && v3Global.widthMinUsage()==VWidthMinUsage::MATCHES_WIDTH) {
+	    nodep->v3fatalSrc("Width != WidthMin");
+	}
+    }
+    void processAndIterate(AstNode* nodep) {
+	BrokenTable::setUnder(nodep,true);
+	if (const char* whyp=nodep->broken()) {
+	    nodep->v3fatalSrc("Broken link in node (or something without maybePointedTo): "<<whyp);
+	}
+	if (nodep->dtypep()) {
+	    if (!nodep->dtypep()->brokeExists()) { nodep->v3fatalSrc("Broken link in node->dtypep() to "<<(void*)nodep->dtypep()); }
+	    else if (!nodep->dtypep()->castNodeDType()) { nodep->v3fatalSrc("Non-dtype link in node->dtypep() to "<<(void*)nodep->dtypep()); }
+	}
+	if (v3Global.assertDTypesResolved()) {
+	    if (nodep->hasDType()) {
+		if (!nodep->dtypep()) nodep->v3fatalSrc("No dtype on node with hasDType(): "<<nodep->prettyTypeName());
+	    } else {
+		if (nodep->dtypep()) nodep->v3fatalSrc("DType on node without hasDType(): "<<nodep->prettyTypeName());
+	    }
+	    if (nodep->getChildDTypep()) nodep->v3fatalSrc("childDTypep() non-null on node after should have removed");
+	    if (AstNodeDType* dnodep = nodep->castNodeDType()) checkWidthMin(dnodep);
+	}
+	checkWidthMin(nodep);
+	nodep->iterateChildrenConst(*this);
+	BrokenTable::setUnder(nodep,false);
+    }
     virtual void visit(AstNode* nodep, AstNUser*) {
-	if (nodep->broken()) {
-	    nodep->v3fatalSrc("Broken link in node (or something without maybePointedTo)\n");
-	}
-	if (v3Global.assertWidthsSame()) {
-	    if (nodep->width() != nodep->widthMin()) {
-		nodep->v3fatalSrc("Width != WidthMin\n");
-	    }
-	    if (!nodep->width() && nodep->castNodeMath()) {
-		nodep->v3fatalSrc("Math node has no assigned width\n");
-	    }
-	}
-	nodep->iterateChildren(*this);
+	processAndIterate(nodep);
     }
 public:
     // CONSTUCTORS
-    BrokenCheckVisitor(AstNetlist* nodep) {
+    explicit BrokenCheckVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~BrokenCheckVisitor() {}
@@ -206,10 +252,18 @@ public:
 
 void V3Broken::brokenAll(AstNetlist* nodep) {
     //UINFO(9,__FUNCTION__<<": "<<endl);
-    BrokenTable::prepForTree();
-    BrokenMarkVisitor mvisitor (nodep);
-    BrokenCheckVisitor cvisitor (nodep);
-    BrokenTable::doneWithTree();
+    static bool inBroken = false;
+    if (inBroken) {
+	// A error called by broken can recurse back into broken; avoid this
+	UINFO(1,"Broken called under broken, skipping recursion.\n");
+    } else {
+	inBroken = true;
+	BrokenTable::prepForTree();
+	BrokenMarkVisitor mvisitor (nodep);
+	BrokenCheckVisitor cvisitor (nodep);
+	BrokenTable::doneWithTree();
+	inBroken = false;
+    }
 }
 
 void V3Broken::addNewed(AstNode* nodep) {

src/V3Broken.h

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Find broken links in tree
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break case statements up and add Unknown assigns
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -67,6 +66,9 @@ private:
     }
 
     virtual void visit(AstNodeCase* nodep, AstNUser*) {
+	if (nodep->castCase() && nodep->castCase()->casex()) {
+	    nodep->v3warn(CASEX,"Suggest casez (with ?'s) in place of casex (with X's)");
+	}
 	// Detect multiple defaults
 	bool hitDefault = false;
 	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
@@ -95,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)");
 		}
@@ -109,7 +112,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    CaseLintVisitor(AstNodeCase* nodep) {
+    explicit CaseLintVisitor(AstNodeCase* nodep) {
 	m_caseExprp = NULL;
 	nodep->accept(*this);
     }
@@ -133,7 +136,7 @@ private:
     // Per-CASE
     int		m_caseWidth;	// Width of valueItems
     int		m_caseItems;	// Number of caseItem unique values
-    int		m_caseNoOverlapsAllCovered;	// Proven to be synopsys parallel_case compliant
+    bool	m_caseNoOverlapsAllCovered;	// Proven to be synopsys parallel_case compliant
     AstNode*	m_valueItem[1<<CASE_OVERLAP_WIDTH];  // For each possible value, the case branch we need
 
     // METHODS
@@ -145,17 +148,19 @@ private:
 
     bool isCaseTreeFast(AstCase* nodep) {
 	int width = 0;
+	bool opaque = false;
 	m_caseItems = 0;
 	m_caseNoOverlapsAllCovered = true;
 	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 	    for (AstNode* icondp = itemp->condsp(); icondp!=NULL; icondp=icondp->nextp()) {
 		if (icondp->width() > width) width = icondp->width();
+		if (icondp->isDouble()) opaque = true;
 		if (!icondp->castConst()) width = CASE_BARF;  // Can't parse; not a constant
 		m_caseItems++;
 	    }
 	}
 	m_caseWidth = width;
-	if (width==0 || width > CASE_OVERLAP_WIDTH) {
+	if (width==0 || width > CASE_OVERLAP_WIDTH || opaque) {
 	    m_caseNoOverlapsAllCovered = false;
 	    return false;	// Too wide for analysis
 	}
@@ -192,7 +197,7 @@ private:
 		    }
 		}
 	    }
-	    // Defaults were moved to last in the caseitem list by V3Link
+	    // Defaults were moved to last in the caseitem list by V3LinkDot
 	    if (itemp->isDefault()) {  // Case statement's default... Fill the table
 		for (uint32_t i=0; i<(1UL<<m_caseWidth); i++) {
 		    if (!m_valueItem[i]) m_valueItem[i] = itemp;
@@ -241,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;
 	    }
 
@@ -290,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: ");
     }
 
@@ -308,7 +313,7 @@ private:
 	for (AstCaseItem* itemp = nodep->itemsp(); itemp; itemp=itemp->nextp()->castCaseItem()) {
 	    if (!itemp->condsp()) {
 		// Default clause.  Just make true, we'll optimize it away later
-		itemp->condsp(new AstConst(itemp->fileline(), V3Number(itemp->fileline(), 1,1)));
+		itemp->condsp(new AstConst(itemp->fileline(), AstConst::LogicTrue()));
 		hadDefault = true;
 	    } else {
 		// Expressioned clause
@@ -318,34 +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(), V3Number(itemp->fileline(),1,0));
-			and2p = new AstConst(itemp->fileline(), V3Number(itemp->fileline(),1,1));
+			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);
 		    }
-		    AstEq* condp = new AstEq(itemp->fileline(), and1p, and2p);
 		    if (!ifexprp) {
 			ifexprp = condp;
 		    } else {
@@ -356,12 +369,12 @@ 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.
 	    nodep->addItemsp(new AstCaseItem(nodep->fileline(),
-					     new AstConst(nodep->fileline(), V3Number(nodep->fileline(),1,1)),
+					     new AstConst(nodep->fileline(), AstConst::LogicTrue()),
 					     NULL));
 	}
 	if (debug()>=9) nodep->dumpTree(cout,"    _comp_COND: ");
@@ -395,10 +408,10 @@ 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 = new AstConst(itemp->fileline(), V3Number(itemp->fileline(),1,1));
+		    itemexprp->deleteTree(); VL_DANGLING(itemexprp);
+		    itemexprp = new AstConst(itemp->fileline(), AstConst::LogicTrue());
 		}
 		AstIf* newp = new AstIf(itemp->fileline(), itemexprp, istmtsp, NULL);
 		if (itemnextp) itemnextp->addElsesp(newp);
@@ -413,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) {
@@ -429,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;
@@ -445,11 +458,11 @@ private:
 	if (isCaseTreeFast(nodep) && v3Global.opt.oCase()) {
 	    // 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;
+	    ++m_statCaseFast;
+	    replaceCaseFast(nodep); VL_DANGLING(nodep);
 	} else {
-	    m_statCaseSlow++;
-	    replaceCaseComplicated(nodep); nodep=NULL;
+	    ++m_statCaseSlow;
+	    replaceCaseComplicated(nodep); VL_DANGLING(nodep);
 	}
     }
     //--------------------
@@ -460,7 +473,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CaseVisitor(AstNetlist* nodep) {
+    explicit CaseVisitor(AstNetlist* nodep) {
 	m_caseNoOverlapsAllCovered = false;
 	nodep->accept(*this);
     }
@@ -476,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break case statements up and add Unknown assigns
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Add C++ casts across expression size changes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2004-2009 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.
@@ -77,8 +76,7 @@ private:
 	AstNRelinker relinkHandle;
 	nodep->unlinkFrBack(&relinkHandle);
 	//
-	AstCast* castp = new AstCast (nodep->fileline(), nodep, needsize);
-	castp->width(needsize, nodep->widthMin());
+	AstCCast* castp = new AstCCast (nodep->fileline(), nodep, needsize, nodep->widthMin());
 	relinkHandle.relink(castp);
 	//if (debug()>8) castp->dumpTree(cout,"-castins: ");
 	//
@@ -97,13 +95,13 @@ private:
 	    insertCast(nodep, castSize(nodep->backp()));
 	}
     }
-    void insureLower32Cast(AstCast* nodep) {
+    void insureLower32Cast(AstCCast* nodep) {
 	// If we have uint64 = CAST(uint64(x)) then the upcasting
 	// really needs to be CAST(uint64(CAST(uint32(x))).
 	// Otherwise a (uint64)(a>b) would return wrong value, as
 	// less than has undeterministic signedness.
 	if (nodep->isQuad() && !nodep->lhsp()->isQuad()
-	    && !nodep->lhsp()->castCast()) {
+	    && !nodep->lhsp()->castCCast()) {
 	    insertCast(nodep->lhsp(), VL_WORDSIZE);
 	}
     }
@@ -130,12 +128,12 @@ private:
 	if (nodep->sizeMattersRhs()) insureCast(nodep->rhsp());
 	if (nodep->sizeMattersThs()) insureCast(nodep->thsp());
     }
-    virtual void visit(AstCast* nodep, AstNUser*) {
+    virtual void visit(AstCCast* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	insureLower32Cast(nodep);
 	nodep->user1(1);
     }
-    virtual void visit(AstUnaryMin* nodep, AstNUser*) {
+    virtual void visit(AstNegate* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	nodep->user1(nodep->lhsp()->user1());
 	if (nodep->lhsp()->widthMin()==1) {
@@ -149,8 +147,9 @@ private:
     }
     virtual void visit(AstVarRef* nodep, AstNUser*) {
 	if (!nodep->lvalue()
-	    && !nodep->backp()->castCast()
+	    && !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
@@ -177,7 +176,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CastVisitor(AstNetlist* nodep) {
+    explicit CastVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CastVisitor() {}
@@ -189,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Add C++ casts across expression size changes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2004-2009 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

@@ -0,0 +1,767 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Clock Domain Crossing Lint
+//
+// 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.
+//
+//*************************************************************************
+// V3Cdc's Transformations:
+//
+// Create V3Graph-ish graph
+// Find all negedge reset flops
+// Trace back to previous flop
+//
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <cstdio>
+#include <cstdarg>
+#include <unistd.h>
+#include <algorithm>
+#include <iomanip>
+#include <vector>
+#include <deque>
+#include <list>
+#include <memory>
+
+#include "V3Global.h"
+#include "V3Cdc.h"
+#include "V3Ast.h"
+#include "V3Graph.h"
+#include "V3Const.h"
+#include "V3EmitV.h"
+#include "V3File.h"
+
+#define CDC_WEIGHT_ASYNC	0x1000	// Weight for edges that feed async logic
+
+//######################################################################
+
+class CdcBaseVisitor : public AstNVisitor {
+public:
+    static int debug() {
+	static int level = -1;
+	if (VL_UNLIKELY(level < 0)) level = v3Global.opt.debugSrcLevel(__FILE__);
+	return level;
+    }
+};
+
+//######################################################################
+// Graph support classes
+
+class CdcEitherVertex : public V3GraphVertex {
+    AstScope*	m_scopep;
+    AstNode*	m_nodep;
+    AstSenTree*	m_srcDomainp;
+    AstSenTree*	m_dstDomainp;
+    bool	m_srcDomainSet:1;
+    bool	m_dstDomainSet:1;
+    bool	m_asyncPath:1;
+public:
+    CdcEitherVertex(V3Graph* graphp, AstScope* scopep, AstNode* nodep)
+	: V3GraphVertex(graphp), m_scopep(scopep), m_nodep(nodep)
+	, m_srcDomainp(NULL), m_dstDomainp(NULL)
+	, m_srcDomainSet(false), m_dstDomainSet(false)
+	, m_asyncPath(false) {}
+    virtual ~CdcEitherVertex() {}
+    // Accessors
+    AstScope* scopep() const { return m_scopep; }
+    AstNode* nodep() const { return m_nodep; }
+    AstSenTree* srcDomainp() const { return m_srcDomainp; }
+    void srcDomainp(AstSenTree* nodep) { m_srcDomainp = nodep; }
+    bool srcDomainSet() const { return m_srcDomainSet; }
+    void srcDomainSet(bool flag) { m_srcDomainSet = flag; }
+    AstSenTree* dstDomainp() const { return m_dstDomainp; }
+    void dstDomainp(AstSenTree* nodep) { m_dstDomainp = nodep; }
+    bool dstDomainSet() const { return m_dstDomainSet; }
+    void dstDomainSet(bool flag) { m_dstDomainSet = flag; }
+    bool asyncPath() const { return m_asyncPath; }
+    void asyncPath(bool flag) { m_asyncPath = flag; }
+};
+
+class CdcVarVertex : public CdcEitherVertex {
+    AstVarScope* m_varScp;
+    int		m_cntAsyncRst;
+    bool	m_fromFlop;
+public:
+    CdcVarVertex(V3Graph* graphp, AstScope* scopep, AstVarScope* varScp)
+	: CdcEitherVertex(graphp, scopep, varScp), m_varScp(varScp), m_cntAsyncRst(0), m_fromFlop(false) {}
+    virtual ~CdcVarVertex() {}
+    // Accessors
+    AstVarScope* varScp() const { return m_varScp; }
+    virtual string name() const { return (cvtToStr((void*)m_varScp)+" "+varScp()->name()); }
+    virtual string dotColor() const { return fromFlop() ? "green" : cntAsyncRst() ? "red" : "blue"; }
+    int cntAsyncRst() const { return m_cntAsyncRst; }
+    void cntAsyncRst(int flag) { m_cntAsyncRst=flag; }
+    bool fromFlop() const { return m_fromFlop; }
+    void fromFlop(bool flag) { m_fromFlop = flag; }
+};
+
+class CdcLogicVertex : public CdcEitherVertex {
+    bool	m_hazard:1;
+    bool	m_isFlop:1;
+public:
+    CdcLogicVertex(V3Graph* graphp, AstScope* scopep, AstNode* nodep, AstSenTree* sensenodep)
+	: CdcEitherVertex(graphp,scopep,nodep)
+	, m_hazard(false), m_isFlop(false)
+	{ srcDomainp(sensenodep); dstDomainp(sensenodep); }
+    virtual ~CdcLogicVertex() {}
+    // Accessors
+    virtual string name() const { return (cvtToStr((void*)nodep())+"@"+scopep()->prettyName()); }
+    virtual string dotColor() const { return hazard() ? "black" : "yellow"; }
+    bool hazard() const { return m_hazard; }
+    void setHazard(AstNode* nodep) { m_hazard = true; nodep->user3(true); }
+    void clearHazard() { m_hazard = false; }
+    bool isFlop() const { return m_isFlop; }
+    void isFlop(bool flag) { m_isFlop = flag; }
+};
+
+//######################################################################
+
+class CdcDumpVisitor : public CdcBaseVisitor {
+private:
+    // NODE STATE
+    //Entire netlist:
+    // {statement}Node::user3	-> bool, indicating not hazard
+    ofstream*		m_ofp;		// Output file
+    string		m_prefix;
+
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	*m_ofp<<m_prefix;
+	if (nodep->user3()) *m_ofp<<" %%";
+	else *m_ofp<<"  ";
+	*m_ofp<<nodep->prettyTypeName()<<" "<<endl;
+	string lastPrefix = m_prefix;
+	m_prefix = lastPrefix + "1:";
+	nodep->op1p()->iterateAndNext(*this);
+	m_prefix = lastPrefix + "2:";
+	nodep->op2p()->iterateAndNext(*this);
+	m_prefix = lastPrefix + "3:";
+	nodep->op3p()->iterateAndNext(*this);
+	m_prefix = lastPrefix + "4:";
+	nodep->op4p()->iterateAndNext(*this);
+	m_prefix = lastPrefix;
+    }
+
+public:
+    // CONSTUCTORS
+    CdcDumpVisitor(AstNode* nodep, ofstream* ofp, const string& prefix) {
+	m_ofp = ofp;
+	m_prefix = prefix;
+	nodep->accept(*this);
+    }
+    virtual ~CdcDumpVisitor() {}
+};
+
+//######################################################################
+
+class CdcWidthVisitor : public CdcBaseVisitor {
+private:
+    int		m_maxLineno;
+    size_t	m_maxFilenameLen;
+
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+	// Keeping line+filename lengths separate is much faster than calling ascii().length()
+	if (nodep->fileline()->lineno() >= m_maxLineno) {
+	    m_maxLineno = nodep->fileline()->lineno()+1;
+	}
+	if (nodep->fileline()->filename().length() >= m_maxFilenameLen) {
+	    m_maxFilenameLen = nodep->fileline()->filename().length()+1;
+	}
+    }
+public:
+    // CONSTUCTORS
+    explicit CdcWidthVisitor(AstNode* nodep) {
+	m_maxLineno = 0;
+	m_maxFilenameLen = 0;
+	nodep->accept(*this);
+    }
+    virtual ~CdcWidthVisitor() {}
+    // ACCESSORS
+    int maxWidth() {
+	size_t width=1;
+	width += m_maxFilenameLen;
+	width += 1;  // The :
+	width += cvtToStr(m_maxLineno).length();
+	width += 1;  // Final :
+	return (int)width;
+    }
+};
+
+//######################################################################
+// Cdc class functions
+
+class CdcVisitor : public CdcBaseVisitor {
+private:
+    // NODE STATE
+    //Entire netlist:
+    // AstVarScope::user1p	-> CdcVarVertex* for usage var, 0=not set yet
+    // AstVarScope::user2	-> bool  Used in sensitivity list
+    // {statement}Node::user1p	-> CdcLogicVertex* for this statement
+    // AstNode::user3		-> bool  True indicates to print %% (via V3EmitV)
+    AstUser1InUse	m_inuser1;
+    AstUser2InUse	m_inuser2;
+    AstUser3InUse	m_inuser3;
+
+    // STATE
+    V3Graph		m_graph;	// Scoreboard of var usages/dependencies
+    CdcLogicVertex*	m_logicVertexp;	// Current statement being tracked, NULL=ignored
+    AstScope*		m_scopep;	// Current scope being processed
+    AstNodeModule*	m_modp;		// Current module
+    AstSenTree*		m_domainp;	// Current sentree
+    bool		m_inDly;	// In delayed assign
+    int			m_inSenItem;	// Number of senitems
+    string		m_ofFilename;	// Output filename
+    ofstream*		m_ofp;		// Output file
+    uint32_t		m_userGeneration; // Generation count to avoid slow userClearVertices
+    int			m_filelineWidth;  // Characters in longest fileline
+
+    // METHODS
+    void iterateNewStmt(AstNode* nodep) {
+	if (m_scopep) {
+	    UINFO(4,"   STMT "<<nodep<<endl);
+	    m_logicVertexp = new CdcLogicVertex(&m_graph, m_scopep, nodep, m_domainp);
+	    if (m_domainp && m_domainp->hasClocked()) {  // To/from a flop
+		m_logicVertexp->isFlop(true);
+		m_logicVertexp->srcDomainp(m_domainp);
+		m_logicVertexp->srcDomainSet(true);
+		m_logicVertexp->dstDomainp(m_domainp);
+		m_logicVertexp->dstDomainSet(true);
+	    }
+	    nodep->iterateChildren(*this);
+	    m_logicVertexp = NULL;
+
+	    if (0 && debug()>=9) {
+		UINFO(9, "Trace Logic:\n");
+		nodep->dumpTree(cout, "-log1: ");
+	    }
+	}
+    }
+
+    CdcVarVertex* makeVarVertex(AstVarScope* varscp) {
+	CdcVarVertex* vertexp = (CdcVarVertex*)(varscp->user1p());
+	if (!vertexp) {
+	    UINFO(6,"New vertex "<<varscp<<endl);
+	    vertexp = new CdcVarVertex(&m_graph, m_scopep, varscp);
+	    varscp->user1p(vertexp);
+	    if (varscp->varp()->isUsedClock()) {}
+	    if (varscp->varp()->isPrimaryIO()) {
+		// Create IO vertex - note it's relative to the pointed to var, not where we are now
+		// This allows reporting to easily print the input statement
+		CdcLogicVertex* ioVertexp = new CdcLogicVertex(&m_graph, varscp->scopep(), varscp->varp(), NULL);
+		if (varscp->varp()->isInput()) {
+		    new V3GraphEdge(&m_graph, ioVertexp, vertexp, 1);
+		} else {
+		    new V3GraphEdge(&m_graph, vertexp, ioVertexp, 1);
+		}
+	    }
+	}
+	if (m_inSenItem) {
+	    varscp->user2(true);  // It's like a clock...
+	    // TODO: In the future we could mark it here and do normal clock tree glitch checks also
+	} else if (varscp->user2()) {  // It was detected in a sensitivity list earlier
+	    // And now it's used as logic.  So must be a reset.
+	    vertexp->cntAsyncRst(vertexp->cntAsyncRst()+1);
+	}
+	return vertexp;
+    }
+
+    void warnAndFile(AstNode* nodep, V3ErrorCode code, const string& msg) {
+	static bool told_file = false;
+	nodep->v3warnCode(code,msg);
+	if (!told_file) {
+	    told_file = 1;
+	    cerr<<V3Error::msgPrefix()<<"     See details in "<<m_ofFilename<<endl;
+	}
+	*m_ofp<<"%Warning-"<<code.ascii()<<": "<<nodep->fileline()<<" "<<msg<<endl;
+    }
+
+    void setNodeHazard(AstNode* nodep) {
+	// Need to not clear if warnings are off (rather than when report it)
+	// as bypassing this warning may turn up another path that isn't warning off'ed.
+	// We can't modifyWarnOff here, as one instantiation might not be an issue until we find a hitting flop
+	// Furthermore, a module like a "Or" module would only get flagged once,
+	// even though the signals feeding it are radically different.
+	if (!m_domainp || m_domainp->hasCombo()) { // Source flop logic in a posedge block is OK for reset (not async though)
+	    if (m_logicVertexp && !nodep->fileline()->warnIsOff(V3ErrorCode::CDCRSTLOGIC)) {
+		UINFO(8,"Set hazard "<<nodep<<endl);
+		m_logicVertexp->setHazard(nodep);
+	    }
+	}
+    }
+
+    string spaces(int level) { string out; while (level--) out+=" "; return out; }
+
+    string pad(unsigned column, const string& in) {
+	string out = in;
+	while (out.length()<column) out += ' ';
+	return out;
+    }
+
+    void analyze() {
+	UINFO(3,__FUNCTION__<<": "<<endl);
+	//if (debug()>6) m_graph.dump();
+	if (debug()>6) m_graph.dumpDotFilePrefixed("cdc_pre");
+	//
+	m_graph.removeRedundantEdges(&V3GraphEdge::followAlwaysTrue);  // This will MAX across edge weights
+	//
+	m_graph.dumpDotFilePrefixed("cdc_simp");
+	//
+	analyzeReset();
+    }
+
+    int filelineWidth() {
+	if (!m_filelineWidth) {
+	    CdcWidthVisitor visitor (v3Global.rootp());
+	    m_filelineWidth = visitor.maxWidth();
+	}
+	return m_filelineWidth;
+    }
+
+    //----------------------------------------
+    // RESET REPORT
+
+    void analyzeReset() {
+	// Find all async reset wires, and trace backwards
+	// userClearVertices is very slow, so we use a generation count instead
+	m_graph.userClearVertices();  // user1: uint32_t - was analyzed generation
+	for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
+	    if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(itp)) {
+		if (vvertexp->cntAsyncRst()) {
+		    m_userGeneration++;  // Effectively a userClearVertices()
+		    UINFO(8, "   Trace One async: "<<vvertexp<<endl);
+		    // Twice, as we need to detect, then propagate
+		    CdcEitherVertex* markp = traceAsyncRecurse(vvertexp, false);
+		    if (markp) { // Mark is non-NULL if something bad on this path
+			UINFO(9, "   Trace One bad! "<<vvertexp<<endl);
+			m_userGeneration++;  // Effectively a userClearVertices()
+			traceAsyncRecurse(vvertexp, true);
+			m_userGeneration++;  // Effectively a userClearVertices()
+			dumpAsync(vvertexp, markp);
+		    }
+		}
+	    }
+	}
+    }
+
+    CdcEitherVertex* traceAsyncRecurse(CdcEitherVertex* vertexp, bool mark) {
+	// First pass: Return vertex of any hazardous stuff attached, or NULL if OK
+	// If first pass returns true, second pass calls asyncPath() on appropriate nodes
+	if (vertexp->user()>=m_userGeneration) return NULL;   // Processed - prevent loop
+	vertexp->user(m_userGeneration);
+
+	CdcEitherVertex* mark_outp = NULL;
+	UINFO(9,"      Trace: "<<vertexp<<endl);
+
+	// Clear out in prep for marking next path
+	if (!mark) vertexp->asyncPath(false);
+
+	if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(vertexp)) {
+	    // Any logic considered bad, at the moment, anyhow
+	    if (vvertexp->hazard() && !mark_outp) mark_outp = vvertexp;
+	    // And keep tracing back so the user can understand what's up
+	}
+	else if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(vertexp)) {
+	    if (mark) vvertexp->asyncPath(true);
+	    // If primary I/O, it's ok here back
+	    if (vvertexp->varScp()->varp()->isPrimaryIn()) {
+		// Show the source "input" statement if it exists
+		for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+		    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+		    eFromVertexp->asyncPath(true);
+		}
+		return NULL;
+	    }
+	    // Also ok if from flop, but partially trace the flop so more obvious to users
+	    if (vvertexp->fromFlop()) {
+		for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+		    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+		    eFromVertexp->asyncPath(true);
+		}
+		return NULL;
+	    }
+	}
+
+	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+	    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+	    CdcEitherVertex* submarkp = traceAsyncRecurse(eFromVertexp, mark);
+	    if (submarkp && !mark_outp) mark_outp = submarkp;
+	}
+
+	if (mark) vertexp->asyncPath(true);
+	return mark_outp;
+    }
+
+    void dumpAsync(CdcVarVertex* vertexp, CdcEitherVertex* markp) {
+	AstNode* nodep = vertexp->varScp();
+	*m_ofp<<"\n";
+	*m_ofp<<"\n";
+	CdcEitherVertex* targetp = vertexp;  // One example destination flop (of possibly many)
+	for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
+	    CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
+	    if (!eToVertexp) targetp = eToVertexp;
+	    if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(eToVertexp)) {
+		if (vvertexp->isFlop()  // IE the target flop that is upsetting us
+		    && edgep->weight() >= CDC_WEIGHT_ASYNC) {  // And this signal feeds an async reset line
+		    targetp = eToVertexp;
+		    //UINFO(9," targetasync  "<<targetp->name()<<" "<<" from "<<vertexp->name()<<endl);
+		    break;
+		}
+	    }  // else it might be random logic that's not relevant
+	}
+	//UINFO(9," finalflop  "<<targetp->name()<<" "<<targetp->nodep()->fileline()<<endl);
+	warnAndFile(markp->nodep(),V3ErrorCode::CDCRSTLOGIC,"Logic in path that feeds async reset, via signal: "+nodep->prettyName());
+	dumpAsyncRecurse(targetp, "", "   ",0);
+    }
+    bool dumpAsyncRecurse(CdcEitherVertex* vertexp, const string& prefix, const string& sep, int level) {
+	// level=0 is special, indicates to dump destination flop
+	// Return true if printed anything
+	// If mark, also mark the output even if nothing hazardous below
+	if (vertexp->user()>=m_userGeneration) return false;   // Processed - prevent loop
+	vertexp->user(m_userGeneration);
+	if (!vertexp->asyncPath() && level!=0) return false;  // Not part of path
+
+	// Other logic in the path
+	string cont = prefix+sep;
+	string nextsep = "   ";
+	for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+	    CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+	    if (dumpAsyncRecurse(eFromVertexp, cont, nextsep, level+1)) {
+		nextsep = " | ";
+	    }
+	}
+
+	// Dump single variable/logic block
+	// See also OrderGraph::loopsVertexCb(V3GraphVertex* vertexp)
+	AstNode* nodep = vertexp->nodep();
+	string front = pad(filelineWidth(),nodep->fileline()->ascii()+":")+" "+prefix+" +- ";
+	if (nodep->castVarScope()) {
+	    *m_ofp<<front<<"Variable: "<<nodep->prettyName()<<endl;
+	}
+	else {
+	    V3EmitV::verilogPrefixedTree(nodep, *m_ofp, prefix+" +- ", filelineWidth(),
+					 vertexp->srcDomainp(), true);
+	    if (debug()) {
+		CdcDumpVisitor visitor (nodep, m_ofp, front+"DBG: ");
+	    }
+	}
+
+	nextsep = " | ";
+	if (level) *m_ofp<<V3OutFile::indentSpaces(filelineWidth())<<" "<<prefix<<nextsep<<"\n";
+
+	if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(vertexp)) {
+	    // Now that we've printed a path with this hazard, don't bother to print any more
+	    // Otherwise, we'd get a path for almost every destination flop
+	    vvertexp->clearHazard();
+	}
+	return true;
+    }
+
+    //----------------------------------------
+    // EDGE REPORTS
+
+    void edgeReport() {
+	// Make report of all signal names and what clock edges they have
+	//
+	// Due to flattening, many interesting direct-connect signals are
+	// lost, so we can't make a report showing I/Os for a low level
+	// module.  Disabling flattening though makes us consider each
+	// signal in it's own unique clock domain.
+
+	UINFO(3,__FUNCTION__<<": "<<endl);
+
+	// Trace all sources and sinks
+	for (int traceDests=0; traceDests<2; ++traceDests) {
+	    UINFO(9, " Trace Direction "<<(traceDests?"dst":"src")<<endl);
+	    m_graph.userClearVertices();  // user1: bool - was analyzed
+	    for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
+		if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(itp)) {
+		    UINFO(9, "   Trace One edge: "<<vvertexp<<endl);
+		    edgeDomainRecurse(vvertexp, traceDests, 0);
+		}
+	    }
+	}
+
+	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc_edges.txt";
+	const VL_UNIQUE_PTR<ofstream> ofp (V3File::new_ofstream(filename));
+	if (ofp->fail()) v3fatalSrc("Can't write "<<filename);
+	*ofp<<"Edge Report for "<<v3Global.opt.prefix()<<endl;
+
+	deque<string> report;  // Sort output by name
+	for (V3GraphVertex* itp = m_graph.verticesBeginp(); itp; itp=itp->verticesNextp()) {
+	    if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(itp)) {
+		AstVar* varp = vvertexp->varScp()->varp();
+		if (1) {  // varp->isPrimaryIO()
+		    const char* whatp = "wire";
+		    if (varp->isPrimaryIO()) whatp = (varp->isInout()?"inout":varp->isInput()?"input":"output");
+
+		    ostringstream os;
+		    os.setf(ios::left);
+		    // Module name - doesn't work due to flattening having lost the original
+		    // so we assume the modulename matches the filebasename
+		    string fname = vvertexp->varScp()->fileline()->filebasename() + ":";
+		    os<<"  "<<setw(20)<<fname;
+		    os<<"  "<<setw(8)<<whatp;
+		    os<<"  "<<setw(40)<<vvertexp->varScp()->prettyName();
+		    os<<"  SRC=";
+		    if (vvertexp->srcDomainp()) V3EmitV::verilogForTree(vvertexp->srcDomainp(), os);
+		    os<<"  DST=";
+		    if (vvertexp->dstDomainp()) V3EmitV::verilogForTree(vvertexp->dstDomainp(), os);
+		    os<<setw(0);
+		    os<<endl;
+		    report.push_back(os.str());
+		}
+	    }
+	}
+	stable_sort(report.begin(), report.end());
+	for (deque<string>::iterator it = report.begin(); it!=report.end(); ++it) {
+	    *ofp << *it;
+	}
+    }
+
+    void edgeDomainRecurse(CdcEitherVertex* vertexp, bool traceDests, int level) {
+	// Scan back to inputs/outputs, flops, and compute clock domain information
+	UINFO(8,spaces(level)<<"     Tracein  "<<vertexp<<endl);
+	if (vertexp->user()>=m_userGeneration) return;   // Mid-Processed - prevent loop
+	vertexp->user(m_userGeneration);
+
+	// Variables from flops already are domained
+	if (traceDests ? vertexp->dstDomainSet() : vertexp->srcDomainSet()) return;  // Fully computed
+
+	typedef set<AstSenTree*> SenSet;
+	SenSet 	    senouts;   // List of all sensitivities for new signal
+	if (CdcLogicVertex* vvertexp = dynamic_cast<CdcLogicVertex*>(vertexp)) {
+	    if (vvertexp) {}  // Unused
+	}
+	else if (CdcVarVertex* vvertexp = dynamic_cast<CdcVarVertex*>(vertexp)) {
+	    // If primary I/O, give it domain of the input
+	    AstVar* varp = vvertexp->varScp()->varp();
+	    if (varp->isPrimaryIO() && varp->isInput() && !traceDests) {
+		senouts.insert(new AstSenTree(varp->fileline(), new AstSenItem(varp->fileline(), AstSenItem::Combo())));
+	    }
+	}
+
+	// Now combine domains of sources/dests
+	if (traceDests) {
+	    for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
+		CdcEitherVertex* eToVertexp = (CdcEitherVertex*)edgep->top();
+		edgeDomainRecurse(eToVertexp, traceDests, level+1);
+		if (eToVertexp->dstDomainp()) senouts.insert(eToVertexp->dstDomainp());
+	    }
+	} else {
+	    for (V3GraphEdge* edgep = vertexp->inBeginp(); edgep; edgep = edgep->inNextp()) {
+		CdcEitherVertex* eFromVertexp = (CdcEitherVertex*)edgep->fromp();
+		edgeDomainRecurse(eFromVertexp, traceDests, level+1);
+		if (eFromVertexp->srcDomainp()) senouts.insert(eFromVertexp->srcDomainp());
+	    }
+	}
+
+	// Convert list of senses into one sense node
+	AstSenTree* senoutp = NULL;
+	bool	    senedited = false;
+	for (SenSet::iterator it=senouts.begin(); it!=senouts.end(); ++it) {
+	    if (!senoutp) senoutp = *it;
+	    else {
+		if (!senedited) {
+		    senedited = true;
+		    senoutp = senoutp->cloneTree(true);
+		}
+		senoutp->addSensesp((*it)->sensesp()->cloneTree(true));
+	    }
+	}
+	// If multiple domains need to do complicated optimizations
+	if (senedited) {
+	    senoutp = V3Const::constifyExpensiveEdit(senoutp)->castSenTree();
+	}
+	if (traceDests) {
+	    vertexp->dstDomainSet(true);  // Note it's set - domainp may be null, so can't use that
+	    vertexp->dstDomainp(senoutp);
+	    if (debug()>=9) {
+		UINFO(9,spaces(level)+"     Tracedst "<<vertexp);
+		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+	    }
+	} else {
+	    vertexp->srcDomainSet(true);  // Note it's set - domainp may be null, so can't use that
+	    vertexp->srcDomainp(senoutp);
+	    if (debug()>=9) {
+		UINFO(9,spaces(level)+"     Tracesrc "<<vertexp);
+		if (senoutp) V3EmitV::verilogForTree(senoutp, cout); cout<<endl;
+	    }
+	}
+    }
+
+    // VISITORS
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
+	m_modp = nodep;
+	nodep->iterateChildren(*this);
+	m_modp = NULL;
+    }
+    virtual void visit(AstScope* nodep, AstNUser*) {
+	UINFO(4," SCOPE "<<nodep<<endl);
+	m_scopep = nodep;
+	m_logicVertexp = NULL;
+	nodep->iterateChildren(*this);
+	m_scopep = NULL;
+    }
+    virtual void visit(AstActive* nodep, AstNUser*) {
+	// Create required blocks and add to module
+	UINFO(4,"  BLOCK  "<<nodep<<endl);
+	AstNode::user2ClearTree();
+	m_domainp = nodep->sensesp();
+	if (!m_domainp || m_domainp->hasCombo() || m_domainp->hasClocked()) {  // IE not hasSettle/hasInitial
+	    iterateNewStmt(nodep);
+	}
+	m_domainp = NULL;
+	AstNode::user2ClearTree();
+    }
+    virtual void visit(AstNodeVarRef* nodep, AstNUser*) {
+	if (m_scopep) {
+	    if (!m_logicVertexp) nodep->v3fatalSrc("Var ref not under a logic block\n");
+	    AstVarScope* varscp = nodep->varScopep();
+	    if (!varscp) nodep->v3fatalSrc("Var didn't get varscoped in V3Scope.cpp\n");
+	    CdcVarVertex* varvertexp = makeVarVertex(varscp);
+	    UINFO(5," VARREF to "<<varscp<<endl);
+	    // We use weight of one for normal edges,
+	    // Weight of CDC_WEIGHT_ASYNC to indicate feeds async (for reporting)
+	    // When simplify we'll take the MAX weight
+	    if (nodep->lvalue()) {
+		new V3GraphEdge(&m_graph, m_logicVertexp, varvertexp, 1);
+		if (m_inDly) {
+		    varvertexp->fromFlop(true);
+		    varvertexp->srcDomainp(m_domainp);
+		    varvertexp->srcDomainSet(true);
+		}
+	    } else {
+		if (varvertexp->cntAsyncRst()) {
+		    //UINFO(9," edgeasync "<<varvertexp->name()<<" to "<<m_logicVertexp<<endl);
+		    new V3GraphEdge(&m_graph, varvertexp, m_logicVertexp, CDC_WEIGHT_ASYNC);
+		} else {
+		    //UINFO(9," edgena    "<<varvertexp->name()<<" to "<<m_logicVertexp<<endl);
+		    new V3GraphEdge(&m_graph, varvertexp, m_logicVertexp, 1);
+		}
+	    }
+	}
+    }
+    virtual void visit(AstAssignDly* nodep, AstNUser*) {
+	m_inDly = true;
+	nodep->iterateChildren(*this);
+	m_inDly = false;
+    }
+    virtual void visit(AstSenItem* nodep, AstNUser*) {
+	// Note we look at only AstSenItems, not AstSenGate's
+	// The gating term of a AstSenGate is normal logic
+	m_inSenItem = true;
+	nodep->iterateChildren(*this);
+	m_inSenItem = false;
+    }
+    virtual void visit(AstAlways* nodep, AstNUser*) {
+	iterateNewStmt(nodep);
+    }
+    virtual void visit(AstAlwaysPublic* nodep, AstNUser*) {
+	// CDC doesn't care about public variables
+    }
+    virtual void visit(AstCFunc* nodep, AstNUser*) {
+	iterateNewStmt(nodep);
+    }
+    virtual void visit(AstSenGate* nodep, AstNUser*) {
+	// First handle the clock part will be handled in a minute by visit AstSenItem
+	// The logic gating term is delt with as logic
+	iterateNewStmt(nodep);
+    }
+    virtual void visit(AstAssignAlias* nodep, AstNUser*) {
+	iterateNewStmt(nodep);
+    }
+    virtual void visit(AstAssignW* nodep, AstNUser*) {
+	iterateNewStmt(nodep);
+    }
+
+    // Math that shouldn't cause us to clear hazard
+    virtual void visit(AstConst* nodep, AstNUser*) { }
+    virtual void visit(AstReplicate* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstConcat* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstNot* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstSel* nodep, AstNUser*) {
+	if (!nodep->lsbp()->castConst()) setNodeHazard(nodep);
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstNodeSel* nodep, AstNUser*) {
+	if (!nodep->bitp()->castConst()) setNodeHazard(nodep);
+	nodep->iterateChildren(*this);
+    }
+
+    // Ignores
+    virtual void visit(AstInitial* nodep, AstNUser*) { }
+    virtual void visit(AstTraceInc* nodep, AstNUser*) { }
+    virtual void visit(AstCoverToggle* nodep, AstNUser*) { }
+    virtual void visit(AstNodeDType* nodep, AstNUser*) { }
+
+    //--------------------
+    // Default
+    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+	setNodeHazard(nodep);
+	nodep->iterateChildren(*this);
+    }
+    virtual void visit(AstNode* nodep, AstNUser*) {
+	nodep->iterateChildren(*this);
+    }
+
+public:
+    // CONSTUCTORS
+    explicit CdcVisitor(AstNode* nodep) {
+	m_logicVertexp = NULL;
+	m_scopep = NULL;
+	m_modp = NULL;
+	m_domainp = NULL;
+	m_inDly = false;
+	m_inSenItem = 0;
+	m_userGeneration = 0;
+	m_filelineWidth = 0;
+
+	// Make report of all signal names and what clock edges they have
+	string filename = v3Global.opt.makeDir()+"/"+v3Global.opt.prefix()+"__cdc.txt";
+	m_ofp = V3File::new_ofstream(filename);
+	if (m_ofp->fail()) v3fatalSrc("Can't write "<<filename);
+	m_ofFilename = filename;
+	*m_ofp<<"CDC Report for "<<v3Global.opt.prefix()<<endl;
+	*m_ofp<<"Each dump below traces logic from inputs/source flops to destination flop(s).\n";
+	*m_ofp<<"First source logic is listed, then a variable that logic generates,\n";
+	*m_ofp<<"repeating recursively forwards to the destination flop(s).\n";
+	*m_ofp<<"%% Indicates the operator considered potentially hazardous.\n";
+
+	nodep->accept(*this);
+	analyze();
+	if (debug()>=1) edgeReport();  // Not useful to users at the moment
+
+	if (0) { *m_ofp<<"\nDBG-test-dumper\n"; V3EmitV::verilogPrefixedTree(nodep, *m_ofp, "DBG ",40,NULL,true); *m_ofp<<endl; }
+    }
+    virtual ~CdcVisitor() {
+	if (m_ofp) { delete m_ofp; m_ofp = NULL; }
+    }
+};
+
+//######################################################################
+// Cdc class functions
+
+void V3Cdc::cdcAll(AstNetlist* nodep) {
+    UINFO(2,__FUNCTION__<<": "<<endl);
+    CdcVisitor visitor (nodep);
+}

src/V3Cdc.h

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
-// DESCRIPTION: Verilator: Signed/unsigned resolution
+// DESCRIPTION: Verilator: Break always into sensitivity block domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2005-2009 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.
@@ -20,8 +18,8 @@
 //
 //*************************************************************************
 
-#ifndef _V3SIGNED_H_
-#define _V3SIGNED_H_ 1
+#ifndef _V3CDC_H_
+#define _V3CDC_H_ 1
 #include "config_build.h"
 #include "verilatedos.h"
 #include "V3Error.h"
@@ -29,12 +27,9 @@
 
 //============================================================================
 
-class V3Signed {
+class V3Cdc {
 public:
-    static void signedAll(AstNetlist* nodep);
-protected:
-    friend class V3Width;  // Use widthParamsEdit instead of signedParamsEdit
-    static AstNode* signedParamsEdit(AstNode* nodep); // May replace nodep
+    static void cdcAll(AstNetlist* nodep);
 };
 
 #endif // Guard

src/V3Changed.cpp

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for changed nodes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -44,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
 
@@ -55,9 +178,7 @@ private:
     AstUser1InUse	m_inuser1;
 
     // STATE
-    AstModule*		m_topModp;	// Top module
-    AstScope*		m_scopetopp;	// Scope under TOPSCOPE
-    AstCFunc*		m_chgFuncp;	// Change function we're building
+    ChangedState*	m_statep;	// Shared state across visitors
 
     // METHODS
     static int debug() {
@@ -67,42 +188,15 @@ private:
     }
 
     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);
-	if (varp->arraysp()) {
-	    vscp->v3error("Unsupported: Can't detect changes on arrayed 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);
-	    AstChangeDet* changep
-		= new AstChangeDet (vscp->fileline(),
-				    new AstVarRef(vscp->fileline(), vscp, false),
-				    new AstVarRef(vscp->fileline(), newvscp, false),
-				    false);
-	    m_chgFuncp->addStmtsp(changep);
-	    AstAssign* initp
-		= new AstAssign (vscp->fileline(),
-				 new AstVarRef(vscp->fileline(), newvscp, true),
-				 new AstVarRef(vscp->fileline(), vscp, false));
-	    m_chgFuncp->addFinalsp(initp);
-	}
+	ChangedInsertVisitor visitor (vscp, m_statep);
     }
 
     // VISITORS
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    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);
     }
@@ -113,27 +207,29 @@ 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, "bool");
-	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);
     }
     virtual void visit(AstVarScope* nodep, AstNUser*) {
 	if (nodep->isCircular()) {
 	    UINFO(8,"  CIRC "<<nodep<<endl);
-	    if (!nodep->user1()) {
-		nodep->user1(true);
+	    if (!nodep->user1SetOnce()) {
 		genChangeDet(nodep);
 	    }
 	}
     }
+    virtual void visit(AstNodeMath* nodep, AstNUser*) {
+	// Short-circuit 
+    }
     //--------------------
     // Default: Just iterate
     virtual void visit(AstNode* nodep, AstNUser*) {
@@ -142,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() {}
@@ -156,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Pre C-Emit stage changes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Add temporaries, such as for clean nodes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -24,7 +23,7 @@
 //	For each math operator, if it requires a clean operand,
 //	and the operand is dirty, insert a CLEAN node.
 //	Resize operands to C++ 32/64/wide types.
-//	Copy all width() values to minWidth() so RANGE, etc can still see orig widths
+//	Copy all width() values to widthMin() so RANGE, etc can still see orig widths
 //
 //*************************************************************************
 
@@ -47,15 +46,17 @@ private:
     // NODE STATE
     // Entire netlist:
     //  AstNode::user()		-> CleanState.  For this node, 0==UNKNOWN
-    //  AstNode::user2()	-> bool.  True indicates minWidth has been propagated
+    //  AstNode::user2()	-> bool.  True indicates widthMin has been propagated
+    //  AstNodeDType::user3()	-> AstNodeDType*.  Alternative node with C size
     AstUser1InUse	m_inuser1;
     AstUser2InUse	m_inuser2;
+    AstUser3InUse	m_inuser3;
 
     // TYPES
-    enum CleanState { UNKNOWN, CLEAN, DIRTY };
+    enum CleanState { CS_UNKNOWN, CS_CLEAN, CS_DIRTY };
 
     // STATE
-    AstModule* m_modp;
+    AstNodeModule* m_modp;
 
     // METHODS
     static int debug() {
@@ -70,16 +71,28 @@ private:
 	else if (nodep->width()<=VL_QUADSIZE) return VL_QUADSIZE;
 	else return nodep->widthWords()*VL_WORDSIZE;
     }
-    void setCppWidth (AstNode* nodep, int width, int widthMin) {
+    void setCppWidth (AstNode* nodep) {
 	nodep->user2(true);  // Don't resize it again
-	nodep->width(width, widthMin);
+	AstNodeDType* old_dtypep = nodep->dtypep();
+	int width=cppWidth(nodep);  // widthMin is unchanged
+	if (old_dtypep->width() != width) {
+	    // Since any given dtype's cppWidth() is the same, we can just
+	    // remember one convertion for each, and reuse it
+	    if (AstNodeDType* new_dtypep = old_dtypep->user3p()->castNode()->castNodeDType()) {
+		nodep->dtypep(new_dtypep);
+	    } else {
+		nodep->dtypeChgWidth(width, nodep->widthMin());
+		AstNodeDType* new_dtypep2 = nodep->dtypep();
+		if (new_dtypep2 == old_dtypep) nodep->v3fatalSrc("Dtype didn't change when width changed");
+		old_dtypep->user3p(new_dtypep2);  // Remember for next time
+	    }
+	}
     }
     void computeCppWidth (AstNode* nodep) {
-	if (!nodep->user2()) {
-	    if (nodep->castVar()) {  // Don't want to change variable widths!
-		setCppWidth(nodep, nodep->width(), nodep->width());  // set widthMin anyways so can see it later
+	if (!nodep->user2() && nodep->hasDType()) {
+	    if (nodep->castVar() || nodep->castNodeDType()) {  // Don't want to change variable widths!
 	    } else {
-		setCppWidth(nodep, cppWidth(nodep), nodep->widthMin());
+		setCppWidth(nodep);
 	    }
 	}
     }
@@ -93,15 +106,15 @@ private:
     }
     bool isClean(AstNode* nodep) {
 	CleanState clstate = getCleanState(nodep);
-	if (clstate==CLEAN) return true;
-	if (clstate==DIRTY) return false;
-	nodep->v3fatalSrc("Unknown clean state on node.");
+	if (clstate==CS_CLEAN) return true;
+	if (clstate==CS_DIRTY) return false;
+	nodep->v3fatalSrc("Unknown clean state on node: "+nodep->prettyTypeName());
 	return false;
     }
     void setClean(AstNode* nodep, bool isClean) {
 	computeCppWidth (nodep);  // Just to be sure it's in widthMin
 	bool wholeUint = ((nodep->widthMin() % VL_WORDSIZE) == 0);  //32,64,...
-	setCleanState(nodep, ((isClean||wholeUint) ? CLEAN:DIRTY));
+	setCleanState(nodep, ((isClean||wholeUint) ? CS_CLEAN:CS_DIRTY));
     }
 
     // Operate on nodes
@@ -116,7 +129,7 @@ private:
 	AstNode* cleanp = new AstAnd (nodep->fileline(),
 				      new AstConst (nodep->fileline(), mask),
 				      nodep);
-	setCppWidth (cleanp, cppWidth(nodep), nodep->widthMin());
+	cleanp->dtypeFrom(nodep);  // Otherwise the AND normally picks LHS
 	relinkHandle.relink(cleanp);
     }
     void insureClean(AstNode* nodep) {
@@ -160,7 +173,7 @@ private:
     }
 
     // VISITORS
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	m_modp = nodep;
 	nodep->iterateChildren(*this);
 	m_modp = NULL;
@@ -225,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*) {
@@ -240,9 +257,10 @@ private:
 	nodep->iterateChildren(*this);
 	insureClean(nodep->condp());
     }
-    virtual void visit(AstNodePli* nodep, AstNUser*) {
+    virtual void visit(AstSFormatF* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
 	insureCleanAndNext (nodep->exprsp());
+	setClean(nodep, true);  // generates a string, so not relevant
     }
     virtual void visit(AstUCStmt* nodep, AstNUser*) {
 	nodep->iterateChildren(*this);
@@ -262,7 +280,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CleanVisitor(AstNetlist* nodep) {
+    explicit CleanVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CleanVisitor() {}
@@ -274,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Pre C-Emit stage changes
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into sensitivity active domains
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2008-2009 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.
@@ -68,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);
     }
@@ -81,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
@@ -91,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
@@ -219,7 +217,7 @@ private:
     }
 public:
     // CONSTUCTORS
-    GaterCondVisitor(AstNode* nodep) {
+    explicit GaterCondVisitor(AstNode* nodep) {
 	m_isSimple = true;
 	nodep->accept(*this);
     }
@@ -298,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 {
@@ -315,6 +313,7 @@ public:
 	m_exprp = exprp;
 	m_original = original;
 	m_state = STATE_UNKNOWN;
+	m_cloning = false;
 	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyIn:  ");
 	nodep->bodysp()->iterateAndNext(*this);
 	if (debug()>=9) nodep->dumpTree(cout,"  GateBodyOut: ");
@@ -428,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");
@@ -464,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());
@@ -488,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()) {
@@ -516,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);
 		    }
 		}
 	    }
@@ -530,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);
 		}
 	    }
 	}
@@ -685,6 +684,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	AstNode* bodyp = nodep->bodysp()->cloneTree(true);
 
 	AstAlways* alwp = new AstAlways(nodep->fileline(),
+					nodep->keyword(),
 					sensesp,
 					bodyp);
 
@@ -696,7 +696,7 @@ class GaterVisitor : public GaterBaseVisitor {
 	// Blow old statements from new body
 	GaterBodyVisitor(alwp,exprp,false);
 
-	m_statGaters++;
+	++m_statGaters;
 	if (debug()>=9) alwp->dumpTree(cout,"  new: ");
     }
 
@@ -704,8 +704,7 @@ class GaterVisitor : public GaterBaseVisitor {
     virtual void visit(AstAlways* nodep, AstNUser*) {
 	if (debug()>=9) cout<<endl<<endl<<endl;
 	UINFO(5, "Gater: ALWAYS: "<<nodep<<endl);
-	if (nodep->user4()) return;
-	nodep->user4(1);
+	if (nodep->user4SetOnce()) return;
 
 	clear();
 
@@ -862,9 +861,9 @@ class GaterVisitor : public GaterBaseVisitor {
 	    m_stmtVscp = NULL;
 	    m_stmtInPli = false;
 	}
-	if (!nodep->isSplittable()) {
+	if (!nodep->isPure() || nodep->isBrancher()) {
 	    // May also be a new statement (above if); if so we mark it immediately
-	    UINFO(9,"         NotSplittable "<<nodep<<endl);
+	    UINFO(9,"         NotPure "<<nodep<<endl);
 	    scoreboardPli(nodep);
 	}
 	{
@@ -879,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);
@@ -915,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Break always into clock gated blocks
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Clocking POS/NEGEDGE insertion
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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,7 +59,7 @@ private:
     enum {  DOUBLE_OR_RATE = 10 };	// How many | per ||, Determined experimentally as best
 
     // STATE
-    AstModule*		m_modp;		// Current module
+    AstNodeModule*	m_modp;		// Current module
     AstTopScope*	m_topScopep;	// Current top scope
     AstScope*		m_scopep;	// Current scope
     AstActive*		m_activep;	// Current block
@@ -83,11 +82,9 @@ private:
     AstVarScope* getCreateLastClk(AstVarScope* vscp) {
 	if (vscp->user1p()) return ((AstVarScope*)vscp->user1p());
 	AstVar* varp = vscp->varp();
-	if (varp->width()!=1) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
-	string newvarname = ((string)"__Vclklast__"+vscp->scopep()->nameDotless()+"__"+varp->shortName());
-	AstVar* newvarp
-	    = new AstVar (vscp->fileline(), AstVarType::MODULETEMP, newvarname, NULL, NULL); // No range; 1 bit.
-	newvarp->width(1,1);
+	if (!varp->width1()) varp->v3error("Unsupported: Clock edge on non-single bit signal: "<<varp->prettyName());
+	string newvarname = ((string)"__Vclklast__"+vscp->scopep()->nameDotless()+"__"+varp->name());
+	AstVar* newvarp = new AstVar (vscp->fileline(), AstVarType::MODULETEMP, newvarname, VFlagLogicPacked(), 1);
 	m_modp->addStmtp(newvarp);
 	AstVarScope* newvscp = new AstVarScope(vscp->fileline(), m_scopep, newvarp);
 	vscp->user1p(newvscp);
@@ -102,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, new AstRange(fl, width-1, 0));
-	} 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.
@@ -124,7 +109,7 @@ private:
 	// LOWEDGE:  ~var
 	AstNode* newp = NULL;
 	AstVarScope* clkvscp = nodep->varrefp()->varScopep();
-	if (nodep->edgeType()==AstEdgeType::POSEDGE) {
+	if (nodep->edgeType()==AstEdgeType::ET_POSEDGE) {
 	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
 	    newp = new AstAnd(nodep->fileline(),
 			      new AstVarRef(nodep->fileline(),
@@ -132,23 +117,23 @@ private:
 			      new AstNot(nodep->fileline(),
 					 new AstVarRef(nodep->fileline(),
 						       lastVscp, false)));
-	} else if (nodep->edgeType()==AstEdgeType::NEGEDGE) {
+	} else if (nodep->edgeType()==AstEdgeType::ET_NEGEDGE) {
 	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
 	    newp = new AstAnd(nodep->fileline(),
 			      new AstNot(nodep->fileline(),
 					 new AstVarRef(nodep->fileline(),
 						       nodep->varrefp()->varScopep(), false)),
 			      new AstVarRef(nodep->fileline(), lastVscp, false));
-	} else if (nodep->edgeType()==AstEdgeType::BOTHEDGE) {
+	} else if (nodep->edgeType()==AstEdgeType::ET_BOTHEDGE) {
 	    AstVarScope* lastVscp = getCreateLastClk(clkvscp);
 	    newp = new AstXor(nodep->fileline(),
 			      new AstVarRef(nodep->fileline(),
 					    nodep->varrefp()->varScopep(), false),
 			      new AstVarRef(nodep->fileline(), lastVscp, false));
-	} else if (nodep->edgeType()==AstEdgeType::HIGHEDGE) {
+	} else if (nodep->edgeType()==AstEdgeType::ET_HIGHEDGE) {
 	    newp = new AstVarRef(nodep->fileline(),
 				 clkvscp, false);
-	} else if (nodep->edgeType()==AstEdgeType::LOWEDGE) {
+	} else if (nodep->edgeType()==AstEdgeType::ET_LOWEDGE) {
 	    newp = new AstNot(nodep->fileline(),
 			      new AstVarRef(nodep->fileline(),
 					    clkvscp, false));
@@ -233,10 +218,9 @@ private:
 	    funcp->slow(true);
 	    funcp->isStatic(false);
 	    funcp->entryPoint(true);
-	    funcp->addInitsp(
-		new AstCStmt(nodep->fileline(),
-			     "    "+EmitCBaseVisitor::symClassVar()+" = this->__VlSymsp;\n"));
-	    funcp->addInitsp(new AstCStmt(nodep->fileline(),"    "+EmitCBaseVisitor::symTopAssign()+"\n"));
+	    funcp->addInitsp(new AstCStmt(nodep->fileline(),
+					  EmitCBaseVisitor::symClassVar()+" = this->__VlSymsp;\n"));
+	    funcp->addInitsp(new AstCStmt(nodep->fileline(), EmitCBaseVisitor::symTopAssign()+"\n"));
 	    m_scopep->addActivep(funcp);
 	    m_finalFuncp = funcp;
 	}
@@ -259,7 +243,7 @@ private:
 	m_topScopep=NULL;
 	m_scopep = NULL;
     }
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	//UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_stableNum = 0;
@@ -284,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());
@@ -293,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:");
@@ -313,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());
@@ -322,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*) {
@@ -373,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 {
@@ -400,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
@@ -410,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::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*) {
@@ -531,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;
@@ -552,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Clocking POS/NEGEDGE insertion
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Combine common code into functions
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -70,8 +69,12 @@ protected:
     virtual ~CombBaseVisitor() {}
 
     //***** optimization levels
-    bool emptyFunctionDeletion() { return true; }
-    bool duplicateFunctionCombine() { return true; }
+    static bool emptyFunctionDeletion() { return true; }
+    static bool duplicateFunctionCombine() { return true; }
+    // Note this is disabled, it still needed work
+    // Also repair it for DPI functions; when make __common need to insure proper
+    // flags get inherited from the old to new AstCFunc, and that AstText doesn't
+    // get split between functions causing the text to have a danginling reference.
     bool statementCombine() { return false && duplicateFunctionCombine(); }
 };
 
@@ -101,14 +104,14 @@ public:
 		if (callp->funcp() != oldfuncp) callp->v3fatalSrc("Call list broken, points to call w/different func");
 		if (newfuncp) {
 		    AstCCall* newp = new AstCCall(callp, newfuncp);
-		    newp->argTypes(callp->argTypes());
+		    // Special new AstCCall form above transfers children of callp to newfuncp
 		    callp->replaceWith(newp);
 		    addCall(newp); // Fix the table
 		} else { // Just deleting empty function
 		    callp->unlinkFrBack();
 		}
 		callp->user3(true);	// Dead now
-		pushDeletep(callp); callp=NULL;
+		pushDeletep(callp); VL_DANGLING(callp);
 		m_callMmap.erase(eqit);	// Fix the table
 	    }
 	}
@@ -142,7 +145,9 @@ private:
     }
 public:
     // CONSTRUCTORS
-    CombCallVisitor() {}
+    CombCallVisitor() {
+	m_find = false;
+    }
     virtual ~CombCallVisitor() {}
     void main(AstNetlist* nodep) {
 	nodep->accept(*this);
@@ -164,7 +169,7 @@ private:
     }
 public:
     // CONSTRUCTORS
-    CombMarkVisitor(AstNode* nodep) {
+    explicit CombMarkVisitor(AstNode* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CombMarkVisitor() {}
@@ -189,7 +194,7 @@ private:
     typedef enum {STATE_IDLE, STATE_HASH, STATE_DUP} CombineState;
     V3Double0		m_statCombs;	// Statistic tracking
     CombineState	m_state;	// Major state
-    AstModule*		m_modp;		// Current module
+    AstNodeModule*	m_modp;		// Current module
     AstCFunc*		m_funcp;	// Current function
     V3Hash		m_lowerHash;	// Hash of the statement we're building
     CombCallVisitor	m_call;		// Tracking of function call users
@@ -225,7 +230,7 @@ private:
 		CombMarkVisitor visitor(oldfuncp);
 		m_call.replaceFunc(oldfuncp, NULL);
 		oldfuncp->unlinkFrBack();
-		pushDeletep(oldfuncp); oldfuncp=NULL;
+		pushDeletep(oldfuncp); VL_DANGLING(oldfuncp);
 	    }
 	}
     }
@@ -253,11 +258,11 @@ private:
 	UINFO(5,"     DupFunc "<<hex<<V3Hash(newfuncp->user4p())<<" "<<newfuncp<<endl);
 	UINFO(5,"         and "<<hex<<V3Hash(oldfuncp->user4p())<<" "<<oldfuncp<<endl);
 	// Mark user3p on entire old tree, so we don't process it more
-	m_statCombs++;
+	++m_statCombs;
 	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()) {
@@ -269,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);
 	    }
 	}
     }
@@ -379,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
@@ -393,7 +398,7 @@ private:
 	// Required so that a module instantiating another can benefit from collapsing.
 	nodep->iterateChildrenBackwards(*this);
     }
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    virtual void visit(AstNodeModule* nodep, AstNUser*) {
 	UINFO(4," MOD   "<<nodep<<endl);
 	m_modp = nodep;
 	m_modNFuncs = 0;
@@ -452,7 +457,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CombineVisitor(AstNetlist* nodep) {
+    explicit CombineVisitor(AstNetlist* nodep) {
 	m_modp=NULL;
 	m_funcp = NULL;
 	m_state = STATE_IDLE;
@@ -469,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Combine common code into functions
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -0,0 +1,158 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Configuration Files
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// 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.
+//
+// Verilator is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+//*************************************************************************
+
+#include "config_build.h"
+#include "verilatedos.h"
+#include <string>
+#include <map>
+#include <set>
+
+#include "V3Global.h"
+#include "V3String.h"
+#include "V3Config.h"
+
+//######################################################################
+
+class V3ConfigLine {
+public:
+    int		m_lineno;	// Line number to make change at
+    V3ErrorCode	m_code;		// Error code
+    bool	m_on;		// True to enaable message
+    V3ConfigLine(V3ErrorCode code, int lineno, bool on)
+	: m_lineno(lineno), m_code(code), m_on(on) {}
+    ~V3ConfigLine() {}
+    inline bool operator< (const V3ConfigLine& rh) const {
+	if (m_lineno<rh.m_lineno) return true;
+	if (m_lineno>rh.m_lineno) return false;
+	if (m_code<rh.m_code) return true;
+	if (m_code>rh.m_code) return false;
+	// Always turn "on" before "off" so that overlapping lines will end up finally with the error "off"
+	return (m_on>rh.m_on);
+    }
+};
+ostream& operator<<(ostream& os, V3ConfigLine rhs) { return os<<rhs.m_lineno<<", "<<rhs.m_code<<", "<<rhs.m_on; }
+
+class V3ConfigIgnores {
+    typedef multiset<V3ConfigLine> IgnLines;	// list of {line,code,on}
+    typedef map<string,IgnLines> IgnFiles;	// {filename} => list of {line,code,on}
+
+    // MEMBERS
+    string		m_lastFilename;	// Last filename looked up
+    int			m_lastLineno;	// Last linenumber looked up
+
+    IgnLines::const_iterator m_lastIt;	// Point with next linenumber > current line number
+    IgnLines::const_iterator m_lastEnd;	// Point with end()
+
+    IgnFiles		m_ignWilds;	// Ignores for each wildcarded filename
+    IgnFiles		m_ignFiles;	// Ignores for each non-wildcarded filename
+
+    static V3ConfigIgnores s_singleton;	// Singleton (not via local static, as that's slow)
+
+    V3ConfigIgnores() { m_lastLineno = -1; }
+    ~V3ConfigIgnores() {}
+
+    // METHODS
+    inline IgnLines* findWilds(const string& wildname) {
+	IgnFiles::iterator it = m_ignWilds.find(wildname);
+	if (it != m_ignWilds.end()) {
+	    return &(it->second);
+	} else {
+	    m_ignWilds.insert(make_pair(wildname, IgnLines()));
+	    it = m_ignWilds.find(wildname);
+	    return &(it->second);
+	}
+    }
+    inline void absBuild(const string& filename) {
+	// Given a filename, find all wildcard matches against it and build
+	// hash with the specific filename.  This avoids having to wildmatch
+	// more than once against any filename.
+	IgnFiles::iterator it = m_ignFiles.find(filename);
+	if (it == m_ignFiles.end()) {
+	    // Haven't seen this filename before
+	    m_ignFiles.insert(make_pair(filename, IgnLines()));
+	    it = m_ignFiles.find(filename);
+	    // Make new list for this file of all matches
+	    for (IgnFiles::iterator fnit = m_ignWilds.begin(); fnit != m_ignWilds.end(); ++fnit) {
+		if (VString::wildmatch(filename.c_str(), fnit->first.c_str())) {
+		    for (IgnLines::iterator lit = fnit->second.begin(); lit != fnit->second.end(); ++lit) {
+			it->second.insert(*lit);
+		    }
+		}
+	    }
+	}
+	m_lastIt = it->second.begin();
+	m_lastEnd = it->second.end();
+    }
+
+public:
+    inline static V3ConfigIgnores& singleton() { return s_singleton; }
+
+    void addIgnore(V3ErrorCode code, string wildname, int lineno, bool on) {
+	// Insert
+	IgnLines* linesp = findWilds(wildname);
+	UINFO(9,"config addIgnore "<<wildname<<":"<<lineno<<", "<<code<<", "<<on<<endl);
+	linesp->insert(V3ConfigLine(code, lineno, on));
+	// Flush the match cache, due to a change in the rules.
+	m_ignFiles.clear();
+	m_lastFilename = " ";
+    }
+    inline void applyIgnores(FileLine* filelinep) {
+	// HOT routine, called each parsed token line
+	if (m_lastLineno != filelinep->lineno()
+	    || m_lastFilename != filelinep->filename()) {
+	    //UINFO(9,"   ApplyIgnores for "<<filelinep->ascii()<<endl);
+	    if (VL_UNLIKELY(m_lastFilename != filelinep->filename())) {
+		absBuild(filelinep->filename());
+		m_lastFilename = filelinep->filename();
+	    }
+	    // Process all on/offs for lines up to and including the current line
+	    int curlineno = filelinep->lineno();
+	    for (; m_lastIt != m_lastEnd; ++m_lastIt) {
+		if (m_lastIt->m_lineno > curlineno) break;
+		//UINFO(9,"     Hit "<<*m_lastIt<<endl);
+		filelinep->warnOn(m_lastIt->m_code, m_lastIt->m_on);
+	    }
+	    if (0 && debug() >= 9) {
+		for (IgnLines::const_iterator it=m_lastIt; it != m_lastEnd; ++it) {
+		    UINFO(9,"     NXT "<<*it<<endl);
+		}
+	    }
+	    m_lastLineno = filelinep->lineno();
+	}
+    }
+};
+
+V3ConfigIgnores V3ConfigIgnores::s_singleton;
+
+//######################################################################
+// V3Config
+
+void V3Config::addIgnore(V3ErrorCode code, bool on, string filename, int min, int max) {
+    if (filename=="*") {
+	FileLine::globalWarnOff(code,!on);
+    } else {
+	V3ConfigIgnores::singleton().addIgnore(code, filename, min, on);
+	if (max) V3ConfigIgnores::singleton().addIgnore(code, filename, max, !on);
+    }
+}
+
+void V3Config::applyIgnores(FileLine* filelinep) {
+    V3ConfigIgnores::singleton().applyIgnores(filelinep);
+}

src/V3Config.h

@@ -0,0 +1,37 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+// DESCRIPTION: Verilator: Configuration Files
+//
+// Code available from: http://www.veripool.org/verilator
+//
+//*************************************************************************
+//
+// 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.
+//
+// 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 _V3CONFIG_H_
+#define _V3CONFIG_H_ 1
+#include "config_build.h"
+#include "verilatedos.h"
+#include <string>
+#include "V3Error.h"
+#include "V3FileLine.h"
+
+//######################################################################
+
+class V3Config {
+public:
+    static void addIgnore(V3ErrorCode code, bool on, string filename, int min, int max);
+    static void applyIgnores(FileLine* filelinep);
+};
+
+#endif // Guard

src/V3Const.h

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Propagate constants across AST
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -31,9 +29,10 @@
 
 class V3Const {
 public:
-    // Force this cell node's parameter list to become a constant
-    // Return new node that may have replaced nodep
     static AstNode* constifyParamsEdit(AstNode* nodep);
+    static AstNode* constifyGenerateParamsEdit(AstNode* nodep);
+    // Only do constant pushing, without removing dead logic
+    static void constifyAllLive(AstNetlist* nodep);
     // Everything that's possible
     static void constifyAll(AstNetlist* nodep);
     // Also, warn

src/V3Coverage.cpp

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Netlist (top level) functions
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -48,10 +47,29 @@ private:
     // TYPES
     typedef map<string,int>	FileMap;
 
+    struct ToggleEnt {
+	string		m_comment;	// Comment for coverage dump
+	AstNode*	m_varRefp;	// How to get to this element
+	AstNode*	m_chgRefp;	// How to get to this element
+	ToggleEnt(const string& comment, AstNode* vp, AstNode* cp)
+	    : m_comment(comment), m_varRefp(vp), m_chgRefp(cp) {}
+	~ToggleEnt() {}
+	void cleanup() {
+	    m_varRefp->deleteTree(); m_varRefp=NULL;
+	    m_chgRefp->deleteTree(); m_chgRefp=NULL;
+	}
+    };
+
+    // NODE STATE
+    // Entire netlist:
+    //  AstIf::user1()			-> bool.  True indicates ifelse processed
+    AstUser1InUse	m_inuser1;
+
     // STATE
-    bool	m_checkBlock;	// Should this block get covered?
-    AstModule*	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
 
@@ -68,11 +86,13 @@ private:
 	string prettyName = nodep->prettyName();
 	if (!nodep->isToggleCoverable())
 	    return "Not relevant signal type";
-	if (prettyName.c_str()[0] == '_')
-	    return "Leading underscore";
-	if (prettyName.find("._") != string::npos)
-	    return "Inlined leading underscore";
-	if ((nodep->width()*nodep->arrayElements()) > 256) return "Wide bus/array > 256 bits";
+	if (!v3Global.opt.coverageUnderscore()) {
+	    if (prettyName[0] == '_')
+	        return "Leading underscore";
+	    if (prettyName.find("._") != string::npos)
+	        return "Inlined leading underscore";
+	}
+	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;
@@ -108,11 +128,13 @@ private:
     }
 
     // VISITORS - BOTH
-    virtual void visit(AstModule* nodep, AstNUser*) {
+    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
@@ -126,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) {
@@ -143,12 +165,6 @@ private:
 		//    Convert to "AstCoverInc(CoverInc...)"
 		//	We'll do this, and make the if(...) coverinc later.
 
-		// Compute size of the problem
-		int dimensions = 0;
-		for (AstRange* arrayp=nodep->arraysp(); arrayp; arrayp = arrayp->nextp()->castRange()) {
-		    dimensions++;
-		}
-
 		// Add signal to hold the old value
 		string newvarname = (string)"__Vtogcov__"+nodep->shortName();
 		AstVar* chgVarp = new AstVar (nodep->fileline(), AstVarType::MODULETEMP, newvarname, nodep);
@@ -157,73 +173,127 @@ private:
 		// Create bucket for each dimension * bit.
 		// This is necessarily an O(n^2) expansion, which is why
 		// we limit coverage to signals with < 256 bits.
-		vector<int> selects_docs;  selects_docs.resize(dimensions);
-		vector<int> selects_code;  selects_code.resize(dimensions);
-		toggleVarRecurse(nodep, chgVarp, nodep->arraysp(),
-				 0, selects_docs, selects_code );
+
+		ToggleEnt newvec (string(""),
+				  new AstVarRef(nodep->fileline(), nodep, false),
+				  new AstVarRef(nodep->fileline(), chgVarp, true));
+		toggleVarRecurse(nodep->dtypeSkipRefp(), 0, newvec,
+				 nodep, chgVarp);
+		newvec.cleanup();
 	    }
 	}
     }
 
-    void toggleVarRecurse(AstVar* nodep, AstVar* chgVarp, AstRange* arrayp,
-			  int dimension, vector<int>& selects_docs, vector<int>& selects_code) {
-	if (arrayp) {
-	    for (int index=arrayp->lsbConst(); index<=arrayp->msbConst()+1; index++) {
-		// Handle the next dimension, if any
-		selects_docs[dimension] = index;
-		selects_code[dimension] = index - arrayp->lsbConst();
-		toggleVarRecurse(nodep, chgVarp, arrayp->nextp()->castRange(),
-				 dimension+1, selects_docs, selects_code);
-	    }
-	} else {  // No more arraying - just each bit in the width
-	    if (nodep->rangep()) {
-		for (int bitindex_docs=nodep->lsb(); bitindex_docs<nodep->msb()+1; bitindex_docs++) {
-		    toggleVarBottom(nodep, chgVarp,
-				    dimension, selects_docs, selects_code,
-				    true, bitindex_docs);
+    void toggleVarBottom(AstNodeDType* dtypep, int depth, // per-iteration
+		     const ToggleEnt& above,
+		     AstVar* varp, AstVar* chgVarp) { // Constant
+	AstCoverToggle* newp
+	    = new AstCoverToggle (varp->fileline(),
+				  newCoverInc(varp->fileline(), "", "v_toggle",
+					      varp->name()+above.m_comment),
+				  above.m_varRefp->cloneTree(true),
+				  above.m_chgRefp->cloneTree(true));
+	m_modp->addStmtp(newp);
+    }
+
+    void toggleVarRecurse(AstNodeDType* dtypep, int depth, // per-iteration
+		     const ToggleEnt& above,
+		     AstVar* varp, AstVar* chgVarp) { // Constant
+	if (AstBasicDType* bdtypep = dtypep->castBasicDType()) {
+	    if (bdtypep->isRanged()) {
+		for (int index_docs=bdtypep->lsb(); index_docs<bdtypep->msb()+1; index_docs++) {
+		    int index_code = index_docs - bdtypep->lsb();
+		    ToggleEnt newent (above.m_comment+string("[")+cvtToStr(index_docs)+"]",
+				      new AstSel(varp->fileline(), above.m_varRefp->cloneTree(true), index_code, 1),
+				      new AstSel(varp->fileline(), above.m_chgRefp->cloneTree(true), index_code, 1));
+		    toggleVarBottom(dtypep, depth+1,
+				    newent,
+				    varp, chgVarp);
+		    newent.cleanup();
 		}
 	    } else {
-		toggleVarBottom(nodep, chgVarp,
-				dimension, selects_docs, selects_code,
-				false, 0);
+		toggleVarBottom(dtypep, depth+1,
+				above,
+				varp, chgVarp);
 	    }
 	}
-    }
-    void toggleVarBottom(AstVar* nodep, AstVar* chgVarp,
-			 int dimension, vector<int>& selects_docs, vector<int>& selects_code,
-			 bool bitsel, int bitindex_docs) {
-	string comment = nodep->name();
-	AstNode* varRefp = new AstVarRef(nodep->fileline(), nodep, false);
-	AstNode* chgRefp = new AstVarRef(nodep->fileline(), chgVarp, true);
-	// Now determine the name of, and how to get to the bit of this slice
-	for (int dim=0; dim<dimension; dim++) {
-	    // Comments are strings, not symbols, so we don't need __BRA__ __KET__ 
-	    comment += "["+cvtToStr(selects_docs[dim])+"]";
-	    varRefp = new AstArraySel(nodep->fileline(), varRefp, selects_code[dim]);
-	    chgRefp = new AstArraySel(nodep->fileline(), chgRefp, selects_code[dim]);
+	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),
+				  new AstArraySel(varp->fileline(), above.m_chgRefp->cloneTree(true), index_code));
+		toggleVarRecurse(adtypep->subDTypep()->skipRefp(), depth+1,
+				 newent,
+				 varp, chgVarp);
+		newent.cleanup();
+	    }
 	}
-	if (bitsel) {
-	    comment += "["+cvtToStr(bitindex_docs)+"]";
-	    int bitindex_code = bitindex_docs - nodep->lsb();
-	    varRefp = new AstSel(nodep->fileline(), varRefp, bitindex_code, 1);
-	    chgRefp = new AstSel(nodep->fileline(), chgRefp, bitindex_code, 1);
+	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());
 	}
-	AstCoverToggle* newp = new AstCoverToggle (nodep->fileline(),
-						   newCoverInc(nodep->fileline(), "", "v_toggle", comment),
-						   varRefp, chgRefp);
-	m_modp->addStmtp(newp);
     }
 
     // VISITORS - LINE COVERAGE
     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"));
 		}
 	    }
@@ -231,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"));
 		    }
 		}
@@ -246,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
@@ -275,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);
 	}
@@ -310,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() {}
@@ -326,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

@@ -1,14 +1,12 @@
-// -*- C++ -*-
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Coverage modules/signals together
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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

@@ -1,13 +1,12 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 // DESCRIPTION: Verilator: Netlist (top level) functions
 //
 // Code available from: http://www.veripool.org/verilator
 //
-// AUTHORS: Wilson Snyder with Paul Wasson, Duane Gabli
-//
 //*************************************************************************
 //
-// Copyright 2003-2009 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.
@@ -94,10 +93,10 @@ 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++;
+		    ++m_statToggleJoins;
 		}
 	    }
 	}
@@ -122,7 +121,7 @@ private:
 
 public:
     // CONSTUCTORS
-    CoverageJoinVisitor(AstNetlist* nodep) {
+    explicit CoverageJoinVisitor(AstNetlist* nodep) {
 	nodep->accept(*this);
     }
     virtual ~CoverageJoinVisitor() {
@@ -136,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);
 }