Version bump

- Issue an error when --build is used together with --make
- When given --build, always use GNU Make to perform the build
- Update documentation (examples were good as they were)
- Remove the broken t_flag_build_cmake test

Fixes #2280

.clang-format

@@ -13,7 +13,7 @@ AllowShortBlocksOnASingleLine: true
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: All
 AllowShortIfStatementsOnASingleLine: true
-AllowShortLoopsOnASingleLine: false
+AllowShortLoopsOnASingleLine: true
 AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
@@ -90,10 +90,6 @@ PenaltyBreakString: 1000
 PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Left
-RawStringFormats: 
-  - Delimiter:       pb
-    Language:        TextProto
-    BasedOnStyle:    google
 ReflowComments:  true
 SortIncludes:    false
 SortUsingDeclarations: true
@@ -108,7 +104,7 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp11
+Standard:        Cpp03
 TabWidth:        8
 UseTab:          Never
 ...

.codacy.yml

@@ -1,4 +1,5 @@
 ---
 exclude_paths:
+  - '.github/**'
   - 'ci/build_verilator.sh'
   - 'include/vltstd/**'

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Something isn't working as expected, and it isn't "Unsupported." (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+title: ''
+labels: new
+assignees: ''
+
+---
+
+Thanks for taking the time to report this.
+
+Can you attach an example that shows the issue?  (Must be openly licensed, ideally in test_regress format.)
+
+What 'verilator --version' are you using?  Did you try it with the git master version?
+
+Would you be willing to try to fix Verilator yourself with assistance?

.github/ISSUE_TEMPLATE/feature.md

@@ -0,0 +1,16 @@
+---
+name: Feature Request
+about: Request something should be supported, or a new feature added. (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+title: ''
+labels: new
+assignees: ''
+
+---
+
+Thanks for taking the time to report this.
+
+What would you like added/supported?
+
+Can you attach an example that runs on other simulators?  (Must be openly licensed, ideally in test_regress format.)
+
+May we assist you in trying to fix this yourself?

.github/ISSUE_TEMPLATE/questions.md

@@ -0,0 +1,10 @@
+---
+name: Q and A, or Other
+about: Ask a question, not related to a specific bug or feature request. (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+title: ''
+labels: new
+assignees: ''
+
+---
+
+How may we help - what is your question?

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1 @@
+We appreciate your contributing to Verilator.  If this is your first commit, please add your name to docs/CONTRIBUTORS, and read our contributing guidelines in docs/CONTRIBUTING.adoc.

.github/labels.toml

@@ -0,0 +1,199 @@
+["area: assertions"]
+color = "ffffe8"
+name = "area: assertions"
+description = "Issue involves assertions"
+
+["area: configure/compiling"]
+color = "ffffe8"
+name = "area: configure/compiling"
+description = "Issue involves configuring or compilating Verilator itself"
+
+["area: coverage"]
+color = "ffffe8"
+name = "area: coverage"
+description = "Issue involves coverage generation"
+
+["area: data-types"]
+color = "ffffe8"
+name = "area: data-types"
+description = "Issue involves data-types"
+
+["area: documentation"]
+color = "ffffe8"
+name = "area: documentation"
+description = "Issue involves documentation"
+
+["area: elaboration"]
+color = "ffffe8"
+name = "area: elaboration"
+description = "Issue involves elaboration phase"
+
+["area: invoking/options"]
+color = "ffffe8"
+name = "area: invoking/options"
+description = "Issue involves options passed to Verilator"
+
+["area: lint"]
+color = "ffffe8"
+name = "area: lint"
+description = "Issue involves SystemVerilog lint checking"
+
+["area: parser"]
+color = "ffffe8"
+name = "area: parser"
+description = "Issue involves SystemVerilog parsing"
+
+["area: performance"]
+color = "ffffe8"
+name = "area: performance"
+description = "Issue involves performance issues"
+
+["area: portability"]
+color = "ffffe8"
+name = "area: portability"
+description = "Issue involves operating system/compiler portability"
+
+["area: runtime result"]
+color = "ffffe8"
+name = "area: runtime result"
+description = "Issue involves an incorrect runtine result from Verilated model"
+
+["area: scheduling"]
+color = "ffffe8"
+name = "area: scheduling"
+description = "Issue involves scheduling/ordering of events"
+
+["area: tests"]
+color = "ffffe8"
+name = "area: tests"
+description = "Issue involves the testing system"
+
+["area: usability"]
+color = "ffffe8"
+name = "area: usability"
+description = "Issue involves general usability"
+
+["effort: days"]
+color = "d0c0b0"
+name = "effort: days"
+description = "Expect this issue to require roughly days of invested effort to resolve"
+
+["effort: hours"]
+color = "f5e6d6"
+name = "effort: hours"
+description = "Expect this issue to require roughly hours of invested effort to resolve"
+
+["effort: minutes"]
+color = "f5e6d6"
+name = "effort: minutes"
+description = "Expect this issue to require less than an hour of invested effort to resolve"
+
+["effort: weeks"]
+color = "d0c0b0"
+name = "effort: weeks"
+description = "Expect this issue to require weeks or more of invested effort to resolve"
+
+["good first issue"]
+color = "7057ff"
+name = "good first issue"
+description = "Good for newcomers"
+
+["help wanted"]
+color = "008672"
+name = "help wanted"
+description = "Extra attention is needed"
+
+["new"]
+color = "ff4400"
+name = "new"
+description = "New issue, not yet seen by maintainers"
+
+["resolution: abandoned"]
+color = "cfd3d7"
+name = "resolution: abandoned"
+description = "Closed; not enough information or otherwise never finished"
+
+["resolution: answered"]
+color = "cfd3d7"
+name = "resolution: answered"
+description = "Closed; only applies to questions which were answered"
+
+["resolution: duplicate"]
+color = "cfd3d7"
+name = "resolution: duplicate"
+description = "Closed; issue or pull request already exists"
+
+["resolution: external"]
+color = "cfd3d7"
+name = "resolution: external"
+description = "Closed; passed to another tool's bug tracker"
+
+["resolution: fixed"]
+color = "cfd3d7"
+name = "resolution: fixed"
+description = "Closed; fixed"
+
+["resolution: invalid"]
+color = "cfd3d7"
+name = "resolution: invalid"
+description = "Closed; issue or pull request is no longer relevant"
+
+["resolution: no fix needed"]
+color = "cfd3d7"
+name = "resolution: no fix needed"
+description = "Closed; no fix required (not a bug)"
+
+["resolution: wontfix"]
+color = "cfd3d7"
+name = "resolution: wontfix"
+description = "Closed; work won't continue on an issue or pull request"
+
+["status: asked reporter"]
+color = "ffffff"
+name = "status: asked reporter"
+description = "Bug is waiting for reporter to answer a question"
+
+["status: assigned"]
+color = "a0f0ff"
+name = "status: assigned"
+description = "Issue is assigned to someone to work on"
+
+["status: blocked"]
+color = "00007f"
+name = "status: blocked"
+description = "Issue is waiting for another bug, when other bug is fixed, then goes to 'status: assigned'"
+
+["status: discussion"]
+color = "d876e3"
+name = "status: discussion"
+description = "Issue is waiting for discussions to resolve"
+
+["status: ready"]
+color = "b6c92a"
+name = "status: ready"
+description = "Issue is ready for someone to fix; then goes to 'status: assigned'"
+
+["type: bug"]
+color = "d73a4a"
+name = "type: bug"
+description = "Defect"
+
+["type: feature-IEEE"]
+color = "cfccff"
+name = "type: feature-IEEE"
+description = "Request to add new feature, described in IEEE 1800"
+
+["type: feature-non-IEEE"]
+color = "cfccff"
+name = "type: feature-non-IEEE"
+description = "Request to add new feature, outside IEEE 1800"
+
+["type: maintenance"]
+color = "cfccff"
+name = "type: maintenance"
+description = "Internal maintenance task"
+
+["type: q and a"]
+color = "84ba34"
+name = "type: q and a"
+description = "Question and answer about some feature or user question"

.gitignore

@@ -17,6 +17,7 @@
 README
 TAGS
 autom4te.cache
+compile_commands.json
 config.cache
 config.status
 configure

.travis.yml

@@ -1,20 +1,24 @@
 # DESCRIPTION: Travis-CI config
 #
-# Copyright 2003-2019 by Todd Strader. 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.
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
+version: ~> 1.0
+
+os: linux
 language: cpp
-
 cache: ccache
 
 env:
   global:
     - VERILATOR_CACHE=$HOME/verilator_cache
     - VERILATOR_ROOT=$PWD
-    - VERILATOR_NUM_JOBS=$((`nproc` + 1))
+    - VERILATOR_NUM_JOBS=$(echo `nproc` + 1 | bc)
     - VERILATOR_CONFIG_FLAGS="--enable-maintainer-mode --enable-longtests"
-    - OBJCACHE=ccache
+    - VERILATOR_AUTHOR_SITE=1
 
 cache:
   directories:
@@ -22,9 +26,13 @@ cache:
 
 before_install:
 # Perl modules needed for testing
-  - yes yes | sudo cpan -fi Unix::Processors Parallel::Forker Bit::Vector
-  - sudo apt-get install gdb
+# Not listing Bit::Vector as slow to install, and only skips one test
+  - touch temp.cpp ; g++ -E -dM -c temp.cpp | sort ; rm -rf temp.cpp
+  - yes yes | sudo cpan -fi Unix::Processors Parallel::Forker
+  - sudo apt-get install gdb gtkwave
+  - sudo apt-get install libgoogle-perftools-dev
 before_script:
+  - bash -x ci/build_vcddiff.sh
   - bash -x ci/build_verilator.sh
 after_script:
   - ccache -s
@@ -38,75 +46,84 @@ jobs:
     - if: type != cron
       stage: "Build Verilator"
       name: Build Verilator
-      os: linux
       compiler: gcc
       script: echo "Done building Verilator"
 # Non-cron build will just run on whatever linux flavor we get
     - if: type != cron
       stage: test
       name: Dist test
-      os: linux
       compiler: gcc
       script: ci/test.sh dist
     - if: type != cron
       stage: test
       name: Vlt test
-      os: linux
       compiler: gcc
       script: ci/test.sh vlt
     - if: type != cron
       stage: test
-      name: Vltmt test
-      os: linux
+      name: Vltmt set 0 test
       compiler: gcc
-      script: ci/test.sh vltmt
+      script: ci/test.sh vltmt0
+    - if: type != cron
+      stage: test
+      name: Vltmt set 1 test
+      compiler: gcc
+      script: ci/test.sh vltmt1
 # Cron builds try different OS/compiler combinations
     - if: type = cron
       stage: "Build Verilator"
       name: Build xenial gcc Verilator
-      os: xenial
+      os: linux
+      dist: xenial
       compiler: gcc
       script: echo "Done building Verilator"
     - if: type = cron
       stage: test
-      name: Xenail gcc dist test
-      os: xenial
+      name: Xenial gcc dist test
+      os: linux
+      dist: xenial
       compiler: gcc
       script: ci/test.sh dist
     - if: type = cron
       stage: test
-      name: Xenail gcc vlt test
-      os: xenial
+      name: Xenial gcc vlt test
+      os: linux
+      dist: xenial
       compiler: gcc
       script: ci/test.sh vlt
     - if: type = cron
       stage: test
-      name: Xenail gcc vltmt test
-      os: xenial
+      name: Xenial gcc vltmt test
+      os: linux
+      dist: xenial
       compiler: gcc
       script: ci/test.sh vltmt
     - if: type = cron
       stage: "Build Verilator"
       name: Build xenial clang Verilator
-      os: xenial
+      os: linux
+      dist: xenial
       compiler: clang
       script: echo "Done building Verilator"
     - if: type = cron
       stage: test
-      name: Xenail clang dist test
-      os: xenial
+      name: Xenial clang dist test
+      os: linux
+      dist: xenial
       compiler: clang
       script: ci/test.sh dist
     - if: type = cron
       stage: test
-      name: Xenail clang vlt test
-      os: xenial
+      name: Xenial clang vlt test
+      os: linux
+      dist: xenial
       compiler: clang
       script: ci/test.sh vlt
     - if: type = cron
       stage: test
-      name: Xenail clang vltmt test
-      os: xenial
+      name: Xenial clang vltmt test
+      os: linux
+      dist: xenial
       compiler: clang
       script: ci/test.sh vltmt
 #    - if: type = cron
@@ -125,37 +142,46 @@ jobs:
 #      stage: test
 #      name: OSX gcc vlt test
 #      os: osx
-#      os: osx
 #      compiler: gcc
 #      script: ci/test.sh vlt
 #    - if: type = cron
 #      stage: test
 #      name: OSX gcc vltmt test
 #      os: osx
-#      os: osx
 #      compiler: gcc
 #      script: ci/test.sh vltmt
     - if: type = cron
       stage: "Build Verilator"
       name: Build trusty gcc Verilator
-      os: trusty
+      os: linux
+      dist: trusty
       compiler: gcc
       script: echo "Done building Verilator"
     - if: type = cron
       stage: test
       name: Trusty gcc dist test
-      os: trusty
+      os: linux
+      dist: trusty
       compiler: gcc
       script: ci/test.sh dist
     - if: type = cron
       stage: test
       name: Trusty gcc vlt test
-      os: trusty
+      os: linux
+      dist: trusty
       compiler: gcc
       script: ci/test.sh vlt
     - if: type = cron
       stage: test
-      os: trusty
+      os: linux
+      dist: trusty
       name: Trusty gcc vltmt test
       compiler: gcc
       script: ci/test.sh vltmt
+
+notifications:
+  email:
+    if: repo = verilator/verilator
+    recipients:
+      - [email protected]
+      - [email protected]

MANIFEST.SKIP

@@ -2,6 +2,7 @@
 \.clang-tidy
 \.git/
 \.git$
+\.github/
 \.svn/
 \.(bak|old)/
 \.(bak|old)$
@@ -18,15 +19,16 @@
 \.codacy\.yml
 \.travis\.yml
 /build/
-/obj_dir/
 /obj_dbg/
+/obj_dir/
+/obj_dist/
+/obj_iv/
 /obj_nc/
 /obj_opt/
 /obj_vcs/
 /obj_vlt/
 /obj_vltmt/
-/obj_dist/
-/INCA_libs/
+INCA_libs/
 /cov_work/
 /logs/
 ^Makefile$
@@ -35,6 +37,7 @@ bin/verilator_bin.*
 bin/verilator_coverage_bin.*
 docs/.*\.html$
 docs/Makefile$
+docs/clang-format.txt$
 docs/doxygen-doc/.*
 examples/xml_py/copied/
 examples/xml_py/graph.*

Makefile.in

@@ -7,15 +7,11 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/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.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 #****************************************************************************/
 #
@@ -103,7 +99,7 @@ PACKAGE_VERSION = @PACKAGE_VERSION@
 
 SHELL = /bin/sh
 
-SUBDIRS = src test_regress \
+SUBDIRS = docs src test_regress \
 	examples/cmake_hello_c \
 	examples/cmake_hello_sc \
 	examples/cmake_tracing_c \
@@ -114,6 +110,7 @@ SUBDIRS = src test_regress \
 	examples/make_tracing_c \
 	examples/make_tracing_sc \
 	examples/make_protect_lib \
+	examples/xml_py \
 
 INFOS = verilator.txt verilator.html verilator.pdf
 
@@ -147,6 +144,7 @@ DISTFILES_INC = $(INFOS) .gitignore \
 	docs/install.adoc \
 	docs/internals.adoc \
 	docs/verilator_logo.png \
+	docs/xml.adoc \
 	install-sh configure *.pod \
 	include/*.[chv]* \
 	include/*.in \
@@ -206,12 +204,6 @@ EXAMPLES_FIRST = \
 
 EXAMPLES = $(EXAMPLES_FIRST) $(filter-out $(EXAMPLES_FIRST), $(sort $(wildcard examples/*)))
 
-ifeq ($(OBJCACHE_JOBS),)
-ifneq ($(OBJCACHE_HOSTS),)
-export OBJCACHE_JOBS := -j $(shell objcache --jobs "$(OBJCACHE_HOSTS)")
-endif
-endif
-
 # 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_gantt.1 verilator_profcfunc.1
 
@@ -344,6 +336,7 @@ installdata:
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_c
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_sc
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/cmake_protect_lib
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/examples/xml_py
 	cd $(srcdir) \
 	; for p in $(VL_INST_DATA_SRCDIR_FILES) ; do \
 	  $(INSTALL_DATA) $$p $(DESTDIR)$(pkgdatadir)/$$p; \
@@ -378,8 +371,8 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_c
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_tracing_sc
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples/cmake_protect_lib
+	-rmdir $(DESTDIR)$(pkgdatadir)/examples/xml_py
 	-rmdir $(DESTDIR)$(pkgdatadir)/examples
-	-rmdir $(DESTDIR)$(pkgdatadir)/cmake
 	-rmdir $(DESTDIR)$(pkgdatadir)
 	-rmdir $(DESTDIR)$(pkgconfigdir)
 
@@ -463,6 +456,14 @@ analyzer-include:
 	-rm -rf examples/*/obj*
 	scan-build $(MAKE) -k examples
 
+CLANGFORMAT = clang-format
+CLANGFORMAT_FLAGS = -i
+
+clang-format:
+	@$(CLANGFORMAT) --version | egrep 10.0 > /dev/null \
+		|| echo "*** You are not using clang-format 10.0, indents may differ from master's ***"
+	$(CLANGFORMAT) $(CLANGFORMAT_FLAGS) $(CPPCHECK_CPP) $(CPPCHECK_H)
+
 ftp: info
 
 install-msg:
@@ -513,6 +514,7 @@ clean mostlyclean distclean maintainer-clean::
 	rm -f *.tex
 	rm -rf examples/*/obj_dir* examples/*/logs
 	rm -rf test_*/obj_dir
+	rm -rf nodist/fuzzer/dictionary
 	rm -rf nodist/obj_dir
 
 distclean maintainer-clean::

README.adoc

@@ -4,7 +4,7 @@
 ifdef::env-github[]
 image:https://img.shields.io/badge/License-LGPL%20v3-blue.svg[license LGPLv3,link=https://www.gnu.org/licenses/lgpl-3.0]
 image:https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg[license Artistic-2.0,link=https://opensource.org/licenses/Artistic-2.0]
-image:https://api.codacy.com/project/badge/Grade/ff998fdaa6f64b9a95eb5f342ee6bf4d[Code Quality,link=https://www.codacy.com/manual/wsnyder/verilator]
+image:https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f[Code Quality,link=https://www.codacy.com/gh/verilator/verilator]
 image:https://travis-ci.com/verilator/verilator.svg?branch=master[Build Status (Travis CI),link=https://travis-ci.com/verilator/verilator]
 endif::[]
 
@@ -16,15 +16,16 @@ ifndef::env-github[]
 :link_verilator_contributing: https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.adoc
 :link_verilator_install: https://verilator.org/install
 endif::[]
+:link_verilator_commercial_support: https://verilator.org/verilator_commercial_support
 
 == Welcome to Verilator
 
 [cols="a,a",indent=0,frame="none"]
 |===
-^.^| *Welcome to Verilator, the fastest free Verilog HDL simulator.*
+^.^| *Welcome to Verilator, the fastest Verilog HDL simulator.*
 +++ <br/> +++ &bullet; Accepts synthesizable Verilog or SystemVerilog
 +++ <br/> +++ &bullet; Performs lint code-quality checks
-+++ <br/> +++ &bullet; Compiles into multithreaded {cpp}, SystemC, or (soon) {cpp}-under-Python
++++ <br/> +++ &bullet; Compiles into multithreaded {cpp}, or SystemC
 +++ <br/> +++ &bullet; Creates XML to front-end your own tools
 <.^|image:https://www.veripool.org/img/verilator_256_200_min.png[Logo,256,200]
 
@@ -38,18 +39,24 @@ endif::[]
 +++ <br/> +++ &bullet; Out-of-the-box support from Arm, and RISC-V vendor IP
 <.^|image:https://www.veripool.org/img/verilator_usage_400x200-min.png[,400,200]
 
->.^|image:https://www.veripool.org/img/chips_alliance_logo_225x75-min.png[CHIPS Alliance,link=https://chipsalliance.org]
-image:https://www.veripool.org/img/osi_logo_125x125-min.png[,125,125]
+>.^|image:https://www.veripool.org/img/verilator_community_400x125-min.png[,400,125]
 ^.^| *Community Driven & Openly Licensed*
 +++ <br/> +++ &bullet; Guided by the https://chipsalliance.org/[CHIPS Alliance] and https://www.linuxfoundation.org/[Linux Foundation]
 +++ <br/> +++ &bullet; Open, and free as in both speech and beer
 +++ <br/> +++ &bullet; More simulation for your verification budget
+
+^.^| *Commercial Support Available*
++++ <br/> +++ &bullet; Commercial support contracts
++++ <br/> +++ &bullet; Design support contracts
++++ <br/> +++ &bullet; Enhancement contracts
+<.^|image:https://www.veripool.org/img/verilator_support_400x125-min.png[,400,125]
+
 |===
 
 == What Verilator Does
 
 Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
-"Verilates" the specified synthesizable Verilog or SystemVerilog code by
+"Verilates" the specified Verilog or SystemVerilog code by
 reading it, performing lint checks, and optionally inserting assertion
 checks and coverage-analysis points.  It outputs single- or multi-threaded
 .cpp and .h files, the "Verilated" code.
@@ -65,30 +72,30 @@ Verilator may not be the best choice if you are expecting a full featured
 replacement for NC-Verilog, VCS or another commercial Verilog simulator, or
 if you are looking for a behavioral Verilog simulator e.g. for a quick
 class project (we recommend http://iverilog.icarus.com[Icarus Verilog] for
-this.)  However, if you are looking for a path to migrate synthesizable
-Verilog to {cpp} or SystemC, and your team is comfortable writing just a
+this.)  However, if you are looking for a path to migrate SystemVerilog to
+{cpp} or SystemC, and your team is comfortable writing just a
 touch of {cpp} code, Verilator is the tool for you.
 
 == Performance
 
-Verilator does not simply convert Verilog HDL to {cpp} or SystemC.  Rather
-than only translate, Verilator compiles your code into a much faster
-optimized and optionally thread-partitioned model, which is in turn wrapped
-inside a {cpp}/SystemC/Python module.  The results are a compiled Verilog
-model that executes even on a single-thread over 10x faster than standalone
-SystemC, and on a single thread is about 100 times faster than interpreted
-Verilog simulators such as http://iverilog.icarus.com[Icarus
+Verilator does not simply convert Verilog HDL to {cpp} or SystemC.  Rather,
+Verilator compiles your code into a much faster optimized and optionally
+thread-partitioned model, which is in turn wrapped inside a
+{cpp}/SystemC/{cpp}-under-Python module.  The results are a compiled
+Verilog model that executes even on a single-thread over 10x faster than
+standalone SystemC, and on a single thread is about 100 times faster than
+interpreted Verilog simulators such as http://iverilog.icarus.com[Icarus
 Verilog]. Another 2-10x speedup might be gained from multithreading
 (yielding 200-1000x total over interpreted simulators).
 
-Verilator has typically similar or better performance versus the commercial
-Verilog simulators (Carbon Design Systems Carbonator, Modelsim, Cadence
-Incisive/NC-Verilog, Synopsys VCS, VTOC, and Pragmatic CVer/CVC). But,
-Verilator is free, so you can spend on computes rather than licenses. Thus
-Verilator gives you more cycles/dollar than anything else available.
+Verilator has typically similar or better performance versus the
+closed-source Verilog simulators (Carbon Design Systems Carbonator,
+Modelsim, Cadence Incisive/NC-Verilog, Synopsys VCS, VTOC, and Pragmatic
+CVer/CVC). But, Verilator is open-sourced, so you can spend on computes
+rather than licenses. Thus Verilator gives you the best cycles/dollar.
 
 For more information on how Verilator stacks up to some of the other
-commercial and free Verilog simulators, see the
+closed-sourced and open-sourced Verilog simulators, see the
 https://www.veripool.org/verilog_sim_benchmarks.html[Verilog Simulator
 Benchmarks].  (If you benchmark Verilator, please see the notes in the
 https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)], and also
@@ -109,7 +116,7 @@ or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)]
 
 * https://verilator.org/issues[Verilator Issues]
 
-== Community Supported
+== Support
 
 Verilator is a community project, guided by the
 https://chipsalliance.org/[CHIPS Alliance] under the
@@ -120,6 +127,10 @@ We appreciate and welcome your contributions in whatever form; please see
 https://verilator.org/verilator_doc.html#CONTRIBUTORS[Contributors and
 Sponsors].
 
+Verilator also supports and encourages commercial support models and
+organizations; please see {link_verilator_commercial_support}[Verilator
+Commercial Support].
+
 == Related Projects
 
 * http://gtkwave.sourceforge.net/[GTKwave] - Waveform viewer for Verilator
@@ -131,10 +142,10 @@ perhaps Icarus may.
 
 == Open License
 
-Verilator is Copyright 2003-2019 by Wilson Snyder.  (Report bugs to
+Verilator is Copyright 2003-2020 by Wilson Snyder.  (Report bugs to
 https://verilator.org/issues[Verilator Issues].)
 
 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.)
+Perl Artistic License Version 2.0.  See the documentation for more
+details.

bin/verilator_coverage

@@ -1,18 +1,11 @@
-: # -*-Mode: perl;-*- use perl, wherever it is
-eval 'exec perl -wS $0 ${1+"$@"}'
-  if 0;
+#!/usr/bin/env perl
 ######################################################################
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
 # can redistribute it and/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;
@@ -271,10 +264,12 @@ Specifies a module search directory.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2019 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.
+Copyright 2003-2020 by Wilson Snyder. This program 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.
+
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 =head1 AUTHORS
 

bin/verilator_difftree

@@ -1,10 +1,7 @@
-: # -*-Mode: perl;-*- use perl, wherever it is
-eval 'exec perl -wS $0 ${1+"$@"}'
-  if 0;
+#!/usr/bin/env perl
 # See copyright, etc in below POD section.
 ######################################################################
 
-require 5.006_001;
 use warnings;
 use Getopt::Long;
 use IO::File;
@@ -236,9 +233,12 @@ Do not show differences in line numbering.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2005-2019 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.
+Copyright 2005-2020 by Wilson Snyder. This program is free software; you
+can redistribute it and/or modify it under the terms of either the GNU
+Lesser General Public License Version 3 or the Perl Artistic License
+Version 2.0.
+
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 =head1 AUTHORS
 

bin/verilator_gantt

@@ -1,11 +1,9 @@
-: # -*-Mode: perl;-*- use perl, wherever it is
-eval 'exec perl -wS $0 ${1+"$@"}'
-  if 0;
+#!/usr/bin/env perl
 # See copyright, etc in below POD section.
 ######################################################################
 
-use strict;
 use warnings;
+use strict;
 use Getopt::Long;
 use IO::File;
 use Pod::Usage;
@@ -125,13 +123,13 @@ sub report {
     }
 
     my $nthreads = scalar keys %Threads;
-    $Global{cpus}{cpu_time} = {};
+    $Global{cpus} = {};
     foreach my $thread (keys %Threads) {
         # Make potentially multiple characters per column
         foreach my $start (keys %{$Threads{$thread}}) {
             my $cpu = $Threads{$thread}{$start}{cpu};
             my $elapsed = $Threads{$thread}{$start}{end} - $start;
-            $Global{cpus}{cpu_time}{$cpu} += $elapsed;
+            $Global{cpus}{$cpu}{cpu_time} += $elapsed;
         }
     }
 
@@ -540,9 +538,12 @@ verilator_gantt.vcd.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2018-2019 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.
+Copyright 2018-2020 by Wilson Snyder. This program is free software; you
+can redistribute it and/or modify it under the terms of either the GNU
+Lesser General Public License Version 3 or the Perl Artistic License
+Version 2.0.
+
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 =head1 AUTHORS
 

bin/verilator_includer

@@ -1,11 +1,11 @@
-: # -*-Mode: perl;-*- use perl, wherever it is
-eval 'exec perl -wS $0 ${1+"$@"}'
-  if 0;
+#!/usr/bin/env perl
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2019 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.
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 ######################################################################
 
 require 5.005;

bin/verilator_profcfunc

@@ -1,6 +1,4 @@
-: # -*-Mode: perl;-*- use perl, wherever it is
-eval 'exec perl -wS $0 ${1+"$@"}'
-  if 0;
+#!/usr/bin/env perl
 # See copyright, etc in below POD section.
 ######################################################################
 
@@ -230,9 +228,12 @@ Displays this message and program version and exits.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2007-2019 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.
+Copyright 2007-2020 by Wilson Snyder. This program is free software; you
+can redistribute it and/or modify it under the terms of either the GNU
+Lesser General Public License Version 3 or the Perl Artistic License
+Version 2.0.
+
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 =head1 AUTHORS
 

ci/build_vcddiff.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# DESCRIPTION: Verilator: Build script for vcddiff
+#
+# Copyright 2019 by Todd Strader. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+set -e
+
+# NB: it would be better to add this via a PPA
+
+TMP_DIR=$(mktemp -d)
+
+git -C "${TMP_DIR}" clone https://github.com/veripool/vcddiff
+VCDDIFF_DIR=${TMP_DIR}/vcddiff
+git -C "${VCDDIFF_DIR}" checkout 5112f88b7ba8818dce9dfb72619e64a1fc19542c
+make -C "${VCDDIFF_DIR}"
+sudo cp "${VCDDIFF_DIR}/vcddiff" /usr/local/bin

ci/build_verilator.sh

@@ -1,10 +1,11 @@
 #!/bin/bash
 # DESCRIPTION: Verilator: Travis CI build script
 #
-# Copyright 2019 by Todd Strader. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2019 by Todd Strader. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 # This script builds and caches the Verilator binaries for Travis CI
 # (and possibly other CI platforms).  The Verilator CI system uses this

ci/docker/buildenv/Dockerfile

@@ -0,0 +1,58 @@
+# DESCRIPTION: Dockerfile for env to build and fully test Verilator
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+FROM ubuntu:18.04
+
+RUN apt-get update \
+    && DEBIAN_FRONTEND=noninteractive \
+       apt-get install --no-install-recommends -y \
+                        autoconf=2.69-11 \
+                        bc=1.07.1-2 \
+                        bison=2:3.0.4.dfsg-1build1 \
+                        build-essential=12.4ubuntu1 \
+                        ca-certificates=20180409 \
+                        cmake=3.10.2-1ubuntu2.18.04.1 \
+                        flex=2.6.4-6 \
+                        gdb=8.1-0ubuntu3.2 \
+                        gcc-6=6.5.0-2ubuntu1~18.04 \
+                        gcc-5=5.5.0-12ubuntu1 \
+                        gcc-4.8=4.8.5-4ubuntu8 \
+                        git=1:2.17.1-1ubuntu0.5 \
+                        gtkwave=3.3.86-1 \
+                        g++-6=6.5.0-2ubuntu1~18.04 \
+                        g++-5=5.5.0-12ubuntu1 \
+                        g++-4.8=4.8.5-4ubuntu8 \
+                        libfl2=2.6.4-6 \
+                        libfl-dev=2.6.4-6 \
+                        numactl=2.0.11-2.1ubuntu0.1 \
+                        perl=5.26.1-6ubuntu0.3 \
+                        python3=3.6.7-1~18.04 \
+                        wget=1.19.4-1ubuntu2.2 \
+                        zlibc=0.9k-4.3 \
+                        zlib1g=1:1.2.11.dfsg-0ubuntu2 \
+                        zlib1g-dev=1:1.2.11.dfsg-0ubuntu2 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /tmp
+
+COPY build-systemc.sh /tmp/
+RUN ./build-systemc.sh
+
+RUN cpan install -fi Unix::Processors Parallel::Forker Bit::Vector
+
+RUN git clone https://github.com/veripool/vcddiff.git && \
+    make -C vcddiff && \
+    cp -p vcddiff/vcddiff /usr/local/bin/vcddiff && \
+    rm -rf vcddiff
+
+COPY build.sh /tmp/build.sh
+
+ENV VERILATOR_AUTHOR_SITE=1
+
+ENTRYPOINT [ "/tmp/build.sh" ]

ci/docker/buildenv/README.adoc

@@ -0,0 +1,49 @@
+= Verilator Docker Build Environment
+
+This Verilator Build container is set up to compile and test a Verilator
+build. It uses the following parameters:
+
+* Source repository (default: https://github.com/verilator/verilator)
+* Source revision (default: master)
+* GCC version (4.8.5, 5.5.0, 6.5.0, 7.4.0, default: 7.4.0)
+
+The container is published as `verilator/verilator-buildenv` on
+https://hub.docker.com/repository/docker/verilator/verilator-buildenv[docker hub].
+
+To run the basic build using the current Verilator master:
+
+    docker run -ti verilator/verilator-buildenv
+
+To also run tests:
+
+    docker run -ti verilator/verilator-buildenv test
+
+To change the compiler:
+
+    docker run -ti -e CC=gcc-4.8 -e CXX=g++-4.8 verilator/verilator-buildenv test
+
+The tests that involve gdb are not working due to security restrictions.
+To run those too:
+
+....
+docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` -e CC=gcc-4.8 -e CXX=g++-4.8 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
+....
+
+Rather then building using a remote git repository you may prefer to use a
+working copy on the local filesystem. Mount the local working copy path as
+a volume and use that in place of git. When doing this be careful to have
+all changes committed to the local git area. To build the current HEAD from
+top of a repository:
+
+....
+docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
+....
+
+== Rebuilding
+
+To rebuild the Verilator-buildenv docker image, run:
+
+    docker build .
+
+This will also build SystemC under all supported compiler variants to
+reduce the SystemC testing time.

ci/docker/buildenv/build-systemc.sh

@@ -0,0 +1,30 @@
+#!/bin/bash -e
+# DESCRIPTION: Build SystemC in Ubuntu 18.04 with  different g++/gcc
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+build_variant () {
+    version=$($1 --version | grep gcc | awk '{print $4}')
+    mkdir "/usr/local/systemc-2.3.3-gcc$version"
+    mkdir build
+    cd build
+    ../configure --prefix="/usr/local/systemc-2.3.3-gcc$version" CC="$1" CXX="$2" LD="$2"
+    make -j
+    make install
+    cd ..
+    rm -r build
+}
+
+wget https://www.accellera.org/images/downloads/standards/systemc/systemc-2.3.3.tar.gz
+tar -xzf systemc-2.3.3.tar.gz
+cd systemc-2.3.3
+build_variant gcc g++
+build_variant gcc-6 g++-6
+build_variant gcc-5 g++-5
+build_variant gcc-4.8 g++-4.8
+cd ..
+rm -r systemc-2.3.3*

ci/docker/buildenv/build.sh

@@ -0,0 +1,31 @@
+#!/bin/bash -e
+# DESCRIPTION: Build Verilator (inside container)
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+: "${REPO:=https://github.com/verilator/verilator}"
+: "${REV:=master}"
+: "${CC:=gcc}"
+: "${CXX:=g++}"
+
+GCCVERSION=$(${CC} --version | grep gcc | awk '{print $4}')
+
+export SYSTEMC_INCLUDE="/usr/local/systemc-2.3.3-gcc${GCCVERSION}/include"
+export SYSTEMC_LIBDIR="/usr/local/systemc-2.3.3-gcc${GCCVERSION}/lib-linux64"
+export LD_LIBRARY_PATH=${SYSTEMC_LIBDIR}
+
+SRCS=$PWD/verilator
+
+git clone "$REPO" "$SRCS"
+cd "$SRCS"
+git checkout "$REV"
+autoconf
+./configure --enable-longtests
+make -j $(nproc)
+if [ "${1:-''}" == "test" ]; then
+    make test
+fi

ci/docker/run/Dockerfile

@@ -0,0 +1,50 @@
+# DESCRIPTION: Dockerfile for image to run Verilator inside
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+FROM ubuntu:18.04
+
+RUN apt-get update \
+    && apt-get install --no-install-recommends -y \
+                        autoconf=2.69-11 \
+                        bc=1.07.1-2 \
+                        bison=2:3.0.4.dfsg-1build1 \
+                        build-essential=12.4ubuntu1 \
+                        ca-certificates=20180409 \
+                        ccache \
+                        flex=2.6.4-6 \
+                        git \
+                        libfl-dev=2.6.4-6 \
+                        libgoogle-perftools-dev \
+                        perl \
+                        python3 \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+ARG REPO=https://github.com/verilator/verilator
+ARG SOURCE_COMMIT=master
+
+WORKDIR /tmp
+
+# Add an exception for the linter, we want to cd here in one layer
+# to reduce the number of layers (and thereby size).
+# hadolint ignore=DL3003
+RUN git clone "${REPO}" verilator && \
+    cd verilator && \
+    git checkout "${SOURCE_COMMIT}" && \
+    autoconf && \
+    ./configure && \
+    make -j "$(nproc)" && \
+    make install && \
+    cd .. && \
+    rm -r verilator
+
+COPY verilator-wrap.sh /usr/local/bin/verilator-wrap.sh
+
+WORKDIR /work
+
+ENTRYPOINT [ "/usr/local/bin/verilator-wrap.sh" ]

ci/docker/run/README.adoc

@@ -0,0 +1,59 @@
+= Verilator Executable Docker Container
+
+The Verilator Executable Docker Container allows you to run Verilator
+easily as a docker image, e.g.:
+
+    docker run -ti verilator/verilator:latest --version
+
+This will install the container, run the latest Verilator and print
+Verilator's version.
+
+Containers are automatically built for all released versions, so you may
+easily compare results across versions, e.g.:
+
+    docker run -ti verilator/verilator:4.030 --version
+
+Verilator needs to read and write files on the local system.  To simplify
+this process, use the `verilator-docker` convenience script.  This script
+takes the version number, and all remaining arguments are passed through to
+Verilator. e.g.:
+
+    ./verilator-docker 4.030 --version
+
+or
+
+    ./verilator-docker 4.030 --cc test.v
+
+If you prefer not to use `verilator-docker` you must give the container
+access to your files as a volume with appropriate user rights.  For example
+to Verilate test.v:
+
+....
+docker run -ti -v ${PWD}:/work --user $(id -u):$(id -g) verilator/verilator:latest --cc test.v
+....
+
+This method can only access files below the current directory. An
+alternative is setup the volume `-workdir`.
+
+You can also work in the container by setting the entrypoint
+(don't forget to mount a volume if you want your work persistent):
+
+    docker run -ti --entrypoint /bin/bash verilator/verilator:latest
+
+You can also use the container to build Verilator at a specific
+commit:
+
+    docker build --build-arg SOURCE_COMMIT=<commit> .
+
+== Internals
+
+The Dockerfile builds Verilator and removes the tree when completed to
+reduce the image size. The entrypoint is set as a wrapper script
+(`verilator-wrap.sh`).  That script 1. calls Verilator, and 2. copies the
+Verilated runtime files to the `obj_dir` or the `-Mdir` respectively. This
+allows the user to have the files to they may later build the C++ output
+with the matching runtime files. The wrapper also patches the Verilated
+Makefile accordingly.
+
+There is also a hook defined that is run by docker hub via automated
+builds.

ci/docker/run/hooks/build

@@ -0,0 +1,10 @@
+#!/bin/bash
+# DESCRIPTION: Docker hub hook to pass SOURCE_COMMIT
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+docker build --build-arg SOURCE_COMMIT=${SOURCE_COMMIT} -f $DOCKERFILE_PATH -t $IMAGE_NAME .

ci/docker/run/hooks/post_push

@@ -0,0 +1,13 @@
+#!/bin/bash
+# DESCRIPTION: Docker hub hook to tag the latest release (stable)
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+if [ "$SOURCE_BRANCH"="stable" ]; then
+    docker tag $IMAGE_NAME $DOCKER_REPO:latest
+    docker push $DOCKER_REPO:latest
+fi

ci/docker/run/verilator-docker

@@ -0,0 +1,11 @@
+#!/bin/bash
+# DESCRIPTION: Wrap a verilator call to run a docker container
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+docker pull verilator/verilator:$1 >/dev/null
+docker run -ti -v ${PWD}:/work --user $(id -u):$(id -g) verilator/verilator:$1 "${@:2}"

ci/docker/run/verilator-wrap.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# DESCRIPTION: Wrap a Verilator call and copy vlt includes
+#              (inside docker container)
+#
+# Copyright 2020 by Stefan Wallentowitz. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+perl /usr/local/bin/verilator "$@"
+status=$?
+if [ $status -ne 0 ]; then
+    exit $status
+fi
+
+# Check if user set an obj_dir
+obj_dir=$(echo " $@" | grep -oP '\s--Mdir\s*\K\S+')
+if [ "$obj_dir" == "" ]; then
+    obj_dir="obj_dir"
+fi
+
+# If the run was successful: Copy required files to allow build without this container
+if [ -e ${obj_dir} ]; then
+    # Copy files required for the build
+    mkdir -p ${obj_dir}/vlt
+    cp -r /usr/local/share/verilator/bin ${obj_dir}/vlt
+    cp -r /usr/local/share/verilator/include ${obj_dir}/vlt
+    # Point Makefile to that folder
+    perl -i -pe 's/VERILATOR_ROOT = \/usr\/local\/share\/verilator/VERILATOR_ROOT = vlt/g' ${obj_dir}/*.mk
+fi

ci/test.sh

@@ -1,10 +1,12 @@
 #!/bin/bash
 # DESCRIPTION: Verilator: Travis CI test script
 #
-# Copyright 2019 by Todd Strader. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2019 by Todd Strader. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
 set -e
 
 export DRIVER_FLAGS='-j 0 --quiet --rerun'
@@ -19,6 +21,12 @@ case $1 in
     vltmt)
         make -C test_regress SCENARIOS=--vltmt
         ;;
+    vltmt0)
+        make -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
+        ;;
+    vltmt1)
+        make -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
+        ;;
     *)
     echo "Usage: test.sh (dist|vlt|vltmt)"
     exit -1

configure.ac

@@ -1,12 +1,13 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2019 by Wilson Snyder. Verilator is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU Lesser
+# Copyright 2003-2020 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.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[4.022 2019-11-10],
+AC_INIT([Verilator],[4.034 2020-05-03],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 # When releasing, also update header of Changes file
@@ -25,11 +26,43 @@ AC_ARG_ENABLE([maintainer-mode],
 AC_ARG_ENABLE([silent-rules],
               [AS_HELP_STRING([--disable-silent-rules], [ignored])])
 
+# Flag to enable linking specific libraries statically
+AC_MSG_CHECKING(whether to perform partial static linking of Verilator binary)
+AC_ARG_ENABLE([partial-static],
+              [AS_HELP_STRING([--disable-partial-static],
+                              [By default, for Verilation peformance, Verilator
+                               is linked against some of its dependencies
+                               statically. Use this to link the Verilator binary
+                               fully dynamically.])],
+              [case "${enableval}" in
+                yes) CFG_ENABLE_PARTIAL_STATIC=yes ;;
+                no)  CFG_ENABLE_PARTIAL_STATIC=no ;;
+                *)   AC_MSG_ERROR([bad value '${enableval}' for --disable-partial-static]) ;;
+               esac],
+               CFG_ENABLE_PARTIAL_STATIC=yes)
+AC_MSG_RESULT($CFG_ENABLE_PARTIAL_STATIC)
+
+# Flag to enable linking Verilator with tcmalloc if available
+AC_MSG_CHECKING(whether to use tcmalloc)
+AC_ARG_ENABLE([tcmalloc],
+              [AS_HELP_STRING([--enable-tcmalloc],
+                              [Use libtcmalloc_minimal for faster dynamic memory
+                               management in Verilator binary@<:@default=check@:>@])],
+              [case "${enableval}" in
+                yes) CFG_WITH_TCMALLOC=yes ;;
+                no)  CFG_WITH_TCMALLOC=no ;;
+                *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-tcmalloc]) ;;
+               esac],
+              [CFG_WITH_TCMALLOC=check;])
+AC_MSG_RESULT($CFG_WITH_TCMALLOC)
+
 # Special Substitutions - CFG_WITH_DEFENV
 AC_MSG_CHECKING(whether to use hardcoded paths)
 AC_ARG_ENABLE([defenv],
               [AS_HELP_STRING([--disable-defenv],
-                              [disable using some hardcoded data paths extracted from some default environment variables (the default is to use hardcoded paths)])],
+                              [disable using some hardcoded data paths extracted
+                              from some default environment variables (the default
+                              is to use hardcoded paths) in Verilator binary])],
               [case "${enableval}" in
                 yes) CFG_WITH_DEFENV=yes ;;
                 no)  CFG_WITH_DEFENV=no ;;
@@ -43,7 +76,8 @@ AC_MSG_RESULT($CFG_WITH_DEFENV)
 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])],
+                              [enable showing and stopping on compilation warnings
+                               in Verilator binrary and Verilated makefiles])],
               [case "${enableval}" in
                 yes) CFG_WITH_CCWARN=yes ;;
                 no)  CFG_WITH_CCWARN=no ;;
@@ -79,7 +113,8 @@ AC_MSG_RESULT($CFG_WITH_LONGTESTS)
 AC_MSG_CHECKING(whether allow pre-C++11)
 AC_ARG_ENABLE([prec11],
               [AS_HELP_STRING([--enable-prec11],
-                              [enable pre-C++11 compilers])],
+                              [enable pre-C++11 compilers for Verilator binary
+                               and Verilated makefiles])],
               [case "${enableval}" in
                 yes) CFG_WITH_PREC11=yes ;;
                 no)  CFG_WITH_PREC11=no ;;
@@ -124,6 +159,12 @@ if test "x$YACC" = "x" ; then
    AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
 fi
 
+AC_CHECK_PROG(OBJCACHE,ccache,ccache)
+if test "x$OBJCACHE" != "x" ; then
+  objcache_version=$($OBJCACHE --version | head -1)
+  AC_MSG_RESULT([objcache is $OBJCACHE --version = $objcache_version])
+fi
+
 # Checks for libraries.
 
 # Checks for typedefs, structures
@@ -209,15 +250,26 @@ AC_DEFUN([_MY_LDLIBS_CHECK_FLAG],
     LIBS="$ACO_SAVE_LIBS"
    ])
 
-AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
-   [# _MY_LDLIBS_CHECK_OPT(flag) -- Check if linker supports specific options
-    # If it does, append flag to variable
-    _MY_LDLIBS_CHECK_FLAG($2)
+AC_DEFUN([_MY_LDLIBS_CHECK_IFELSE],
+   [# _MY_LDLIBS_CHECK_IFELSE(flag,action-if-supported,action-if-not-supported)
+    # Check if linker supports specific flag, if it does do action-if-supported
+    # otherwise do action-if-not-supported
+    _MY_LDLIBS_CHECK_FLAG($1)
     if test "$_my_result" = "yes" ; then
-       $1="$$1 $2"
+      true
+      $2
+    else
+      true
+      $3
     fi
    ])
 
+AC_DEFUN([_MY_LDLIBS_CHECK_OPT],
+   [# _MY_LDLIBS_CHECK_OPT(variable, flag) -- Check if linker supports specific
+    # options. If it does, append flag to variable.
+    _MY_LDLIBS_CHECK_IFELSE($2, $1="$$1 $2")
+   ])
+
 # Flag to select newest language standard supported
 # Macros work such that first option that passes is the one we take
 # gnu++17 code is clean, but SystemC in 2018 doesn't link with it (bug1339)
@@ -256,7 +308,6 @@ AC_SUBST(CFG_CXXFLAGS_WEXTRA)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-undefined-bool-conversion)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
 AC_SUBST(CFG_CXXFLAGS_SRC)
 
@@ -283,6 +334,7 @@ m4_foreach([cflag],[
         [-mno-cet],
         [-Qunused-arguments],
         [-Wno-bool-operation],
+        [-Wno-tautological-bitwise-compare],
         [-Wno-parentheses-equality],
         [-Wno-sign-compare],
         [-Wno-uninitialized],
@@ -310,6 +362,44 @@ m4_foreach([ldflag], [
 AC_SUBST(CFG_LDLIBS_THREADS)
 AC_SUBST(CFG_LDFLAGS_THREADS_CMAKE)
 
+# When linking partially statically
+if test "$CFG_ENABLE_PARTIAL_STATIC" = "yes"; then
+  _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -static-libgcc)
+  _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -static-libstdc++)
+  _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -Xlinker -gc-sections)
+  LTCMALLOC=-l:libtcmalloc_minimal.a
+else
+  LTCMALLOC=-ltcmalloc_minimal
+fi
+AC_SUBST(CFG_LDFLAGS_SRC)
+
+# The pthread library is required by tcmalloc, so add it if it exists. If it
+# does not, the tcmalloc check below will fail anyway, and linking against
+# pthreads is harmless otherwise.
+CFG_LIBS="$LIBS $CFG_LIBS"
+_MY_LDLIBS_CHECK_OPT(CFG_LIBS, -lpthread)
+
+# Check libraries for MingW
+_MY_LDLIBS_CHECK_OPT(CFG_LIBS, -lbcrypt)
+_MY_LDLIBS_CHECK_OPT(CFG_LIBS, -lpsapi)
+
+# Check if tcmalloc is available based on --enable-tcmalloc
+_MY_LDLIBS_CHECK_IFELSE(
+  $LTCMALLOC,
+  [if test "$CFG_WITH_TCMALLOC" != "no"; then
+    CFG_LIBS="$LTCMALLOC $CFG_LIBS";
+    # If using tcmalloc, add some extra options to make the compiler not assume
+    # it is using it's own versions of the standard library functions
+    _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-malloc)
+    _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-calloc)
+    _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-realloc)
+    _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-free)
+   fi],
+  [if test "$CFG_WITH_TCMALLOC" = "yes"; then
+    AC_MSG_ERROR([--enable-tcmalloc was given but test for ${LTCMALLOC} failed])
+   fi])
+AC_SUBST(CFG_LIBS)
+
 # Set CFG_WITH_THREADED if can support threading
 AC_MSG_CHECKING(whether $CXX supports Verilated threads)
 ACO_SAVE_CXXFLAGS="$CXXFLAGS"

docs/CONTRIBUTING.adoc

@@ -11,7 +11,7 @@ contributions flow more efficiently.
   https://verilator.org/issues[Verilator Issues].
 
 * If you're unable to find an open issue addressing the problem,
-  https://verilator.org/issues/new[open a new issue].
+  https://verilator.org/issues/new[open a new Verilator issue].
 
 ** Be sure to include a **code sample** or an **executable test case**
    demonstrating the bug and expected behavior that is not occurring.
@@ -24,8 +24,8 @@ contributions flow more efficiently.
 
 * Please https://verilator.org/issues/new[Open a new issue].
 
-* You may attach a patch to the issue, or (preferred) may point to a GitHub
-  repository branch within your GitHub account.
+* You may attach a patch to the issue, or (preferred) may request a GitHub
+  pull request.
 
 ** Verilator uses Travis CI to provide continuous integration. You may
    want to setup Travis CI on your GitHub branch to ensure your changes
@@ -50,13 +50,13 @@ contributions flow more efficiently.
    link:CONTRIBUTORS[docs/CONTRIBUTORS] and you are agreeing all future
    contributions are also certified.
 
-** We occasionally accept contributions where people do not want their
-   name published. Please email us; you must still certify your
-   contribution using email.
+** We occasionally accept contributions where people do not want their name
+   published. Please email us; you must still privately certify your
+   contribution.
 
-* Your test contributions are generally considered released into the public
-  domain, unless you request otherwise or put a GNU/Artistic license on
-  your test file.
+* Your test contributions are generally considered released into the
+  Creative Commons Public Domain (CC0), unless you request otherwise or put
+  a GNU/Artistic license on your file.
 
 * Most important is we get your patch. If you'd like to clean up
   indentation and related issues ahead of our feedback, that is

docs/CONTRIBUTORS

@@ -1,28 +1,49 @@
 The contributors listed below have certified their Verilator contributions
-under the Developer Certificate of Origin
-(https://developercertificate.org/).
+under the Developer Certificate of Origin (https://developercertificate.org/).
 
-Please see the Verilator manual for additional contributors.
+Please see the Verilator manual for 200+ additional contributors. Thanks to all.
 
 Ahmed El-Mahmoudy
 Alex Chadwick
 Chris Randall
+David Stanford
+Driss Hafdi
 Eric Rippey
+Garrett Smith
+Geza Lore
 Gianfranco Costamagna
 Howard Su
 Iztok Jeras
+James Hanlon
 Jeremy Bennett
 John Coiner
+John Demme
+Julien Margetts
 Kanad Kanhere
 Kevin Kiningham
+Kuba Ober
 Lukasz Dalek
 Maarten De Braekeleer
+Maciej Sobkowski
+Marco Widmer
+Matthew Ballance
 Mike Popoloski
+Nathan Kohagen
+Nathan Myers
 Patrick Stewart
+Peter Horvath
+Peter Monsson
 Philipp Wagner
+Pieter Kapsenberg
+Qingyao Sun
 Richard Myers
+Sean Cross
 Sebastien Van Cauwenberghe
 Stefan Wallentowitz
+Tobias Rosenkranz
+Tobias Wölfel
 Todd Strader
+Veripool API Bot
 Wilson Snyder
+Yutetsu TAKATSUKASA
 Yves Mathieu

docs/Makefile.in

@@ -7,15 +7,11 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/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.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 #****************************************************************************/
 #

docs/TODO

@@ -1,9 +1,10 @@
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2004-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
 * Language support:
 ** Fix ordering of each bit separately in a signal (mips)
@@ -22,17 +23,10 @@
 ** Assertions
 ** Tristate support
 
-* Configure/Make/Install
-** 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
-** // verilator debug in code so can see only tree affecting those nodes
 
 * Usability:
 ** Detect and pre-remove most UNOPTFLATs

docs/doxygen-mainpage

@@ -3,4 +3,4 @@
  * \section intro_sec Introduction
  *
  * This is a full doxygen analysis of the Verilator source tree.
- */
+ */

docs/install.adoc

@@ -21,9 +21,14 @@ Git, below, maybe a better alternative.) To install as a package:
 
 If this works, skip down to <<Running Verilator>>.
 
+=== Docker
+
+Verilator is available in pre-built Docker containers. See
+https://github.com/verilator/verilator/blob/master/ci/docker/run/README.adoc
+
 === Git
 
-Alternatively, installing Verilator with Git provides the most flexibility.
+Installing Verilator with Git provides the most flexibility.
 For additional options and details see the additional sections below.  In
 brief:
 
@@ -73,13 +78,7 @@ MSVC++.
 
 === Install Prerequisites
 
-To build Verilator you will need to install some standard packages:
-
-   sudo apt-get install git
-   sudo apt-get install autoconf
-   sudo apt-get install flex bison
-
-Additionally, to build or run Verilator you need these standard packages:
+To build or run Verilator you need these standard packages:
 
    sudo apt-get install perl python3
    sudo apt-get install make
@@ -87,20 +86,34 @@ Additionally, to build or run Verilator you need these standard packages:
    sudo apt-get install libgz  # Non-Ubuntu (ignore if gives error)
    sudo apt-get install libfl2 libfl-dev zlibc zlib1g zlib1g-dev  # Ubuntu only (ignore if gives error)
 
-Those developing Verilator may also want these (see internals.adoc):
+To build or run the following are optional but should be installed for
+good performance:
 
-   sudo apt-get install gdb asciidoctor graphviz
+   sudo apt-get install ccache  # If present at build, needed for run
+   sudo apt-get install libgoogle-perftools-dev numactl
+
+To build Verilator you will need to install these packages; these do not
+need to be present to run Verilator:
+
+   sudo apt-get install git
+   sudo apt-get install autoconf flex bison
+
+Those developing Verilator itself may also want these (see internals.adoc):
+
+   sudo apt-get install gdb asciidoctor graphviz cmake clang-format
    cpan install Pod::Perldoc
    cpan install Unix::Processors
+   cpan install Parallel::Forker
+   cpan install Bit::Vector
 
 ==== Install SystemC
 
 If you will be using SystemC (vs straight C++ output), download
-http://www.systemc.org[SystemC].  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.)
+https://www.accellera.org/downloads/standards/systemc[SystemC].
+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.)
 
 ==== Install GTKWave
 
@@ -289,6 +302,7 @@ or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].
 
 == License
 
-Copyright 2008-2019 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2020 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

docs/internals.adoc

@@ -70,7 +70,10 @@ The AST is represented at the top level by the class `AstNode`. This
 abstract class has derived classes for the individual components
 (e.g. `AstGenerate` for a generate block) or groups of components
 (e.g. `AstNodeFTask` for functions and tasks, which in turn has `AstFunc`
-and `AstTask` as derived classes).
+and `AstTask` as derived classes). An important property of the `AstNode`
+type hierarchy is that all non-final subclasses of `AstNode` (i.e.: those
+which themselves have subclasses) must be abstract as well, and be named
+with the prefix `AstNode*`. The `astgen` (see below) script relies on this.
 
 Each `AstNode` has pointers to up to four children, accessed by the `op1p`
 through `op4p` methods.  These methods are then abstracted in a specific
@@ -382,12 +385,19 @@ changed; if clear, checking those signals for changes may be skipped.
 
 == Coding Conventions
 
+=== Compiler Version and C++11
+
+Verilator supports GCC 4.4.7 and newer.  GCC 4.4.7 does not support C++11,
+therefore C++11 is generally not required.  Exceptions may be made to
+require C++11 for features that are only practical with C++11,
+e.g. threads.
+
 === Indentation and Naming Style
 
 We will work with contributors to fix up indentation style issues, but it
 is appreciated if you could match our style:
 
-* All files should contain the magic header to insure standard indentation:
+* All files should contain the magic header to ensure standard indentation:
 +
    // -*- mode: C++; c-file-style: "cc-mode" -*-
 +
@@ -395,6 +405,15 @@ 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.)
 
+* Use "mixedCapsSymbols" instead of "underlined_symbols".
+
+* Uas a "p" suffix on variables that are pointers, e.g. "nodep".
+
+* Comment every member variable.
+
+Indentation is automatically maintained with "make clang-format" (using
+clang-format version 10.0.0).  For those manually formatting:
+
 * Use 4 spaces per level, and no tabs.
 
 * Use 2 spaces between the end of source and the beginning of a comment.
@@ -404,12 +423,6 @@ style indentation; the `c-set-style` undoes that.)
 * No spaces before semicolons, nor between a function's name and open
 parenthesis (only applies to functions; if/else has a following space).
 
-* Use "mixedCapsSymbols" instead of "underlined_symbols".
-
-* Uas a "p" suffix on variables that are pointers, e.g. "nodep".
-
-* Comment every member variable.
-
 === The `astgen` Script
 
 Some of the code implementing passes is extremely repetitive, and must be
@@ -615,13 +628,17 @@ with e.g. "sudo cpan install Parallel::Forker".
 * vcddiff to find differences in VCD outputs. See the readme at
 https://github.com/veripool/vcddiff
 
+* Cmake for build paths that use it.
+
+* Bit::Vector to test vgen.pl
+
 === 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
+   test_regress/driver.pl --help
 
 For convenience, a summary of the most commonly used features is provided
 here. All drivers require a call to `compile` subroutine to compile the
@@ -706,6 +723,13 @@ respectively 16,384 and 4,096. The method of doing this is system
 dependent, but on Fedora Linux it would require editing the
 `/etc/security/limits.conf` file as root.
 
+=== Manual Test Execution
+
+A specific regression test can be executed manually. To start the "EXAMPLE"
+test, run the following command.
+
+   test_regress/t/t_EXAMPLE.pl
+
 === Continuous Integration
 
 Verilator has a https://travis-ci.com/verilator/verilator[Travis CI environment]
@@ -952,7 +976,8 @@ 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.
 
-. If a new Ast type is needed, add it to V3AstNodes.h.
+. If a new Ast type is needed, add it to V3AstNodes.h. Follow the convention
+described above about the AstNode type hierarchy.
 
 . 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
@@ -973,6 +998,7 @@ list in `src/Makefile_obj.in` and reconfigure.
 
 == Distribution
 
-Copyright 2008-2019 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2020 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

docs/xml.adoc

@@ -0,0 +1,72 @@
+= Verilator XML Output
+:toc: right
+
+// Github doesn't render unless absolute URL
+image::https://www.veripool.org/img/verilator_256_200_min.png[Logo,256,200,role="right"]
+
+== Introduction
+
+This document describes Verilator's XML output. For more general information
+please see https://verilator.org[verilator.org].
+
+== General
+
+Verilator's XML output is enabled with the `--xml-only` flag. It contains
+limited information about the elaborated design including files, modules,
+instance hierarchy, logic and data types. There is no formal schema since part
+of the structure of the XML document matches the compiled code which would
+require the schema to describe legal SystemVerilog structure. The intended
+usage is to enable other downstream tools to take advantage of Verilator's
+parser.
+
+== Structure
+
+The XML document consists of 4 sections within the top level `verilator_xml`
+element:
+
+`<files>`...`</files>`::
+
+This section contains a list of all design files read, including the
+built-in constructs and the command line as their own entries.  Each
+`<file>` has an attribute `id` which is a short ASCII string unique to that
+file. Other elements' `loc` attributes use this id to refer to a particular
+file.
+
+`<module_files>`...`</module_files>`::
+
+All files containing Verilog module definitions are listed in this section.
+This element's contents is a subset of the `<files>` element's contents.
+
+`<cells>`...`</cells>`::
+
+The cells section of the XML document contains the design instance
+hierarchy.  Each instance is represented with the `<cell>` element with the
+following attributes:
+
+* `fl` (deprecated): The file id and line number where the module was
+  instanced.  Use `loc` instead.
+
+* `loc`: The file id, first line number, last line number, first column
+   number and last column number of the identifier where the module was
+   instanced, separated by commas.
+
+* `name`: The instance name.
+
+* `submodname`: The module name uniquified with particular parameter values (if any).
+
+* `hier`: The full hierarchy path.
+
+`<netlist>`...`</netlist>`::
+
+The netlist section contains a number of `<module>`...`</module>` elements,
+each describing the contents of that module, and a single `<typetable>`...
+`</typetable>` element which lists all used types used within the
+modules. Each type has a numeric `id` attribute that is referred to by
+elements in the `<module>` elements using the `dtype_id` attribute.
+
+== Distribution
+
+Copyright 2020-2020 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

examples/cmake_hello_c/CMakeLists.txt

@@ -5,10 +5,11 @@
 # This is an example cmake script to build a verilog to systemc project
 # using cmake and verilator.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 

examples/cmake_hello_c/Makefile

@@ -6,10 +6,11 @@
 # This makefile is here for testing the examples and should
 # generally not be added to a CMake project.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -50,11 +51,11 @@ run:
 	@echo "-- Verilator CMake hello world example"
 
 	@echo
-	@echo "-- CMake ----------------"
+	@echo "-- VERILATE ----------------"
 	mkdir -p build && cd build && cmake ..
 
 	@echo
-	@echo "-- COMPILE -----------------"
+	@echo "-- BUILD -------------------"
 	cmake --build build
 
 	@echo

examples/cmake_hello_sc/CMakeLists.txt

@@ -5,10 +5,11 @@
 # This is an example cmake script to build a verilog to SystemC project
 # using CMake and Verilator.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 

examples/cmake_hello_sc/Makefile

@@ -6,10 +6,11 @@
 # This makefile is here for testing the examples and should
 # generally not be added to a CMake project.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -86,11 +87,11 @@ run:
 	@echo "-- Verilator CMake SystemC hello-world simple example"
 
 	@echo
-	@echo "-- CMake ----------------"
+	@echo "-- VERILATE ----------------"
 	mkdir -p build && cd build && cmake ..
 
 	@echo
-	@echo "-- COMPILE -----------------"
+	@echo "-- BUILD -------------------"
 	cmake --build build
 
 	@echo

examples/cmake_protect_lib/CMakeLists.txt

@@ -5,10 +5,11 @@
 # This is an example cmake script to build a verilog to systemc project
 # using cmake and verilator.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 

examples/cmake_protect_lib/Makefile

@@ -6,10 +6,11 @@
 # This makefile is here for testing the examples and should
 # generally not be added to a CMake project.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -50,11 +51,11 @@ run:
 	@echo "-- Verilator CMake protect_lib example"
 
 	@echo
-	@echo "-- CMake ----------------"
+	@echo "-- VERILATE ----------------"
 	mkdir -p build && cd build && cmake ..
 
 	@echo
-	@echo "-- COMPILE -----------------"
+	@echo "-- BUILD -------------------"
 	cmake --build build
 
 	@echo

examples/cmake_tracing_c/CMakeLists.txt

@@ -5,10 +5,11 @@
 # This is an example cmake script to build a verilog to systemc project
 # using cmake and verilator.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -34,5 +35,5 @@ add_executable(example ../make_tracing_c/sim_main.cpp)
 # Add the Verilated circuit to the target
 verilate(example COVERAGE TRACE
   INCLUDE_DIRS "../make_tracing_c"
-  VERILATOR_ARGS -f ../make_tracing_c/input.vc -O2 -x-assign 0
+  VERILATOR_ARGS -f ../make_tracing_c/input.vc -Os -x-assign 0
   SOURCES ../make_tracing_c/top.v)

examples/cmake_tracing_c/Makefile

@@ -6,10 +6,11 @@
 # This makefile is here for testing the examples and should
 # generally not be added to a CMake project.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -50,11 +51,11 @@ run:
 	@echo "-- Verilator CMake tracing example"
 
 	@echo
-	@echo "-- CMake ----------------"
+	@echo "-- VERILATE ----------------"
 	mkdir -p build && cd build && cmake ..
 
 	@echo
-	@echo "-- COMPILE -----------------"
+	@echo "-- BUILD -------------------"
 	cmake --build build
 
 	@echo

examples/cmake_tracing_sc/CMakeLists.txt

@@ -5,10 +5,11 @@
 # This is an example cmake script to build a verilog to SystemC project
 # using CMake and Verilator.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -41,7 +42,7 @@ add_executable(example ../make_tracing_sc/sc_main.cpp)
 # Add the Verilated circuit to the target
 verilate(example SYSTEMC COVERAGE TRACE
   INCLUDE_DIRS "../make_tracing_sc"
-  VERILATOR_ARGS -f ../make_tracing_sc/input.vc -O2 -x-assign 0
+  VERILATOR_ARGS -f ../make_tracing_sc/input.vc -Os -x-assign 0
   SOURCES ../make_tracing_sc/top.v)
 
 verilator_link_systemc(example)

examples/cmake_tracing_sc/Makefile

@@ -6,10 +6,11 @@
 # This makefile is here for testing the examples and should
 # generally not be added to a CMake project.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -86,11 +87,11 @@ run:
 	@echo "-- Verilator CMake SystemC tracing example"
 
 	@echo
-	@echo "-- CMake ----------------"
+	@echo "-- VERILATE ----------------"
 	mkdir -p build && cd build && cmake ..
 
 	@echo
-	@echo "-- COMPILE -----------------"
+	@echo "-- BUILD -------------------"
 	cmake --build build
 
 	@echo

examples/make_hello_c/Makefile

@@ -5,10 +5,11 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -35,10 +36,8 @@ endif
 
 default:
 	@echo "-- Verilator hello-world simple example"
-	@echo "-- VERILATE ----------------"
-	$(VERILATOR) -cc --exe top.v sim_main.cpp
-	@echo "-- COMPILE -----------------"
-	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- VERILATE & BUILD --------"
+	$(VERILATOR) -cc --exe --build -j top.v sim_main.cpp
 	@echo "-- RUN ---------------------"
 	obj_dir/Vtop
 	@echo "-- DONE --------------------"

examples/make_hello_c/sim_main.cpp

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
 // Include common routines

examples/make_hello_c/top.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 
 // See also the EXAMPLE section in the verilator manpage/document.
 module top;

examples/make_hello_sc/Makefile

@@ -5,10 +5,11 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -44,10 +45,8 @@ endif
 
 run:
 	@echo "-- Verilator hello-world simple example"
-	@echo "-- VERILATE ----------------"
-	$(VERILATOR) -sc --exe top.v sc_main.cpp
-	@echo "-- COMPILE -----------------"
-	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
+	@echo "-- VERILATE & COMPILE ------"
+	$(VERILATOR) -sc --exe --build -j top.v sc_main.cpp
 	@echo "-- RUN ---------------------"
 	obj_dir/Vtop
 	@echo "-- DONE --------------------"

examples/make_hello_sc/sc_main.cpp

@@ -1,8 +1,9 @@
 // -*- SystemC -*-
 // DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
 // SystemC global header
@@ -28,16 +29,16 @@ int sc_main(int argc, char* argv[]) {
     Vtop* top = new Vtop("top");
 
     // Initialize SC model
-#if (SYSTEMC_VERSION>=20070314)
-    sc_start(1,SC_NS);
+#if (SYSTEMC_VERSION >= 20070314)
+    sc_start(1, SC_NS);
 #else
     sc_start(1);
 #endif
 
     // Simulate until $finish
     while (!Verilated::gotFinish()) {
-#if (SYSTEMC_VERSION>=20070314)
-        sc_start(1,SC_NS);
+#if (SYSTEMC_VERSION >= 20070314)
+        sc_start(1, SC_NS);
 #else
         sc_start(1);
 #endif

examples/make_hello_sc/top.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 
 // See also the EXAMPLE section in the verilator manpage/document.
 module top;

examples/make_protect_lib/Makefile

@@ -5,10 +5,11 @@
 # This calls the object directory makefiles.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2019 by Todd Strader. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2019 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -34,7 +35,7 @@ VERILATOR_FLAGS =
 # Generate C++
 VERILATOR_FLAGS += -cc
 # Optimize
-VERILATOR_FLAGS += -O2 -x-assign 0
+VERILATOR_FLAGS += -Os -x-assign 0
 # Warn abount lint issues; may not want this on less solid designs
 VERILATOR_FLAGS += -Wall
 # Make waveforms

examples/make_protect_lib/secret_impl.v

@@ -1,18 +1,21 @@
 // DESCRIPTION: Verilator: --protect-lib example secret module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2019 by Todd Strader.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2019 by Todd Strader.
+// SPDX-License-Identifier: CC0-1.0
 
 // This module will be used as libsecret.a or libsecret.so without
 // exposing the source.
-module secret_impl(
-		   input [31:0]        a,
-		   input [31:0]        b,
-		   output logic [31:0] x,
-		   input 	       clk);
 
-   logic [31:0] 		       accum_q = 0;
-   logic [31:0] 		       secret_value = 9;
+module secret_impl
+  (
+   input [31:0]        a,
+   input [31:0]        b,
+   output logic [31:0] x,
+   input               clk);
+
+   logic [31:0]        accum_q = 0;
+   logic [31:0]        secret_value = 9;
 
    initial $display("%m: initialized");
 

examples/make_protect_lib/sim_main.cpp

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: --protect-lib example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2019 by Todd Strader.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2019 by Todd Strader.
+// SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
 // See examples/tracing_c for notes on tracing
@@ -16,9 +17,7 @@
 #endif
 
 vluint64_t main_time = 0;
-double sc_time_stamp() {
-    return main_time;
-}
+double sc_time_stamp() { return main_time; }
 
 int main(int argc, char** argv, char** env) {
     if (0 && argc && argv && env) {}
@@ -34,7 +33,7 @@ int main(int argc, char** argv, char** env) {
     // When tracing, the contents of the secret module will not be seen
     VerilatedVcdC* tfp = NULL;
     const char* flag = Verilated::commandArgsPlusMatch("trace");
-    if (flag && 0==strcmp(flag, "+trace")) {
+    if (flag && 0 == strcmp(flag, "+trace")) {
         Verilated::traceEverOn(true);
         VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
         tfp = new VerilatedVcdC;
@@ -61,11 +60,15 @@ int main(int argc, char** argv, char** env) {
 
     // Close trace if opened
 #if VM_TRACE
-    if (tfp) { tfp->close(); tfp = NULL; }
+    if (tfp) {
+        tfp->close();
+        tfp = NULL;
+    }
 #endif
 
     // Destroy model
-    delete top; top = NULL;
+    delete top;
+    top = NULL;
 
     // Fin
     exit(0);

examples/make_protect_lib/top.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: --protect-lib example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2019 by Todd Strader.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2019 by Todd Strader.
+// SPDX-License-Identifier: CC0-1.0
 
 // See also the EXAMPLE section in the verilator manpage/document.
 module top (input clk);

examples/make_tracing_c/Makefile

@@ -5,10 +5,11 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -38,7 +39,7 @@ VERILATOR_FLAGS += -cc --exe
 # Generate makefile dependencies (not shown as complicates the Makefile)
 #VERILATOR_FLAGS += -MMD
 # Optimize
-VERILATOR_FLAGS += -O2 -x-assign 0
+VERILATOR_FLAGS += -Os -x-assign 0
 # Warn abount lint issues; may not want this on less solid designs
 VERILATOR_FLAGS += -Wall
 # Make waveforms
@@ -52,6 +53,9 @@ VERILATOR_FLAGS += --coverage
 # Add this trace to get a backtrace in gdb
 #VERILATOR_FLAGS += --gdbbt
 
+# Input files for Verilator
+VERILATOR_INPUT = -f input.vc top.v sim_main.cpp
+
 ######################################################################
 default: run
 
@@ -61,22 +65,26 @@ run:
 
 	@echo
 	@echo "-- VERILATE ----------------"
-	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sim_main.cpp
+	$(VERILATOR) $(VERILATOR_FLAGS) $(VERILATOR_INPUT)
 
 	@echo
-	@echo "-- COMPILE -----------------"
-# To compile, we can either just do what Verilator asks,
-# or call a submakefile where we can override the rules ourselves
-#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
-	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+	@echo "-- BUILD -------------------"
+# To compile, we can either
+# 1. Pass --build to Verilator by editing VERILATOR_FLAGS above.
+# 2. Or, run the make rules Verilator does:
+#	$(MAKE) -j -C obj_dir -f Vtop.mk
+# 3. Or, call a submakefile where we can override the rules ourselves:
+	$(MAKE) -j -C obj_dir -f ../Makefile_obj
 
 	@echo
 	@echo "-- RUN ---------------------"
+	@rm -rf logs
 	@mkdir -p logs
 	obj_dir/Vtop +trace
 
 	@echo
 	@echo "-- COVERAGE ----------------"
+	@rm -rf logs/annotated
 	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
 
 	@echo

examples/make_tracing_c/Makefile_obj

@@ -5,10 +5,11 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 #######################################################################
 
@@ -38,7 +39,7 @@ endif
 # SystemC takes minutes to optimize, thus it is off by default.
 OPT_SLOW =
 # Fast path optimizations.  Most time is spent in these classes.
-OPT_FAST = -O2 -fstrict-aliasing
+OPT_FAST = -Os -fstrict-aliasing
 #OPT_FAST = -O
 #OPT_FAST =
 

examples/make_tracing_c/sim_main.cpp

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
 // Include common routines
@@ -10,11 +11,6 @@
 // Include model header, generated from Verilating "top.v"
 #include "Vtop.h"
 
-// If "verilator --trace" is used, include the tracing class
-#if VM_TRACE
-# include <verilated_vcd_c.h>
-#endif
-
 // Current simulation time (64-bit unsigned)
 vluint64_t main_time = 0;
 // Called by $time in Verilog
@@ -36,31 +32,21 @@ int main(int argc, char** argv, char** env) {
     // May be overridden by commandArgs
     Verilated::randReset(2);
 
+    // Verilator must compute traced signals
+    Verilated::traceEverOn(true);
+
     // Pass arguments so Verilated code can see them, e.g. $value$plusargs
     // This needs to be called before you create any model
     Verilated::commandArgs(argc, argv);
 
+    // Create logs/ directory in case we have traces to put under it
+    Verilated::mkdir("logs");
+
     // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
     Vtop* top = new Vtop;  // Or use a const unique_ptr, or the VL_UNIQUE_PTR wrapper
 
-#if VM_TRACE
-    // If verilator was invoked with --trace argument,
-    // and if at run time passed the +trace argument, turn on tracing
-    VerilatedVcdC* tfp = NULL;
-    const char* flag = Verilated::commandArgsPlusMatch("trace");
-    if (flag && 0==strcmp(flag, "+trace")) {
-        Verilated::traceEverOn(true);  // Verilator must compute traced signals
-        VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
-        tfp = new VerilatedVcdC;
-        top->trace(tfp, 99);  // Trace 99 levels of hierarchy
-        Verilated::mkdir("logs");
-        tfp->open("logs/vlt_dump.vcd");  // Open the dump file
-    }
-#endif
-
     // Set some inputs
     top->reset_l = !0;
-    top->fastclk = 0;
     top->clk = 0;
     top->in_small = 1;
     top->in_quad = 0x1234;
@@ -72,46 +58,39 @@ int main(int argc, char** argv, char** env) {
     while (!Verilated::gotFinish()) {
         main_time++;  // Time passes...
 
-        // Toggle clocks and such
-        top->fastclk = !top->fastclk;
-        if ((main_time % 10) == 3) {
-            top->clk = 1;
-        }
-        if ((main_time % 10) == 8) {
-            top->clk = 0;
-        }
-        if (main_time > 1 && main_time < 10) {
-            top->reset_l = !1;  // Assert reset
-        } else {
-            top->reset_l = !0;  // Deassert reset
-        }
+        // Toggle a fast (time/2 period) clock
+        top->clk = !top->clk;
 
-        // Assign some other inputs
-        top->in_quad += 0x12;
+        // Toggle control signals on an edge that doesn't correspond
+        // to where the controls are sampled; in this example we do
+        // this only on a negedge of clk, because we know
+        // reset is not sampled there.
+        if (!top->clk) {
+            if (main_time > 1 && main_time < 10) {
+                top->reset_l = !1;  // Assert reset
+            } else {
+                top->reset_l = !0;  // Deassert reset
+            }
+            // Assign some other inputs
+            top->in_quad += 0x12;
+        }
 
         // Evaluate model
+        // (If you have multiple models being simulated in the same
+        // timestep then instead of eval(), call eval_step() on each, then
+        // eval_end_step() on each.)
         top->eval();
 
-#if VM_TRACE
-        // Dump trace data for this cycle
-        if (tfp) tfp->dump(main_time);
-#endif
-
         // Read outputs
         VL_PRINTF("[%" VL_PRI64 "d] clk=%x rstl=%x iquad=%" VL_PRI64 "x"
-                  " -> oquad=%" VL_PRI64"x owide=%x_%08x_%08x\n",
-                  main_time, top->clk, top->reset_l, top->in_quad,
-                  top->out_quad, top->out_wide[2], top->out_wide[1], top->out_wide[0]);
+                  " -> oquad=%" VL_PRI64 "x owide=%x_%08x_%08x\n",
+                  main_time, top->clk, top->reset_l, top->in_quad, top->out_quad, top->out_wide[2],
+                  top->out_wide[1], top->out_wide[0]);
     }
 
     // Final model cleanup
     top->final();
 
-    // Close trace if opened
-#if VM_TRACE
-    if (tfp) { tfp->close(); tfp = NULL; }
-#endif
-
     //  Coverage analysis (since test passed)
 #if VM_COVERAGE
     Verilated::mkdir("logs");
@@ -119,7 +98,8 @@ int main(int argc, char** argv, char** env) {
 #endif
 
     // Destroy model
-    delete top; top = NULL;
+    delete top;
+    top = NULL;
 
     // Fin
     exit(0);

examples/make_tracing_c/sub.v

@@ -1,31 +1,17 @@
 // DESCRIPTION: Verilator: Verilog Test module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2003 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2003 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 module sub
   (
    input clk,
-   input fastclk,
    input reset_l
    );
 
    // Example counter/flop
-   reg [31:0] count_f;
-   always_ff @ (posedge fastclk) begin
-      if (!reset_l) begin
-         /*AUTORESET*/
-         // Beginning of autoreset for uninitialized flops
-         count_f <= 32'h0;
-         // End of automatics
-      end
-      else begin
-         count_f <= count_f + 1;
-      end
-   end
-
-   // Another example flop
    reg [31:0] count_c;
    always_ff @ (posedge clk) begin
       if (!reset_l) begin
@@ -37,8 +23,6 @@ module sub
       else begin
          count_c <= count_c + 1;
          if (count_c >= 3) begin
-            $display("[%0t] fastclk is %0d times faster than clk\n",
-                     $time, count_f/count_c);
             // This write is a magic value the Makefile uses to make sure the
             // test completes successfully.
             $write("*-* All Finished *-*\n");

examples/make_tracing_c/top.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2003 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2003 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 // This is intended to be a complex example of several features, please also
@@ -10,16 +11,15 @@
 module top
   (
    // Declare some signals so we can see how I/O works
-   input         clk,
-   input         fastclk,
-   input         reset_l,
+   input              clk,
+   input              reset_l,
 
    output wire [1:0]  out_small,
    output wire [39:0] out_quad,
    output wire [69:0] out_wide,
-   input [1:0]   in_small,
-   input [39:0]  in_quad,
-   input [69:0]  in_wide
+   input [1:0]        in_small,
+   input [39:0]       in_quad,
+   input [69:0]       in_wide
    );
 
    // Connect up the outputs, using some trivial logic
@@ -31,11 +31,15 @@ module top
    sub sub (/*AUTOINST*/
             // Inputs
             .clk                        (clk),
-            .fastclk                    (fastclk),
             .reset_l                    (reset_l));
 
    // Print some stuff as an example
    initial begin
+      if ($test$plusargs("trace") != 0) begin
+         $display("[%0t] Tracing to logs/vlt_dump.vcd...\n", $time);
+         $dumpfile("logs/vlt_dump.vcd");
+         $dumpvars();
+      end
       $display("[%0t] Model running...\n", $time);
    end
 

examples/make_tracing_sc/Makefile

@@ -5,10 +5,11 @@
 # This calls the object directory makefile.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -38,7 +39,7 @@ VERILATOR_FLAGS += -sc --exe
 # Generate makefile dependencies (not shown as complicates the Makefile)
 #VERILATOR_FLAGS += -MMD
 # Optimize
-VERILATOR_FLAGS += -O2 -x-assign 0
+VERILATOR_FLAGS += -Os -x-assign 0
 # Warn abount lint issues; may not want this on less solid designs
 VERILATOR_FLAGS += -Wall
 # Make waveforms
@@ -52,6 +53,9 @@ VERILATOR_FLAGS += --coverage
 # Add this trace to get a backtrace in gdb
 #VERILATOR_FLAGS += --gdbbt
 
+# Input files for Verilator
+VERILATOR_INPUT = -f input.vc top.v sc_main.cpp
+
 # Check if SC exists via a verilator call (empty if not)
 SYSTEMC_EXISTS := $(shell $(VERILATOR) --getenv SYSTEMC_INCLUDE)
 
@@ -69,22 +73,26 @@ run:
 
 	@echo
 	@echo "-- VERILATE ----------------"
-	$(VERILATOR) $(VERILATOR_FLAGS) -f input.vc top.v sc_main.cpp
+	$(VERILATOR) $(VERILATOR_FLAGS) $(VERILATOR_INPUT)
 
 	@echo
-	@echo "-- COMPILE ----------------="
-# To compile, we can either just do what Verilator asks,
-# or call a submakefile where we can override the rules ourselves
-#	$(MAKE) -j 4 -C obj_dir -f Vtop.mk
-	$(MAKE) -j 4 -C obj_dir -f ../Makefile_obj
+	@echo "-- COMPILE -----------------"
+# To compile, we can either
+# 1. Pass --build to Verilator by editing VERILATOR_FLAGS above.
+# 2. Or, run the make rules Verilator does:
+#	$(MAKE) -j -C obj_dir -f Vtop.mk
+# 3. Or, call a submakefile where we can override the rules ourselves:
+	$(MAKE) -j -C obj_dir -f ../Makefile_obj
 
 	@echo
 	@echo "-- RUN ---------------------"
+	@rm -rf logs
 	@mkdir -p logs
 	obj_dir/Vtop +trace
 
 	@echo
 	@echo "-- COVERAGE ----------------"
+	@rm -rf logs/annotated
 	$(VERILATOR_COVERAGE) --annotate logs/annotated logs/coverage.dat
 
 	@echo
@@ -92,6 +100,7 @@ run:
 	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
 	@echo
 
+
 ######################################################################
 # Other targets
 

examples/make_tracing_sc/Makefile_obj

@@ -5,10 +5,11 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 #######################################################################
 
@@ -46,7 +47,7 @@ endif
 # SystemC takes minutes to optimize, thus it is off by default.
 OPT_SLOW =
 # Fast path optimizations.  Most time is spent in these classes.
-OPT_FAST = -O2 -fstrict-aliasing
+OPT_FAST = -Os -fstrict-aliasing
 #OPT_FAST = -O
 #OPT_FAST =
 

examples/make_tracing_sc/sc_main.cpp

@@ -1,8 +1,9 @@
 // -*- SystemC -*-
 // DESCRIPTION: Verilator Example: Top level main for invoking SystemC model
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2017 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2017 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
 // SystemC global header
@@ -37,23 +38,26 @@ int sc_main(int argc, char* argv[]) {
     // This needs to be called before you create any model
     Verilated::commandArgs(argc, argv);
 
+    // Create logs/ directory in case we have traces to put under it
+    Verilated::mkdir("logs");
+
     // General logfile
     ios::sync_with_stdio();
 
     // Defaults time
-#if (SYSTEMC_VERSION>20011000)
+#if (SYSTEMC_VERSION > 20011000)
 #else
     sc_time dut(1.0, sc_ns);
     sc_set_default_time_unit(dut);
 #endif
 
     // Define clocks
-#if (SYSTEMC_VERSION>=20070314)
-    sc_clock clk     ("clk",    10,SC_NS, 0.5, 3,SC_NS, true);
-    sc_clock fastclk ("fastclk", 2,SC_NS, 0.5, 2,SC_NS, true);
+#if (SYSTEMC_VERSION >= 20070314)
+    sc_clock clk("clk", 10, SC_NS, 0.5, 3, SC_NS, true);
+    sc_clock fastclk("fastclk", 2, SC_NS, 0.5, 2, SC_NS, true);
 #else
-    sc_clock clk     ("clk",    10, 0.5, 3, true);
-    sc_clock fastclk ("fastclk", 2, 0.5, 2, true);
+    sc_clock clk("clk", 10, 0.5, 3, true);
+    sc_clock fastclk("fastclk", 2, 0.5, 2, true);
 #endif
 
     // Define interconnect
@@ -68,15 +72,15 @@ int sc_main(int argc, char* argv[]) {
     // Construct the Verilated model, from inside Vtop.h
     Vtop* top = new Vtop("top");
     // Attach signals to the model
-    top->clk       (clk);
-    top->fastclk   (fastclk);
-    top->reset_l   (reset_l);
-    top->in_small  (in_small);
-    top->in_quad   (in_quad);
-    top->in_wide   (in_wide);
-    top->out_small (out_small);
-    top->out_quad  (out_quad);
-    top->out_wide  (out_wide);
+    top->clk(clk);
+    top->fastclk(fastclk);
+    top->reset_l(reset_l);
+    top->in_small(in_small);
+    top->in_quad(in_quad);
+    top->in_wide(in_wide);
+    top->out_small(out_small);
+    top->out_quad(out_quad);
+    top->out_wide(out_wide);
 
 #if VM_TRACE
     // Before any evaluation, need to know to calculate those signals only used for tracing
@@ -85,8 +89,8 @@ int sc_main(int argc, char* argv[]) {
 
     // You must do one evaluation before enabling waves, in order to allow
     // SystemC to interconnect everything for testing.
-#if (SYSTEMC_VERSION>=20070314)
-    sc_start(1,SC_NS);
+#if (SYSTEMC_VERSION >= 20070314)
+    sc_start(1, SC_NS);
 #else
     sc_start(1);
 #endif
@@ -96,7 +100,7 @@ int sc_main(int argc, char* argv[]) {
     // and if at run time passed the +trace argument, turn on tracing
     VerilatedVcdSc* tfp = NULL;
     const char* flag = Verilated::commandArgsPlusMatch("trace");
-    if (flag && 0==strcmp(flag, "+trace")) {
+    if (flag && 0 == strcmp(flag, "+trace")) {
         cout << "Enabling waves into logs/vlt_dump.vcd...\n";
         tfp = new VerilatedVcdSc;
         top->trace(tfp, 99);  // Trace 99 levels of hierarchy
@@ -114,15 +118,15 @@ int sc_main(int argc, char* argv[]) {
 #endif
 
         // Apply inputs
-        if (VL_TIME_Q() > 1 && VL_TIME_Q() < 10) {
+        if (sc_time_stamp() > sc_time(1, SC_NS) && sc_time_stamp() < sc_time(10, SC_NS)) {
             reset_l = !1;  // Assert reset
-        } else if (VL_TIME_Q() > 1) {
+        } else {
             reset_l = !0;  // Deassert reset
         }
 
         // Simulate 1ns
-#if (SYSTEMC_VERSION>=20070314)
-        sc_start(1,SC_NS);
+#if (SYSTEMC_VERSION >= 20070314)
+        sc_start(1, SC_NS);
 #else
         sc_start(1);
 #endif
@@ -133,7 +137,10 @@ int sc_main(int argc, char* argv[]) {
 
     // Close trace if opened
 #if VM_TRACE
-    if (tfp) { tfp->close(); tfp = NULL; }
+    if (tfp) {
+        tfp->close();
+        tfp = NULL;
+    }
 #endif
 
     //  Coverage analysis (since test passed)
@@ -143,7 +150,8 @@ int sc_main(int argc, char* argv[]) {
 #endif
 
     // Destroy model
-    delete top; top = NULL;
+    delete top;
+    top = NULL;
 
     // Fin
     return 0;

examples/make_tracing_sc/sub.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog Test module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2003 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2003 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 module sub

examples/make_tracing_sc/top.v

@@ -1,7 +1,8 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2003 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2003 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 // This is intended to be a complex example of several features, please also
@@ -10,16 +11,16 @@
 module top
   (
    // Declare some signals so we can see how I/O works
-   input         clk,
-   input         fastclk,
-   input         reset_l,
+   input              clk,
+   input              fastclk,
+   input              reset_l,
 
    output wire [1:0]  out_small,
    output wire [39:0] out_quad,
    output wire [69:0] out_wide,
-   input [1:0]   in_small,
-   input [39:0]  in_quad,
-   input [69:0]  in_wide
+   input [1:0]        in_small,
+   input [39:0]       in_quad,
+   input [69:0]       in_wide
    );
 
    // Connect up the outputs, using some trivial logic

examples/xml_py/Makefile

@@ -2,10 +2,11 @@
 #
 # DESCRIPTION: Verilator Example: XML tests
 #
-# Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
-# redistribute it and/or modify it under the terms of either the GNU
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 #
 ######################################################################
 
@@ -25,7 +26,20 @@ endif
 DOT = dot
 PYTHON = python3
 
+PYTHON_VERSION := $(shell ${PYTHON} --version 2>&1)
+PYTHON_VERSION_FULL := $(wordlist 2,4,$(subst ., ,${PYTHON_VERSION}))
+PYTHON_VERSION_MAJOR := $(word 1,${PYTHON_VERSION_FULL})
+PYTHON_VERSION_MINOR := $(word 2,${PYTHON_VERSION_FULL})
+PYTHON_GE_3_5 := $(shell [ ${PYTHON_VERSION_MAJOR} -eq 3 -a ${PYTHON_VERSION_MINOR} -ge 5 ] && echo true)
+
+ifeq (${PYTHON_GE_3_5},true)
 default: test
+else
+default: python_message
+endif
+
+python_message:
+	@echo "Found Python version ${PYTHON_VERSION}, but require >= 3.5"
 
 test: \
 	test-vl_file_copy \

examples/xml_py/sub.v

@@ -1,13 +1,14 @@
 // DESCRIPTION: Verilator: Verilog Test module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2019 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2019 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 module sub
   #(parameter type TYPE_t = logic)
    (
-    input TYPE_t in,
+    input  TYPE_t in,
     output TYPE_t out
     );
 

examples/xml_py/top.v

@@ -1,21 +1,22 @@
 // DESCRIPTION: Verilator: Verilog example module
 //
-// This file ONLY is placed into the Public Domain, for any use,
-// without warranty, 2019 by Wilson Snyder.
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2019 by Wilson Snyder.
+// SPDX-License-Identifier: CC0-1.0
 // ======================================================================
 
 module top
   (
-   input         clk,
-   input         fastclk,
-   input         reset_l,
+   input              clk,
+   input              fastclk,
+   input              reset_l,
 
    output wire [1:0]  out_small,
    output wire [39:0] out_quad,
    output wire [69:0] out_wide,
-   input [1:0]   in_small,
-   input [39:0]  in_quad,
-   input [69:0]  in_wide
+   input [1:0]        in_small,
+   input [39:0]       in_quad,
+   input [69:0]       in_wide
    );
 
    sub #(.TYPE_t(logic [1:0])) sub_small

examples/xml_py/vl_file_copy

@@ -84,8 +84,10 @@ Example usage:
   -v <filename>              Verilog library
   -y <dir>                   Directory to search for modules
 
-This file ONLY is placed into the Public Domain, for any use, without
-warranty, 2019 by Wilson Snyder."""
+This file ONLY is placed under the Creative Commons Public Domain, for
+any use, without warranty, 2019 by Wilson Snyder.
+SPDX-License-Identifier: CC0-1.0
+"""
     )
     parser.add_argument('-debug', '--debug',
                         action='store_const', const=9,

examples/xml_py/vl_hier_graph

@@ -108,8 +108,10 @@ Example usage:
   -v <filename>              Verilog library
   -y <dir>                   Directory to search for modules
 
-This file ONLY is placed into the Public Domain, for any use, without
-warranty, 2019 by Wilson Snyder."""
+This file ONLY is placed under the Creative Commons Public Domain, for
+any use, without warranty, 2019 by Wilson Snyder.
+SPDX-License-Identifier: CC0-1.0
+"""
     )
     parser.add_argument('-debug', '--debug',
                         action='store_const', const=9,

include/gtkwave/fastlz.c

@@ -22,6 +22,8 @@
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
+
+  SPDX-License-Identifier: MIT
 */
 
 #include "fastlz.h"
@@ -418,9 +420,7 @@ static FASTLZ_INLINE int FASTLZ_DECOMPRESSOR(const void* input, int length, void
   const flzuint8* ip = (const flzuint8*) input;
   const flzuint8* ip_limit  = ip + length;
   flzuint8* op = (flzuint8*) output;
-#ifdef FASTLZ_SAFE
   flzuint8* op_limit = op + maxout;
-#endif
   flzuint32 ctrl = (*ip++) & 31;
   int loop = 1;
 

include/gtkwave/fastlz.h

@@ -22,6 +22,8 @@
   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
+
+  SPDX-License-Identifier: MIT
 */
 
 #ifndef FASTLZ_H

include/gtkwave/fstapi.c

@@ -18,6 +18,8 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
  */
 
 /*
@@ -37,13 +39,15 @@
  *
  */
 
-// Verilator: use hardcoded config file
-//#include <config.h>
-#include "fst_config.h"
+#ifndef FST_CONFIG_INCLUDE
+# define FST_CONFIG_INCLUDE <config.h>
+#endif
+#include FST_CONFIG_INCLUDE
 
 #include "fstapi.h"
 #include "fastlz.h"
 #include "lz4.h"
+#include <errno.h>
 
 #ifndef HAVE_LIBPTHREAD
 #undef FST_WRITER_PARALLEL
@@ -130,6 +134,16 @@ void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint3
 #include <sys/sysctl.h>
 #endif
 
+#ifdef __GNUC__
+/* Boolean expression more often true than false */
+#define FST_LIKELY(x) __builtin_expect(!!(x), 1)
+/* Boolean expression more often false than true */
+#define FST_UNLIKELY(x) __builtin_expect(!!(x), 0)
+#else
+#define FST_LIKELY(x) (!!(x))
+#define FST_UNLIKELY(x) (!!(x))
+#endif
+
 #define FST_APIMESS "FSTAPI  | "
 
 /***********************/
@@ -725,6 +739,9 @@ off_t hier_file_len;
 uint32_t *valpos_mem;
 unsigned char *curval_mem;
 
+unsigned char *outval_mem; /* for two-state / Verilator-style value changes */
+uint32_t outval_alloc_siz;
+
 char *filename;
 
 fstHandle maxhandle;
@@ -954,6 +971,19 @@ fflush(xc->handle);
 /*
  * mmap functions
  */
+static void fstWriterMmapSanity(void *pnt, const char *file, int line, const char *usage)
+{
+#if !defined(__CYGWIN__) && !defined(__MINGW32__)
+if(pnt == MAP_FAILED)
+	{
+	fprintf(stderr, "fstMmap() assigned to %s failed: errno: %d, file %s, line %d.\n", usage, errno, file, line);
+	perror("Why");
+	pnt = NULL;
+	}
+#endif
+}
+
+
 static void fstWriterCreateMmaps(struct fstWriterContext *xc)
 {
 off_t curpos = ftello(xc->handle);
@@ -976,19 +1006,29 @@ fflush(xc->handle);
 if(!xc->valpos_mem)
         {
         fflush(xc->valpos_handle);
-        xc->valpos_mem = (uint32_t *)fstMmap(NULL, xc->maxhandle * 4 * sizeof(uint32_t), PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->valpos_handle), 0);
+	errno = 0;
+	if(xc->maxhandle)
+		{
+	        fstWriterMmapSanity(xc->valpos_mem = (uint32_t *)fstMmap(NULL, xc->maxhandle * 4 * sizeof(uint32_t), PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->valpos_handle), 0), __FILE__, __LINE__, "xc->valpos_mem");
+		}
         }
 if(!xc->curval_mem)
         {
         fflush(xc->curval_handle);
-        xc->curval_mem = (unsigned char *)fstMmap(NULL, xc->maxvalpos, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->curval_handle), 0);
+	errno = 0;
+	if(xc->maxvalpos)
+		{
+	        fstWriterMmapSanity(xc->curval_mem = (unsigned char *)fstMmap(NULL, xc->maxvalpos, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->curval_handle), 0), __FILE__, __LINE__, "xc->curval_handle");
+		}
         }
 }
 
 
 static void fstDestroyMmaps(struct fstWriterContext *xc, int is_closing)
 {
+#if !defined __CYGWIN__ && !defined __MINGW32__
 (void)is_closing;
+#endif
 
 fstMunmap(xc->valpos_mem, xc->maxhandle * 4 * sizeof(uint32_t));
 xc->valpos_mem = NULL;
@@ -1684,7 +1724,8 @@ fflush(xc->tchn_handle);
 tlen = ftello(xc->tchn_handle);
 fstWriterFseeko(xc, xc->tchn_handle, 0, SEEK_SET);
 
-tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->tchn_handle), 0);
+errno = 0;
+fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->tchn_handle), 0), __FILE__, __LINE__, "tmem");
 if(tmem)
         {
         unsigned long destlen = tlen;
@@ -1876,7 +1917,7 @@ if(xc)
 
 if(xc && !xc->already_in_close && !xc->already_in_flush)
         {
-        unsigned char *tmem;
+        unsigned char *tmem = NULL;
         off_t fixup_offs, tlen, hlen;
 
         xc->already_in_close = 1; /* never need to zero this out as it is freed at bottom */
@@ -1892,7 +1933,7 @@ if(xc && !xc->already_in_close && !xc->already_in_flush)
                 xc->skip_writing_section_hdr = 1;
                 if(!xc->size_limit_locked)
                         {
-                        if(xc->is_initial_time) /* simulation time never advanced so mock up the changes as time zero ones */
+                        if(FST_UNLIKELY(xc->is_initial_time)) /* simulation time never advanced so mock up the changes as time zero ones */
                                 {
                                 fstHandle dupe_idx;
 
@@ -1910,11 +1951,21 @@ if(xc && !xc->already_in_close && !xc->already_in_flush)
                         }
                 }
         fstDestroyMmaps(xc, 1);
+	if(xc->outval_mem)
+		{
+		free(xc->outval_mem); xc->outval_mem = NULL;
+		xc->outval_alloc_siz = 0;
+		}
 
         /* write out geom section */
         fflush(xc->geom_handle);
         tlen = ftello(xc->geom_handle);
-        tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->geom_handle), 0);
+	errno = 0;
+	if(tlen)
+		{
+	        fstWriterMmapSanity(tmem = (unsigned char *)fstMmap(NULL, tlen, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->geom_handle), 0), __FILE__, __LINE__, "tmem");
+		}
+
         if(tmem)
                 {
                 unsigned long destlen = tlen;
@@ -2022,14 +2073,18 @@ if(xc && !xc->already_in_close && !xc->already_in_flush)
                         {
                         int lz4_maxlen;
                         unsigned char *mem;
-                        unsigned char *hmem;
+                        unsigned char *hmem = NULL;
                         int packed_len;
 
                         fflush(xc->handle);
 
                         lz4_maxlen = LZ4_compressBound(xc->hier_file_len);
                         mem = (unsigned char *)malloc(lz4_maxlen);
-                        hmem = (unsigned char *)fstMmap(NULL, xc->hier_file_len, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->hier_handle), 0);
+			errno = 0;
+			if(xc->hier_file_len)
+				{
+	                        fstWriterMmapSanity(hmem = (unsigned char *)fstMmap(NULL, xc->hier_file_len, PROT_READ|PROT_WRITE, MAP_SHARED, fileno(xc->hier_handle), 0), __FILE__, __LINE__, "hmem");
+				}
                         packed_len = LZ4_compress((char *)hmem, (char *)mem, xc->hier_file_len);
                         fstMunmap(hmem, xc->hier_file_len);
 
@@ -2845,12 +2900,12 @@ const unsigned char *buf = (const unsigned char *)val;
 uint32_t offs;
 int len;
 
-if((xc) && (handle <= xc->maxhandle))
+if(FST_LIKELY((xc) && (handle <= xc->maxhandle)))
         {
         uint32_t fpos;
         uint32_t *vm4ip;
 
-        if(!xc->valpos_mem)
+        if(FST_UNLIKELY(!xc->valpos_mem))
                 {
                 xc->vc_emitted = 1;
                 fstWriterCreateMmaps(xc);
@@ -2860,17 +2915,17 @@ if((xc) && (handle <= xc->maxhandle))
         vm4ip = &(xc->valpos_mem[4*handle]);
 
         len  = vm4ip[1];
-        if(len) /* len of zero = variable length, use fstWriterEmitVariableLengthValueChange */
+        if(FST_LIKELY(len)) /* len of zero = variable length, use fstWriterEmitVariableLengthValueChange */
                 {
-                if(!xc->is_initial_time)
+                if(FST_LIKELY(!xc->is_initial_time))
                         {
                         fpos = xc->vchg_siz;
 
-                        if((fpos + len + 10) > xc->vchg_alloc_siz)
+                        if(FST_UNLIKELY((fpos + len + 10) > xc->vchg_alloc_siz))
                                 {
                                 xc->vchg_alloc_siz += (xc->fst_break_add_size + len); /* +len added in the case of extremely long vectors and small break add sizes */
                                 xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz);
-                                if(!xc->vchg_mem)
+                                if(FST_UNLIKELY(!xc->vchg_mem))
                                         {
                                         fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitValueChange, exiting.\n");
                                         exit(255);
@@ -2955,18 +3010,139 @@ if((xc) && (handle <= xc->maxhandle))
         }
 }
 
+void fstWriterEmitValueChange32(void *ctx, fstHandle handle,
+                                uint32_t bits, uint32_t val) {
+        char buf[32];
+        char *s = buf;
+        uint32_t i;
+        for (i = 0; i < bits; ++i)
+        {
+                *s++ = '0' + ((val >> (bits - i - 1)) & 1);
+        }
+        fstWriterEmitValueChange(ctx, handle, buf);
+}
+void fstWriterEmitValueChange64(void *ctx, fstHandle handle,
+                                uint32_t bits, uint64_t val) {
+        char buf[64];
+        char *s = buf;
+        uint32_t i;
+        for (i = 0; i < bits; ++i)
+        {
+                *s++ = '0' + ((val >> (bits - i - 1)) & 1);
+        }
+        fstWriterEmitValueChange(ctx, handle, buf);
+}
+void fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle,
+                                   uint32_t bits, const uint32_t *val) {
+        struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
+        if (FST_UNLIKELY(bits <= 32))
+        {
+                fstWriterEmitValueChange32(ctx, handle, bits, val[0]);
+        }
+        else if(FST_LIKELY(xc))
+        {
+                int bq = bits / 32;
+                int br = bits & 31;
+                int i;
+                int w;
+                uint32_t v;
+                unsigned char* s;
+                if (FST_UNLIKELY(bits > xc->outval_alloc_siz))
+                {
+                        xc->outval_alloc_siz = bits*2 + 1;
+                        xc->outval_mem = (unsigned char*)realloc(xc->outval_mem, xc->outval_alloc_siz);
+                        if (FST_UNLIKELY(!xc->outval_mem))
+                        {
+                                fprintf(stderr,
+                                        FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec32, exiting.\n");
+                                exit(255);
+                        }
+                }
+                s = xc->outval_mem;
+                {
+                        w = bq;
+                        v = val[w];
+                        for (i = 0; i < br; ++i)
+                        {
+                                *s++ = '0' + ((v >> (br - i - 1)) & 1);
+                        }
+                }
+                for (w = bq - 1; w >= 0; --w)
+                {
+                        v = val[w];
+                        for (i = (32 - 4); i >= 0; i -= 4) {
+                                s[0] = '0' + ((v >> (i + 3)) & 1);
+                                s[1] = '0' + ((v >> (i + 2)) & 1);
+                                s[2] = '0' + ((v >> (i + 1)) & 1);
+                                s[3] = '0' + ((v >> (i + 0)) & 1);
+                                s += 4;
+                        }
+                }
+                fstWriterEmitValueChange(ctx, handle, xc->outval_mem);
+        }
+}
+void fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle,
+                                   uint32_t bits, const uint64_t *val) {
+        struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
+        if (FST_UNLIKELY(bits <= 64))
+        {
+                fstWriterEmitValueChange64(ctx, handle, bits, val[0]);
+        }
+        else if(FST_LIKELY(xc))
+        {
+                int bq = bits / 64;
+                int br = bits & 63;
+                int i;
+                int w;
+                uint32_t v;
+                unsigned char* s;
+                if (FST_UNLIKELY(bits > xc->outval_alloc_siz))
+                {
+                        xc->outval_alloc_siz = bits*2 + 1;
+                        xc->outval_mem = (unsigned char*)realloc(xc->outval_mem, xc->outval_alloc_siz);
+                        if (FST_UNLIKELY(!xc->outval_mem))
+                        {
+                                fprintf(stderr,
+                                        FST_APIMESS "Could not realloc() in fstWriterEmitValueChangeVec64, exiting.\n");
+                                exit(255);
+                        }
+                }
+                s = xc->outval_mem;
+                {
+                        w = bq;
+                        v = val[w];
+                        for (i = 0; i < br; ++i)
+                        {
+                                *s++ = '0' + ((v >> (br - i - 1)) & 1);
+                        }
+                }
+                for (w = bq - 1; w >= 0; --w) {
+                        v = val[w];
+                        for (i = (64 - 4); i >= 0; i -= 4)
+                        {
+                                s[0] = '0' + ((v >> (i + 3)) & 1);
+                                s[1] = '0' + ((v >> (i + 2)) & 1);
+                                s[2] = '0' + ((v >> (i + 1)) & 1);
+                                s[3] = '0' + ((v >> (i + 0)) & 1);
+                                s += 4;
+                        }
+                }
+                fstWriterEmitValueChange(ctx, handle, xc->outval_mem);
+        }
+}
+
 
 void fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len)
 {
 struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
 const unsigned char *buf = (const unsigned char *)val;
 
-if((xc) && (handle <= xc->maxhandle))
+if(FST_LIKELY((xc) && (handle <= xc->maxhandle)))
         {
         uint32_t fpos;
         uint32_t *vm4ip;
 
-        if(!xc->valpos_mem)
+        if(FST_UNLIKELY(!xc->valpos_mem))
                 {
                 xc->vc_emitted = 1;
                 fstWriterCreateMmaps(xc);
@@ -2976,15 +3152,15 @@ if((xc) && (handle <= xc->maxhandle))
         vm4ip = &(xc->valpos_mem[4*handle]);
 
         /* there is no initial time dump for variable length value changes */
-        if(!vm4ip[1]) /* len of zero = variable length */
+        if(FST_LIKELY(!vm4ip[1])) /* len of zero = variable length */
                 {
                 fpos = xc->vchg_siz;
 
-                if((fpos + len + 10 + 5) > xc->vchg_alloc_siz)
+                if(FST_UNLIKELY((fpos + len + 10 + 5) > xc->vchg_alloc_siz))
                         {
                         xc->vchg_alloc_siz += (xc->fst_break_add_size + len + 5); /* +len added in the case of extremely long vectors and small break add sizes */
                         xc->vchg_mem = (unsigned char *)realloc(xc->vchg_mem, xc->vchg_alloc_siz);
-                        if(!xc->vchg_mem)
+                        if(FST_UNLIKELY(!xc->vchg_mem))
                                 {
                                 fprintf(stderr, FST_APIMESS "Could not realloc() in fstWriterEmitVariableLengthValueChange, exiting.\n");
                                 exit(255);
@@ -3006,7 +3182,7 @@ unsigned int i;
 int skip = 0;
 if(xc)
         {
-        if(xc->is_initial_time)
+        if(FST_UNLIKELY(xc->is_initial_time))
                 {
                 if(xc->size_limit_locked)       /* this resets xc->is_initial_time to one */
                         {

include/gtkwave/fstapi.h

@@ -18,6 +18,8 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
  */
 
 #ifndef FST_API_H
@@ -355,6 +357,14 @@ fstHandle       fstWriterCreateVar2(void *ctx, enum fstVarType vt, enum fstVarDi
 void            fstWriterEmitDumpActive(void *ctx, int enable);
 void 		fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
 void            fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val);
+void            fstWriterEmitValueChange32(void *ctx, fstHandle handle,
+                        uint32_t bits, uint32_t val);
+void            fstWriterEmitValueChange64(void *ctx, fstHandle handle,
+                        uint32_t bits, uint64_t val);
+void            fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle,
+                        uint32_t bits, const uint32_t *val);
+void            fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle,
+                        uint32_t bits, const uint64_t *val);
 void            fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len);
 void            fstWriterEmitTimeChange(void *ctx, uint64_t tim);
 void            fstWriterFlushContext(void *ctx);

include/gtkwave/lz4.c

@@ -27,6 +27,8 @@
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+   SPDX-License-Identifier: BSD-2-Clause
+
    You can contact the author at :
    - LZ4 source repository : https://github.com/Cyan4973/lz4
    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c

include/gtkwave/lz4.h

@@ -28,6 +28,8 @@
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+   SPDX-License-Identifier: BSD-2-Clause
+
    You can contact the author at :
    - LZ4 source repository : https://github.com/Cyan4973/lz4
    - LZ4 public forum : https://groups.google.com/forum/#!forum/lz4c

include/gtkwave/wavealloca.h

@@ -18,6 +18,8 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  * DEALINGS IN THE SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
  */
 
 #ifndef WAVE_ALLOCA_H
@@ -33,9 +35,6 @@
 #else
 #include <malloc.h>
 #endif
-#elif defined(_MSC_VER)
-#include <malloc.h>
-#define alloca _alloca
 #endif
 #define wave_alloca alloca
 #endif

include/verilated.mk.in

@@ -2,16 +2,19 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2019 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.
+# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 ######################################################################
 
 PERL = @PERL@
 CXX = @CXX@
 LINK = @CXX@
-AR     = ar
+AR = ar
 RANLIB = ranlib
+OBJCACHE ?= @OBJCACHE@
 
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
@@ -48,7 +51,6 @@ VK_CPPFLAGS_ALWAYS += \
 		-MMD \
 		-I$(VERILATOR_ROOT)/include \
 		-I$(VERILATOR_ROOT)/include/vltstd \
-		-DVL_PRINTF=printf \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
 		-DVM_SC=$(VM_SC) \
 		-DVM_TRACE=$(VM_TRACE) \
@@ -87,7 +89,7 @@ LDLIBS   += $(VM_USER_LDLIBS)
 # SystemC takes minutes to optimize, thus it is off by default.
 #OPT_SLOW =
 # Fast path optimizations.  Most time is spent in these classes.
-#OPT_FAST = -O2 -fstrict-aliasing
+#OPT_FAST = -Os -fstrict-aliasing
 #OPT_FAST = -O
 #OPT_FAST =
 
@@ -113,24 +115,49 @@ endif
 #######################################################################
 ##### Threaded builds
 
+ifneq ($(VM_C11),0)
+ ifneq ($(VM_C11),)
+  VK_C11=1
+ endif
+endif
+
 ifneq ($(VM_THREADS),0)
  ifneq ($(VM_THREADS),)
   CPPFLAGS += -DVL_THREADED
+  VK_C11=1
   VK_LIBS_THREADED=1
  endif
 endif
 
-ifneq ($(VM_TRACE_THREADED),0)
- ifneq ($(VM_TRACE_THREADED),)
+ifneq ($(VM_TRACE_THREADS),0)
+ ifneq ($(VM_TRACE_THREADS),)
+  ifeq ($(findstring -DVL_THREADED,$(CPPFLAGS)),)
+   $(error VM_TRACE_THREADS requires VM_THREADS)
+  endif
   CPPFLAGS += -DVL_TRACE_THREADED
+  VK_C11=1
   VK_LIBS_THREADED=1
  endif
 endif
 
+
+ifneq ($(VM_TRACE_FST_WRITER_THREAD),0)
+ ifneq ($(VM_TRACE_FST_WRITER_THREAD),)
+  CPPFLAGS += -DVL_TRACE_FST_WRITER_THREAD
+  VK_C11=1
+  VK_LIBS_THREADED=1
+ endif
+endif
+
+ifneq ($(VK_C11),0)
+ ifneq ($(VK_C11),)
+  # Need C++11 at least, so always default to newest
+  CPPFLAGS += $(CFG_CXXFLAGS_STD_NEWEST)
+ endif
+endif
+
 ifneq ($(VK_LIBS_THREADED),0)
  ifneq ($(VK_LIBS_THREADED),)
-  # Need C++11 at least, so always default to newest
-  CPPFLAGS += $(CFG_CXXFLAGS_STD_NEWEST)
   LDLIBS += $(CFG_LDLIBS_THREADS)
  endif
 endif
@@ -140,18 +167,14 @@ endif
 
 preproc:
 
-#######################################################################
-##### C/H builds
-
-LIBS   += -lm -lstdc++
-
 #######################################################################
 # Overall Objects Linking
 
-VK_CLASSES_H   = $(addsuffix .h, $(VM_CLASSES))
-VK_CLASSES_CPP = $(addsuffix .cpp, $(VM_CLASSES))
+VK_CLASSES_FAST_CPP = $(addsuffix .cpp, $(VM_CLASSES_FAST))
+VK_CLASSES_SLOW_CPP = $(addsuffix .cpp, $(VM_CLASSES_SLOW))
 
-VK_SUPPORT_CPP = $(addsuffix .cpp, $(VM_SUPPORT))
+VK_SUPPORT_FAST_CPP = $(addsuffix .cpp, $(VM_SUPPORT_FAST))
+VK_SUPPORT_SLOW_CPP = $(addsuffix .cpp, $(VM_SUPPORT_SLOW))
 
 VK_USER_OBJS   = $(addsuffix .o, $(VM_USER_CLASSES))
 
@@ -160,11 +183,11 @@ 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)
+  VK_OBJS += $(VM_PREFIX)__ALLfast.o   $(VM_PREFIX)__ALLslow.o
+  all_cpp:   $(VM_PREFIX)__ALLfast.cpp $(VM_PREFIX)__ALLslow.cpp
+  $(VM_PREFIX)__ALLfast.cpp: $(VK_CLASSES_FAST_CPP) $(VK_SUPPORT_FAST_CPP)
 	$(VERILATOR_INCLUDER) -DVL_INCLUDE_OPT=include $^ > $@
-  $(VM_PREFIX)__ALLsup.cpp: $(VK_SUPPORT_CPP)
+  $(VM_PREFIX)__ALLslow.cpp: $(VK_CLASSES_SLOW_CPP) $(VK_SUPPORT_SLOW_CPP)
 	$(VERILATOR_INCLUDER) -DVL_INCLUDE_OPT=include $^ > $@
 else
   #Slow way of building... Each .cpp file by itself
@@ -179,10 +202,10 @@ $(VM_PREFIX)__ALL.a: $(VK_OBJS)
 ### Compile rules
 
 ifneq ($(VM_DEFAULT_RULES),0)
-$(VM_PREFIX)__ALLcls.o: $(VM_PREFIX)__ALLcls.cpp
+$(VM_PREFIX)__ALLfast.o: $(VM_PREFIX)__ALLfast.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
 
-$(VM_PREFIX)__ALLsup.o: $(VM_PREFIX)__ALLsup.cpp
+$(VM_PREFIX)__ALLslow.o: $(VM_PREFIX)__ALLslow.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<
 
 # VM_GLOBAL_FAST files including verilated.o use this rule

include/verilated.v

@@ -4,15 +4,11 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=========================================================================
 //

include/verilated_config.h.in

@@ -1,15 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //*************************************************************************
 ///
@@ -20,9 +16,8 @@
 ///
 //*************************************************************************
 
-
 ///**** Product and Version name
 
 // Autoconf substitutes this with the strings from AC_INIT.
-#define VERILATOR_PRODUCT    "@PACKAGE_NAME@"
-#define VERILATOR_VERSION    "@PACKAGE_VERSION@"
+#define VERILATOR_PRODUCT "@PACKAGE_NAME@"
+#define VERILATOR_VERSION "@PACKAGE_VERSION@"

include/verilated_cov.cpp

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -50,7 +47,7 @@ public:  // But only local to this file
     // CONSTRUCTORS
     // Derived classes should call zero() in their constructor
     VerilatedCovImpItem() {
-        for (int i=0; i<MAX_KEYS; ++i) {
+        for (int i = 0; i < MAX_KEYS; ++i) {
             m_keys[i] = KEY_UNDEF;
             m_vals[i] = 0;
         }
@@ -69,16 +66,19 @@ public:  // But only local to this file
 template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
 private:
     // MEMBERS
-    T*  m_countp;  ///< Count value
+    T* m_countp;  ///< Count value
 public:
     // METHODS
     // cppcheck-suppress truncLongCastReturn
-    virtual vluint64_t count() const { return *m_countp; }
-    virtual void zero() const { *m_countp = 0; }
+    virtual vluint64_t count() const VL_OVERRIDE { return *m_countp; }
+    virtual void zero() const VL_OVERRIDE { *m_countp = 0; }
     // CONSTRUCTORS
     // cppcheck-suppress noExplicitConstructor
-    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
-    virtual ~VerilatedCoverItemSpec() {}
+    explicit VerilatedCoverItemSpec(T* countp)
+        : m_countp(countp) {
+        *m_countp = 0;
+    }
+    virtual ~VerilatedCoverItemSpec() VL_OVERRIDE {}
 };
 
 //=============================================================================
@@ -90,20 +90,20 @@ public:
 class VerilatedCovImp : VerilatedCovImpBase {
 private:
     // TYPES
-    typedef std::map<std::string,int> ValueIndexMap;
-    typedef std::map<int,std::string> IndexValueMap;
+    typedef std::map<std::string, int> ValueIndexMap;
+    typedef std::map<int, std::string> IndexValueMap;
     typedef std::deque<VerilatedCovImpItem*> ItemList;
 
 private:
     // MEMBERS
-    VerilatedMutex      m_mutex;  ///< Protects all members, when VL_THREADED. Wrapper deals with setting it.
-    ValueIndexMap       m_valueIndexes VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
-    IndexValueMap       m_indexValues VL_GUARDED_BY(m_mutex);  ///< For each key/value a unique arbitrary index value
-    ItemList            m_items VL_GUARDED_BY(m_mutex);  ///< List of all items
+    VerilatedMutex m_mutex;  ///< Protects all members
+    ValueIndexMap m_valueIndexes VL_GUARDED_BY(m_mutex);  ///< Unique arbitrary value for values
+    IndexValueMap m_indexValues VL_GUARDED_BY(m_mutex);  ///< Unique arbitrary value for keys
+    ItemList m_items VL_GUARDED_BY(m_mutex);  ///< List of all items
 
     VerilatedCovImpItem* m_insertp VL_GUARDED_BY(m_mutex);  ///< Item about to insert
-    const char*         m_insertFilenamep VL_GUARDED_BY(m_mutex);  ///< Filename about to insert
-    int                 m_insertLineno VL_GUARDED_BY(m_mutex);  ///< Line number about to insert
+    const char* m_insertFilenamep VL_GUARDED_BY(m_mutex);  ///< Filename about to insert
+    int m_insertLineno VL_GUARDED_BY(m_mutex);  ///< Line number about to insert
 
     // CONSTRUCTORS
     VerilatedCovImp() {
@@ -112,6 +112,7 @@ private:
         m_insertLineno = 0;
     }
     VL_UNCOPYABLE(VerilatedCovImp);
+
 public:
     ~VerilatedCovImp() { clearGuts(); }
     static VerilatedCovImp& imp() VL_MT_SAFE {
@@ -122,10 +123,11 @@ public:
 private:
     // PRIVATE METHODS
     int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
-        static int nextIndex = KEY_UNDEF+1;
+        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);
+        nextIndex++;
+        assert(nextIndex > 0);  // Didn't rollover
         m_valueIndexes.insert(std::make_pair(value, nextIndex));
         m_indexValues.insert(std::make_pair(nextIndex, value));
         return nextIndex;
@@ -134,8 +136,9 @@ private:
         // Quote any special characters
         std::string rtn;
         for (const char* pos = text.c_str(); *pos; ++pos) {
-            if (!isprint(*pos) || *pos=='%' || *pos=='"') {
-                char hex[10]; sprintf(hex, "%%%02X", pos[0]);
+            if (!isprint(*pos) || *pos == '%' || *pos == '"') {
+                char hex[10];
+                sprintf(hex, "%%%02X", pos[0]);
                 rtn += hex;
             } else {
                 rtn += *pos;
@@ -148,18 +151,19 @@ private:
         // 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;
+        if (key.length() < 2) return false;
+        if (key.length() == 2 && isdigit(key[1])) return false;
         return true;
     }
-    static std::string keyValueFormatter(const std::string& key, const std::string& value) VL_PURE {
+    static std::string keyValueFormatter(const std::string& key,
+                                         const std::string& value) VL_PURE {
         std::string name;
-        if (key.length()==1 && isalpha(key[0])) {
-            name += std::string("\001")+key;
+        if (key.length() == 1 && isalpha(key[0])) {
+            name += std::string("\001") + key;
         } else {
-            name += std::string("\001")+dequote(key);
+            name += std::string("\001") + dequote(key);
         }
-        name += std::string("\002")+dequote(value);
+        name += std::string("\002") + dequote(value);
         return name;
     }
     static std::string combineHier(const std::string& old, const std::string& add) VL_PURE {
@@ -176,28 +180,35 @@ private:
         // Scan forward to first mismatch
         const char* apre = a;
         const char* bpre = b;
-        while (*apre == *bpre) { apre++; bpre++; }
+        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
-        std::string prefix = std::string(a, apre-a);
+        std::string prefix = std::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--; }
+        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
-        std::string suffix = *bpost ? std::string(bpost+1) : "";
+        std::string suffix = *bpost ? std::string(bpost + 1) : "";
 
-        std::string out = prefix+"*"+suffix;
+        std::string out = prefix + "*" + suffix;
 
-        //cout << "\nch pre="<<prefix<<"  s="<<suffix<<"\nch a="<<old<<"\nch b="<<add<<"\nch o="<<out<<endl;
+        // cout << "\nch pre="<<prefix<<"  s="<<suffix<<"\nch a="<<old<<"\nch b="<<add
+        // <<"\ncho="<<out<<endl;
         return out;
     }
-    bool itemMatchesString(VerilatedCovImpItem* itemp, const std::string& match) VL_REQUIRES(m_mutex) {
-        for (int i=0; i<MAX_KEYS; ++i) {
+    bool itemMatchesString(VerilatedCovImpItem* itemp, const std::string& match)
+        VL_REQUIRES(m_mutex) {
+        for (int i = 0; i < MAX_KEYS; ++i) {
             if (itemp->m_keys[i] != KEY_UNDEF) {
                 // We don't compare keys, only values
                 std::string val = m_indexValues[itemp->m_vals[i]];
@@ -210,19 +221,25 @@ private:
     }
     static void selftest() VL_MT_SAFE {
         // Little selftest
-        if (combineHier("a.b.c","a.b.c")     !="a.b.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("a.b.c","a.b")       !="a.b*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("a.x.c","a.y.c")     !="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("a.z.z.z.c","a.b.c") !="a.*.c") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("z","a")             !="*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("q.a","q.b")         !="q.*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("q.za","q.zb")       !="q.z*") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
-        if (combineHier("1.2.3.a","9.8.7.a") !="*.a") VL_FATAL_MT(__FILE__,__LINE__,"","%Error: selftest\n");
+#define VL_CST_CHECK(got, exp) \
+    do { \
+        if ((got) != (exp)) VL_FATAL_MT(__FILE__, __LINE__, "", "%Error: selftest\n"); \
+    } while (0)
+
+        VL_CST_CHECK(combineHier("a.b.c", "a.b.c"), "a.b.c");
+        VL_CST_CHECK(combineHier("a.b.c", "a.b"), "a.b*");
+        VL_CST_CHECK(combineHier("a.x.c", "a.y.c"), "a.*.c");
+        VL_CST_CHECK(combineHier("a.z.z.z.c", "a.b.c"), "a.*.c");
+        VL_CST_CHECK(combineHier("z", "a"), "*");
+        VL_CST_CHECK(combineHier("q.a", "q.b"), "q.*");
+        VL_CST_CHECK(combineHier("q.za", "q.zb"), "q.z*");
+        VL_CST_CHECK(combineHier("1.2.3.a", "9.8.7.a"), "*.a");
+#undef VL_CST_CHECK
     }
     void clearGuts() VL_REQUIRES(m_mutex) {
-        for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+        for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
             VerilatedCovImpItem* itemp = *(it);
-            delete itemp;
+            VL_DO_DANGLING(delete itemp, itemp);
         }
         m_items.clear();
         m_indexValues.clear();
@@ -241,10 +258,10 @@ public:
         VerilatedLockGuard lock(m_mutex);
         if (matchp && matchp[0]) {
             ItemList newlist;
-            for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+            for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
                 VerilatedCovImpItem* itemp = *(it);
                 if (!itemMatchesString(itemp, matchp)) {
-                    delete itemp;
+                    VL_DO_DANGLING(delete itemp, itemp);
                 } else {
                     newlist.push_back(itemp);
                 }
@@ -255,7 +272,7 @@ public:
     void zero() VL_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         VerilatedLockGuard lock(m_mutex);
-        for (ItemList::const_iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+        for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
             (*it)->zero();
         }
     }
@@ -271,33 +288,33 @@ public:
         m_insertFilenamep = filenamep;
         m_insertLineno = lineno;
     }
-    void insertp(const char* ckeyps[MAX_KEYS],
-                 const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
+    void insertp(const char* ckeyps[MAX_KEYS], const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
         VerilatedLockGuard lock(m_mutex);
         assert(m_insertp);
         // First two key/vals are filename
-        ckeyps[0]="filename";   valps[0]=m_insertFilenamep;
+        ckeyps[0] = "filename";
+        valps[0] = m_insertFilenamep;
         std::string linestr = vlCovCvtToStr(m_insertLineno);
-        ckeyps[1]="lineno";     valps[1]=linestr.c_str();
+        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;
+        while (const char* foundp = strchr(fnstartp, '/')) fnstartp = foundp + 1;
         const char* fnendp = fnstartp;
-        while (*fnendp && *fnendp!='.') fnendp++;
-        std::string page_default = "sp_user/"+std::string(fnstartp, fnendp-fnstartp);
-        ckeyps[2]="page";       valps[2]=page_default.c_str();
+        for (; *fnendp && *fnendp != '.'; fnendp++) {}
+        std::string page_default = "sp_user/" + std::string(fnstartp, fnendp - fnstartp);
+        ckeyps[2] = "page";
+        valps[2] = page_default.c_str();
 
         // Keys -> strings
         std::string keys[MAX_KEYS];
-        for (int i=0; i<MAX_KEYS; ++i) {
-            if (ckeyps[i] && ckeyps[i][0]) {
-                keys[i] = ckeyps[i];
-            }
+        for (int i = 0; i < MAX_KEYS; ++i) {
+            if (ckeyps[i] && ckeyps[i][0]) { keys[i] = ckeyps[i]; }
         }
         // Ignore empty keys
-        for (int i=0; i<MAX_KEYS; ++i) {
+        for (int i = 0; i < MAX_KEYS; ++i) {
             if (!keys[i].empty()) {
-                for (int j=i+1; j<MAX_KEYS; ++j) {
+                for (int j = i + 1; j < MAX_KEYS; ++j) {
                     if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
                         keys[i] = "";
                         break;
@@ -307,18 +324,18 @@ public:
         }
         // Insert the values
         int addKeynum = 0;
-        for (int i=0; i<MAX_KEYS; ++i) {
+        for (int i = 0; i < MAX_KEYS; ++i) {
             const std::string key = keys[i];
             if (!keys[i].empty()) {
                 const std::string val = valps[i];
-                //cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
+                // cout<<"   "<<__FUNCTION__<<"  "<<key<<" = "<<val<<endl;
                 m_insertp->m_keys[addKeynum] = valueIndex(key);
                 m_insertp->m_vals[addKeynum] = valueIndex(val);
                 addKeynum++;
                 if (!legalKey(key)) {
                     std::string msg
                         = ("%Error: Coverage keys of one character, or letter+digit are illegal: "
-                           +key);
+                           + key);
                     VL_FATAL_MT("", 0, "", msg.c_str());
                 }
             }
@@ -338,22 +355,22 @@ public:
 
         std::ofstream os(filename);
         if (os.fail()) {
-            std::string msg = std::string("%Error: Can't write '")+filename+"'";
+            std::string msg = std::string("%Error: Can't write '") + filename + "'";
             VL_FATAL_MT("", 0, "", msg.c_str());
             return;
         }
         os << "# SystemC::Coverage-3\n";
 
         // Build list of events; totalize if collapsing hierarchy
-        typedef std::map<std::string,std::pair<std::string,vluint64_t> > EventMap;
+        typedef std::map<std::string, std::pair<std::string, vluint64_t> > EventMap;
         EventMap eventCounts;
-        for (ItemList::iterator it=m_items.begin(); it!=m_items.end(); ++it) {
+        for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
             VerilatedCovImpItem* itemp = *(it);
             std::string name;
             std::string hier;
             bool per_instance = false;
 
-            for (int i=0; i<MAX_KEYS; ++i) {
+            for (int i = 0; i < MAX_KEYS; ++i) {
                 if (itemp->m_keys[i] != KEY_UNDEF) {
                     std::string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
                     std::string val = m_indexValues[itemp->m_vals[i]];
@@ -383,19 +400,19 @@ public:
             if (cit != eventCounts.end()) {
                 const std::string& oldhier = cit->second.first;
                 cit->second.second += itemp->count();
-                cit->second.first  = combineHier(oldhier, hier);
+                cit->second.first = combineHier(oldhier, hier);
             } else {
                 eventCounts.insert(std::make_pair(name, make_pair(hier, itemp->count())));
             }
         }
 
         // Output body
-        for (EventMap::const_iterator it=eventCounts.begin(); it!=eventCounts.end(); ++it) {
-            os<<"C '"<<std::dec;
-            os<<it->first;
-            if (!it->second.first.empty()) os<<keyValueFormatter(VL_CIK_HIER, it->second.first);
-            os<<"' "<<it->second.second;
-            os<<std::endl;
+        for (EventMap::const_iterator it = eventCounts.begin(); it != eventCounts.end(); ++it) {
+            os << "C '" << std::dec;
+            os << it->first;
+            if (!it->second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, it->second.first);
+            os << "' " << it->second.second;
+            os << std::endl;
         }
     }
 };
@@ -403,15 +420,11 @@ public:
 //=============================================================================
 // VerilatedCov
 
-void VerilatedCov::clear() VL_MT_SAFE {
-    VerilatedCovImp::imp().clear();
-}
+void VerilatedCov::clear() VL_MT_SAFE { VerilatedCovImp::imp().clear(); }
 void VerilatedCov::clearNonMatch(const char* matchp) VL_MT_SAFE {
     VerilatedCovImp::imp().clearNonMatch(matchp);
 }
-void VerilatedCov::zero() VL_MT_SAFE {
-    VerilatedCovImp::imp().zero();
-}
+void VerilatedCov::zero() VL_MT_SAFE { VerilatedCovImp::imp().zero(); }
 void VerilatedCov::write(const char* filenamep) VL_MT_SAFE {
     VerilatedCovImp::imp().write(filenamep);
 }
@@ -425,48 +438,49 @@ void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
     VerilatedCovImp::imp().insertf(filename, lineno);
 }
 
-#define K(n) const char* key ## n
-#define A(n) const char* key ## n, const char* valp ## n  // Argument list
-#define C(n) key ## n, valp ## 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)) VL_MT_SAFE {
+#define K(n) const char* key##n
+#define A(n) const char *key##n, const char *valp##n  // Argument list
+#define C(n) key##n, valp##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)) VL_MT_SAFE {
     const char* keyps[VerilatedCovImpBase::MAX_KEYS]
-        = {NULL,NULL,NULL,  // filename,lineno,page
-           key0,key1,key2,key3,key4,key5,key6,key7,key8,key9,
-           key10,key11,key12,key13,key14,key15,key16,key17,key18,key19,
-           key20,key21,key22,key23,key24,key25,key26,key27,key28,key29};
+        = {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
-           valp0,valp1,valp2,valp3,valp4,valp5,valp6,valp7,valp8,valp9,
-           valp10,valp11,valp12,valp13,valp14,valp15,valp16,valp17,valp18,valp19,
-           valp20,valp21,valp22,valp23,valp24,valp25,valp26,valp27,valp28,valp29};
+        = {NULL,   NULL,   NULL,  // filename,lineno,page
+           valp0,  valp1,  valp2,  valp3,  valp4,  valp5,  valp6,  valp7,  valp8,  valp9,
+           valp10, valp11, valp12, valp13, valp14, valp15, valp16, valp17, valp18, valp19,
+           valp20, valp21, valp22, valp23, valp24, valp25, valp26, valp27, valp28, valp29};
     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)) VL_MT_SAFE {
-    _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
-             N(10),N(11),N(12),N(13),N(14),N(15),N(16),N(17),N(18),N(19),
-             N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
+void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8),
+                            A(9)) VL_MT_SAFE {
+    _insertp(C(0), C(1), C(2), C(3), C(4), C(5), C(6), C(7), C(8), C(9), N(10), N(11), N(12),
+             N(13), N(14), N(15), N(16), N(17), N(18), N(19), N(20), N(21), N(22), N(23), N(24),
+             N(25), N(26), N(27), N(28), N(29));
 }
-void VerilatedCov::_insertp(A(0),A(1),A(2),A(3),A(4),A(5),A(6),A(7),A(8),A(9),
-                            A(10),A(11),A(12),A(13),A(14),A(15),A(16),A(17),A(18),A(19)) VL_MT_SAFE {
-    _insertp(C(0),C(1),C(2),C(3),C(4),C(5),C(6),C(7),C(8),C(9),
-             C(10),C(11),C(12),C(13),C(14),C(15),C(16),C(17),C(18),C(19),
-             N(20),N(21),N(22),N(23),N(24),N(25),N(26),N(27),N(28),N(29));
+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)) VL_MT_SAFE {
+    _insertp(C(0), C(1), C(2), C(3), C(4), C(5), C(6), C(7), C(8), C(9), C(10), C(11), C(12),
+             C(13), C(14), C(15), C(16), C(17), C(18), C(19), N(20), N(21), N(22), N(23), N(24),
+             N(25), N(26), N(27), N(28), N(29));
 }
 // Backward compatibility for Verilator
-void VerilatedCov::_insertp(A(0), A(1),  K(2),int val2,  K(3),int val3,
-                            K(4),const std::string& val4,  A(5),A(6)) VL_MT_SAFE {
+void VerilatedCov::_insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4),
+                            const std::string& val4, A(5), A(6)) VL_MT_SAFE {
     std::string val2str = vlCovCvtToStr(val2);
     std::string val3str = vlCovCvtToStr(val3);
-    _insertp(C(0),C(1),
-             key2,val2str.c_str(),  key3,val3str.c_str(),  key4, val4.c_str(),
-             C(5),C(6),N(7),N(8),N(9),
-             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));
+    _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

include/verilated_cov.h

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -31,11 +28,17 @@
 //=============================================================================
 /// Conditionally compile coverage code
 
+// clang-format off
 #ifdef VM_COVERAGE
-# define VL_IF_COVER(stmts) do { stmts ; } while(0)
+# define VL_IF_COVER(stmts) \
+    do { stmts; } while (false)
 #else
-# define VL_IF_COVER(stmts) do { if(0) { stmts ; } } while(0)
+# define VL_IF_COVER(stmts) \
+    do { \
+        if (false) { stmts; } \
+    } while (false)
 #endif
+// clang-format on
 
 //=============================================================================
 /// Insert a item for coverage analysis.
@@ -65,16 +68,17 @@
 ///             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))
+#define VL_COVER_INSERT(countp, ...) \
+    VL_IF_COVER(VerilatedCov::_inserti(countp); VerilatedCov::_insertf(__FILE__, __LINE__); \
+                VerilatedCov::_insertp("hier", name(), __VA_ARGS__))
 
 //=============================================================================
 /// Convert VL_COVER_INSERT value arguments to strings
 
-template< class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
-    std::ostringstream os; os<<t; return os.str();
+template <class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
+    std::ostringstream os;
+    os << t;
+    return os.str();
 }
 
 //=============================================================================
@@ -86,6 +90,7 @@ template< class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
 
 class VerilatedCov {
     VL_UNCOPYABLE(VerilatedCov);
+
 public:
     // GLOBAL METHODS
     /// Return default filename
@@ -105,18 +110,18 @@ public:
     // 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));
+#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 std::string& val4,  A(5),A(6));
+    static void _insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4), const std::string& val4,
+                         A(5), A(6));
 
 #undef K
 #undef A

include/verilated_cov_key.h

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -31,6 +28,7 @@
 
 #define VLCOVGEN_ITEM(string_parsed_by_vlcovgen)
 
+// clang-format off
 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, ")
@@ -62,6 +60,7 @@ 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'")
+// clang-format on
 
 // VLCOVGEN_CIK_AUTO_EDIT_BEGIN
 #define VL_CIK_COL0 "c0"

include/verilated_dpi.cpp

@@ -1,15 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=========================================================================
 ///
@@ -44,88 +40,80 @@
 // Not supported yet
 #define _VL_SVDPI_UNIMP() \
     VL_FATAL_MT(__FILE__, __LINE__, "", \
-                (std::string("%%Error: Unsupported DPI function: ")+VL_FUNC).c_str())
+                (std::string("%%Error: Unsupported DPI function: ") + VL_FUNC).c_str())
 
-#define _VL_SVDPI_WARN(message...) \
-    VL_PRINTF_MT(message)
+#define _VL_SVDPI_WARN(...) VL_PRINTF_MT(__VA_ARGS__)
 
 // Function requires a "context" in the import declaration
 #define _VL_SVDPI_CONTEXT_WARN() \
-    _VL_SVDPI_WARN("%%Warning: DPI C Function called by Verilog DPI import with missing 'context' keyword.\n");
+    _VL_SVDPI_WARN("%%Warning: DPI C Function called by Verilog DPI import with missing " \
+                   "'context' keyword.\n");
 
 //======================================================================
 //======================================================================
 //======================================================================
 // DPI ROUTINES
 
-const char* svDpiVersion() {
-    return "1800-2005";
-}
+const char* svDpiVersion() { return "1800-2005"; }
 
 //======================================================================
 // Bit-select utility functions.
 
-svBit svGetBitselBit(const svBitVecVal* sp, int bit) {
-    return VL_BITRSHIFT_W(sp,bit) & 1;
-}
+svBit svGetBitselBit(const svBitVecVal* sp, int bit) { return VL_BITRSHIFT_W(sp, bit) & 1; }
 svLogic svGetBitselLogic(const svLogicVecVal* sp, int bit) {
     // Not VL_BITRSHIFT_W as sp is a different structure type
     // Verilator doesn't support X/Z so only aval
     return (((sp[VL_BITWORD_I(bit)].aval >> VL_BITBIT_I(bit)) & 1)
-            | (((sp[VL_BITWORD_I(bit)].bval >> VL_BITBIT_I(bit)) & 1)<<1));
+            | (((sp[VL_BITWORD_I(bit)].bval >> VL_BITBIT_I(bit)) & 1) << 1));
 }
 
-void svPutBitselBit(svBitVecVal* dp, int bit, svBit s) {
-    VL_ASSIGNBIT_WI(32, bit, dp, s);
-}
+void svPutBitselBit(svBitVecVal* dp, int bit, svBit s) { VL_ASSIGNBIT_WI(32, bit, dp, s); }
 void svPutBitselLogic(svLogicVecVal* dp, int bit, svLogic s) {
     // Verilator doesn't support X/Z so only aval
-    dp[VL_BITWORD_I(bit)].aval
-        = ((dp[VL_BITWORD_I(bit)].aval & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
-           | ((s&1)<<VL_BITBIT_I(bit)));
-    dp[VL_BITWORD_I(bit)].bval
-        = ((dp[VL_BITWORD_I(bit)].bval & ~(VL_UL(1)<<VL_BITBIT_I(bit)))
-           | ((s&2)>>1<<VL_BITBIT_I(bit)));
+    dp[VL_BITWORD_I(bit)].aval = ((dp[VL_BITWORD_I(bit)].aval & ~(VL_UL(1) << VL_BITBIT_I(bit)))
+                                  | ((s & 1) << VL_BITBIT_I(bit)));
+    dp[VL_BITWORD_I(bit)].bval = ((dp[VL_BITWORD_I(bit)].bval & ~(VL_UL(1) << VL_BITBIT_I(bit)))
+                                  | ((s & 2) >> 1 << VL_BITBIT_I(bit)));
 }
 
 void svGetPartselBit(svBitVecVal* dp, const svBitVecVal* sp, int lsb, int width) {
     // See also VL_SEL_WWI
-    int msb = lsb+width-1;
+    int msb = lsb + width - 1;
     int word_shift = VL_BITWORD_I(lsb);
-    if (VL_BITBIT_I(lsb)==0) {
+    if (VL_BITBIT_I(lsb) == 0) {
         // Just a word extract
-        for (int i=0; i<VL_WORDS_I(width); ++i) dp[i] = sp[i+word_shift];
+        for (int i = 0; i < VL_WORDS_I(width); ++i) dp[i] = sp[i + word_shift];
     } else {
         int loffset = lsb & VL_SIZEBITS_I;
-        int nbitsfromlow = 32-loffset;  // bits that end up in lword (know loffset!=0)
+        int nbitsfromlow = 32 - loffset;  // bits that end up in lword (know loffset!=0)
         // Middle words
-        int words = VL_WORDS_I(msb-lsb+1);
-        for (int i=0; i<words; ++i) {
-            dp[i] = sp[i+word_shift]>>loffset;
-            int upperword = i+word_shift+1;
+        int words = VL_WORDS_I(msb - lsb + 1);
+        for (int i = 0; i < words; ++i) {
+            dp[i] = sp[i + word_shift] >> loffset;
+            int upperword = i + word_shift + 1;
             if (upperword <= static_cast<int>(VL_BITWORD_I(msb))) {
                 dp[i] |= sp[upperword] << nbitsfromlow;
             }
         }
     }
     // Clean result
-    dp[VL_WORDS_I(width)-1] &= VL_MASK_I(width);
+    dp[VL_WORDS_I(width) - 1] &= VL_MASK_I(width);
 }
 void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int lsb, int width) {
-    int msb = lsb+width-1;
+    int msb = lsb + width - 1;
     int word_shift = VL_BITWORD_I(lsb);
-    if (VL_BITBIT_I(lsb)==0) {
+    if (VL_BITBIT_I(lsb) == 0) {
         // Just a word extract
-        for (int i=0; i<VL_WORDS_I(width); ++i) dp[i] = sp[i+word_shift];
+        for (int i = 0; i < VL_WORDS_I(width); ++i) dp[i] = sp[i + word_shift];
     } else {
         int loffset = lsb & VL_SIZEBITS_I;
-        int nbitsfromlow = 32-loffset;  // bits that end up in lword (know loffset!=0)
+        int nbitsfromlow = 32 - loffset;  // bits that end up in lword (know loffset!=0)
         // Middle words
-        int words = VL_WORDS_I(msb-lsb+1);
-        for (int i=0; i<words; ++i) {
-            dp[i].aval = sp[i+word_shift].aval >> loffset;
-            dp[i].bval = sp[i+word_shift].bval >> loffset;
-            int upperword = i+word_shift+1;
+        int words = VL_WORDS_I(msb - lsb + 1);
+        for (int i = 0; i < words; ++i) {
+            dp[i].aval = sp[i + word_shift].aval >> loffset;
+            dp[i].bval = sp[i + word_shift].bval >> loffset;
+            int upperword = i + word_shift + 1;
             if (upperword <= static_cast<int>(VL_BITWORD_I(msb))) {
                 dp[i].aval |= sp[upperword].aval << nbitsfromlow;
                 dp[i].bval |= sp[upperword].bval << nbitsfromlow;
@@ -133,58 +121,56 @@ void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int lsb, int
         }
     }
     // Clean result
-    dp[VL_WORDS_I(width)-1].aval &= VL_MASK_I(width);
-    dp[VL_WORDS_I(width)-1].bval &= VL_MASK_I(width);
+    dp[VL_WORDS_I(width) - 1].aval &= VL_MASK_I(width);
+    dp[VL_WORDS_I(width) - 1].bval &= VL_MASK_I(width);
 }
 void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int lbit, int width) {
     // See also _VL_INSERT_WI
-    int hbit = lbit+width-1;
+    int hbit = lbit + width - 1;
     int hoffset = VL_BITBIT_I(hbit);
     int loffset = VL_BITBIT_I(lbit);
-    if (hoffset==VL_SIZEBITS_I && loffset==0) {
+    if (hoffset == VL_SIZEBITS_I && loffset == 0) {
         // Fast and common case, word based insertion
         dp[VL_BITWORD_I(lbit)] = s;
-    }
-    else {
+    } else {
         int hword = VL_BITWORD_I(hbit);
         int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {  // know < 32 bits because above checks it
-            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
-            dp[lword] = (dp[lword] & ~insmask) | ((s<<loffset) & insmask);
+        if (hword == lword) {  // know < 32 bits because above checks it
+            IData insmask = (VL_MASK_I(hoffset - loffset + 1)) << loffset;
+            dp[lword] = (dp[lword] & ~insmask) | ((s << loffset) & insmask);
         } else {
-            IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
-            IData linsmask = (VL_MASK_I(31-loffset+1))<<loffset;
-            int nbitsonright = 32-loffset;  // bits that end up in lword
-            dp[lword] = (dp[lword] & ~linsmask) | ((s<<loffset) & linsmask);
-            dp[hword] = (dp[hword] & ~hinsmask) | ((s>>nbitsonright) & hinsmask);
+            IData hinsmask = (VL_MASK_I(hoffset - 0 + 1)) << 0;
+            IData linsmask = (VL_MASK_I(31 - loffset + 1)) << loffset;
+            int nbitsonright = 32 - loffset;  // bits that end up in lword
+            dp[lword] = (dp[lword] & ~linsmask) | ((s << loffset) & linsmask);
+            dp[hword] = (dp[hword] & ~hinsmask) | ((s >> nbitsonright) & hinsmask);
         }
     }
 }
 // cppcheck-suppress passedByValue
 void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int width) {
-    int hbit = lbit+width-1;
+    int hbit = lbit + width - 1;
     int hoffset = VL_BITBIT_I(hbit);
     int loffset = VL_BITBIT_I(lbit);
-    if (hoffset==VL_SIZEBITS_I && loffset==0) {
+    if (hoffset == VL_SIZEBITS_I && loffset == 0) {
         // Fast and common case, word based insertion
         dp[VL_BITWORD_I(lbit)].aval = s.aval;
         dp[VL_BITWORD_I(lbit)].bval = s.bval;
-    }
-    else {
+    } else {
         int hword = VL_BITWORD_I(hbit);
         int lword = VL_BITWORD_I(lbit);
-        if (hword==lword) {  // know < 32 bits because above checks it
-            IData insmask = (VL_MASK_I(hoffset-loffset+1))<<loffset;
-            dp[lword].aval = (dp[lword].aval & ~insmask) | ((s.aval<<loffset) & insmask);
-            dp[lword].bval = (dp[lword].bval & ~insmask) | ((s.bval<<loffset) & insmask);
+        if (hword == lword) {  // know < 32 bits because above checks it
+            IData insmask = (VL_MASK_I(hoffset - loffset + 1)) << loffset;
+            dp[lword].aval = (dp[lword].aval & ~insmask) | ((s.aval << loffset) & insmask);
+            dp[lword].bval = (dp[lword].bval & ~insmask) | ((s.bval << loffset) & insmask);
         } else {
-            IData hinsmask = (VL_MASK_I(hoffset-0+1))<<0;
-            IData linsmask = (VL_MASK_I(31-loffset+1))<<loffset;
-            int nbitsonright = 32-loffset;  // bits that end up in lword
-            dp[lword].aval = (dp[lword].aval & ~linsmask) | ((s.aval<<loffset) & linsmask);
-            dp[lword].bval = (dp[lword].bval & ~linsmask) | ((s.bval<<loffset) & linsmask);
-            dp[hword].aval = (dp[hword].aval & ~hinsmask) | ((s.aval>>nbitsonright) & hinsmask);
-            dp[hword].bval = (dp[hword].bval & ~hinsmask) | ((s.bval>>nbitsonright) & hinsmask);
+            IData hinsmask = (VL_MASK_I(hoffset - 0 + 1)) << 0;
+            IData linsmask = (VL_MASK_I(31 - loffset + 1)) << loffset;
+            int nbitsonright = 32 - loffset;  // bits that end up in lword
+            dp[lword].aval = (dp[lword].aval & ~linsmask) | ((s.aval << loffset) & linsmask);
+            dp[lword].bval = (dp[lword].bval & ~linsmask) | ((s.bval << loffset) & linsmask);
+            dp[hword].aval = (dp[hword].aval & ~hinsmask) | ((s.aval >> nbitsonright) & hinsmask);
+            dp[hword].bval = (dp[hword].bval & ~hinsmask) | ((s.bval >> nbitsonright) & hinsmask);
         }
     }
 }
@@ -208,27 +194,14 @@ static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHa
 //======================================================================
 // Open array querying functions
 
-int svLeft(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->left(d);
-}
-int svRight(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->right(d);
-}
-int svLow(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->low(d);
-}
-int svHigh(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->high(d);
-}
-int svIncrement(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->increment(d);
-}
-int svSize(const svOpenArrayHandle h, int d) {
-    return _vl_openhandle_varp(h)->elements(d);
-}
-int svDimensions(const svOpenArrayHandle h) {
-    return _vl_openhandle_varp(h)->udims();
-}
+int svLeft(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->left(d); }
+int svRight(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->right(d); }
+int svLow(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->low(d); }
+int svHigh(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->high(d); }
+int svIncrement(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->increment(d); }
+int svSize(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h)->elements(d); }
+int svDimensions(const svOpenArrayHandle h) { return _vl_openhandle_varp(h)->udims(); }
+
 /// Return pointer to open array data, or NULL if not in IEEE standard C layout
 void* svGetArrayPtr(const svOpenArrayHandle h) {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
@@ -246,8 +219,8 @@ int svSizeOfArray(const svOpenArrayHandle h) {
 //======================================================================
 // Open array access internals
 
-static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp,
-                                   int nargs, int indx1, int indx2, int indx3) {
+static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, int indx1,
+                                   int indx2, int indx3) {
     void* datap = varp->datap();
     if (VL_UNLIKELY(nargs != varp->udims())) {
         _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function called on"
@@ -255,26 +228,29 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp,
                        varp->udims(), nargs);
         return NULL;
     }
-    if (nargs>=1) {
+    if (nargs >= 1) {
         datap = varp->datapAdjustIndex(datap, 1, indx1);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 1 out of bounds; %d outside [%d:%d].\n",
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 1 "
+                           "out of bounds; %d outside [%d:%d].\n",
                            indx1, varp->left(1), varp->right(1));
             return NULL;
         }
     }
-    if (nargs>=2) {
+    if (nargs >= 2) {
         datap = varp->datapAdjustIndex(datap, 2, indx2);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 2 out of bounds; %d outside [%d:%d].\n",
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 2 "
+                           "out of bounds; %d outside [%d:%d].\n",
                            indx2, varp->left(2), varp->right(2));
             return NULL;
         }
     }
-    if (nargs>=3) {
+    if (nargs >= 3) {
         datap = varp->datapAdjustIndex(datap, 3, indx3);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 3 out of bounds; %d outside [%d:%d].\n",
+            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 3 "
+                           "out of bounds; %d outside [%d:%d].\n",
                            indx1, varp->left(3), varp->right(3));
             return NULL;
         }
@@ -284,7 +260,8 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp,
 
 static int _vl_sv_adjusted_bit(const VerilatedDpiOpenVar* varp, int indx) {
     if (VL_UNLIKELY(indx < varp->low(0) || indx > varp->high(0))) {
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function packed index out of bounds; %d outside [%d:%d].\n",
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function packed index out of bounds; %d "
+                       "outside [%d:%d].\n",
                        indx, varp->left(0), varp->right(0));
         return 0;
     }
@@ -292,8 +269,8 @@ static int _vl_sv_adjusted_bit(const VerilatedDpiOpenVar* varp, int indx) {
 }
 
 /// Return pointer to simulator open array element, or NULL if outside range
-static void* _vl_svGetArrElemPtr(const svOpenArrayHandle h,
-                                 int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+static void* _vl_svGetArrElemPtr(const svOpenArrayHandle h, int nargs, int indx1, int indx2,
+                                 int indx3) VL_MT_SAFE {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
     if (VL_UNLIKELY(!varp->isDpiStdLayout())) return NULL;
     void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
@@ -301,23 +278,25 @@ static void* _vl_svGetArrElemPtr(const svOpenArrayHandle h,
 }
 
 /// Copy to user bit array from simulator open array
-static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
-                                      int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int nargs,
+                                      int indx1, int indx2, int indx3) VL_MT_SAFE {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
     void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  d[0] = *(reinterpret_cast<CData*>(datap)); return;
+    case VLVT_UINT8: d[0] = *(reinterpret_cast<CData*>(datap)); return;
     case VLVT_UINT16: d[0] = *(reinterpret_cast<SData*>(datap)); return;
     case VLVT_UINT32: d[0] = *(reinterpret_cast<IData*>(datap)); return;
     case VLVT_UINT64: {
-        WData lwp[2]; VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
-        d[0] = lwp[0]; d[1] = lwp[1];
+        WData lwp[2];
+        VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
+        d[0] = lwp[0];
+        d[1] = lwp[1];
         break;
     }
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) d[i] = wdatap[i];
+        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) d[i] = wdatap[i];
         return;
     }
     default:
@@ -327,25 +306,38 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
     }
 }
 /// Copy to user logic array from simulator open array
-static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-                                        int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int nargs,
+                                        int indx1, int indx2, int indx3) VL_MT_SAFE {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
     void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  d[0].aval = *(reinterpret_cast<CData*>(datap)); d[0].bval=0; return;
-    case VLVT_UINT16: d[0].aval = *(reinterpret_cast<SData*>(datap)); d[0].bval=0; return;
-    case VLVT_UINT32: d[0].aval = *(reinterpret_cast<IData*>(datap)); d[0].bval=0; return;
+    case VLVT_UINT8:
+        d[0].aval = *(reinterpret_cast<CData*>(datap));
+        d[0].bval = 0;
+        return;
+    case VLVT_UINT16:
+        d[0].aval = *(reinterpret_cast<SData*>(datap));
+        d[0].bval = 0;
+        return;
+    case VLVT_UINT32:
+        d[0].aval = *(reinterpret_cast<IData*>(datap));
+        d[0].bval = 0;
+        return;
     case VLVT_UINT64: {
-        WData lwp[2]; VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
-        d[0].aval = lwp[0]; d[0].bval=0;
-        d[1].aval = lwp[1]; d[0].bval=0;
+        WData lwp[2];
+        VL_SET_WQ(lwp, *(reinterpret_cast<QData*>(datap)));
+        d[0].aval = lwp[0];
+        d[0].bval = 0;
+        d[1].aval = lwp[1];
+        d[0].bval = 0;
         break;
     }
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) {
-            d[i].aval = wdatap[i]; d[i].bval = 0;
+        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) {
+            d[i].aval = wdatap[i];
+            d[i].bval = 0;
         }
         return;
     }
@@ -357,19 +349,19 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
 }
 
 /// Copy to simulator open array from from user bit array
-static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-                                      int nargs, int indx1, int indx2, int indx3) VL_MT_SAFE {
+static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int nargs,
+                                      int indx1, int indx2, int indx3) VL_MT_SAFE {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
     void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  *(reinterpret_cast<CData*>(datap)) = s[0]; return;
+    case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0]; return;
     case VLVT_UINT16: *(reinterpret_cast<SData*>(datap)) = s[0]; return;
     case VLVT_UINT32: *(reinterpret_cast<IData*>(datap)) = s[0]; return;
     case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1], s[0]); break;
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i];
+        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i];
         return;
     }
     default:
@@ -385,80 +377,82 @@ static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogic
     void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  *(reinterpret_cast<CData*>(datap)) = s[0].aval; return;
+    case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = s[0].aval; return;
     case VLVT_UINT16: *(reinterpret_cast<SData*>(datap)) = s[0].aval; return;
     case VLVT_UINT32: *(reinterpret_cast<IData*>(datap)) = s[0].aval; return;
-    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1].aval, s[0].aval); break;
+    case VLVT_UINT64:
+        *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1].aval, s[0].aval);
+        break;
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        for (int i=0; i<VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i].aval;
+        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i].aval;
         return;
     }
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return;
     }
 }
 
 /// Return bit from simulator open array
-static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s,
-                                 int nargs, int indx1, int indx2, int indx3, int indx4) VL_MT_SAFE {
+static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s, int nargs, int indx1, int indx2,
+                                 int indx3, int indx4) VL_MT_SAFE {
     // One extra index supported, as need bit number
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
     void* datap;
     int lsb;
     if (varp->packed().elements()) {
-        datap = _vl_sv_adjusted_datap(varp, nargs-1, indx1, indx2, indx3);
-        lsb = _vl_sv_adjusted_bit(varp, ((nargs==1) ? indx1
-                                         : (nargs==2) ? indx2
-                                         : (nargs==3) ? indx3
-                                         : indx4));
+        datap = _vl_sv_adjusted_datap(varp, nargs - 1, indx1, indx2, indx3);
+        lsb = _vl_sv_adjusted_bit(
+            varp, ((nargs == 1) ? indx1 : (nargs == 2) ? indx2 : (nargs == 3) ? indx3 : indx4));
     } else {
         datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
         lsb = 0;
     }
     if (VL_UNLIKELY(!datap)) return 0;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  return (*(reinterpret_cast<CData*>(datap)) >> lsb) & 1;
+    case VLVT_UINT8: return (*(reinterpret_cast<CData*>(datap)) >> lsb) & 1;
     case VLVT_UINT16: return (*(reinterpret_cast<SData*>(datap)) >> lsb) & 1;
     case VLVT_UINT32: return (*(reinterpret_cast<IData*>(datap)) >> lsb) & 1;
-    case VLVT_UINT64: return (*(reinterpret_cast<QData*>(datap)) >> static_cast<QData>(lsb)) & VL_ULL(1);
+    case VLVT_UINT64:
+        return (*(reinterpret_cast<QData*>(datap)) >> static_cast<QData>(lsb)) & VL_ULL(1);
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
         return VL_BITRSHIFT_W(wdatap, lsb) & 1;
     }
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return 0;
     }
 }
 /// Update simulator open array from bit
-static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value,
-                                int nargs, int indx1, int indx2, int indx3, int indx4) VL_MT_SAFE {
+static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value, int nargs, int indx1,
+                                int indx2, int indx3, int indx4) VL_MT_SAFE {
     // One extra index supported, as need bit number
     value &= 1;  // Make sure clean
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
     void* datap;
     int lsb;
     if (varp->packed().elements()) {
-        datap = _vl_sv_adjusted_datap(varp, nargs-1, indx1, indx2, indx3);
-        lsb = _vl_sv_adjusted_bit(varp, ((nargs==1) ? indx1
-                                         : (nargs==2) ? indx2
-                                         : (nargs==3) ? indx3
-                                         : indx4));
+        datap = _vl_sv_adjusted_datap(varp, nargs - 1, indx1, indx2, indx3);
+        lsb = _vl_sv_adjusted_bit(
+            varp, ((nargs == 1) ? indx1 : (nargs == 2) ? indx2 : (nargs == 3) ? indx3 : indx4));
     } else {
         datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
         lsb = 0;
     }
     if (VL_UNLIKELY(!datap)) return;
     switch (varp->vltype()) {
-    case VLVT_UINT8:  VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<CData*>(datap)), value); return;
+    case VLVT_UINT8: VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<CData*>(datap)), value); return;
     case VLVT_UINT16: VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<SData*>(datap)), value); return;
     case VLVT_UINT32: VL_ASSIGNBIT_II(-1, lsb, *(reinterpret_cast<IData*>(datap)), value); return;
     case VLVT_UINT64: VL_ASSIGNBIT_QI(-1, lsb, *(reinterpret_cast<QData*>(datap)), value); return;
-    case VLVT_WDATA:  VL_ASSIGNBIT_WI(-1, lsb, (reinterpret_cast<WDataOutP>(datap)), value); return;
+    case VLVT_WDATA: VL_ASSIGNBIT_WI(-1, lsb, (reinterpret_cast<WDataOutP>(datap)), value); return;
     default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n", varp->vltype());
+        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+                       varp->vltype());
         return;
     }
 }
@@ -474,10 +468,17 @@ void* svGetArrElemPtr(const svOpenArrayHandle h, int indx1, ...) {
     // va_arg is a macro, so need temporaries as used below
     switch (varp->udims()) {
     case 1: datap = _vl_svGetArrElemPtr(h, 1, indx1, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            datap = _vl_svGetArrElemPtr(h, 2, indx1, indx2, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            datap = _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        datap = _vl_svGetArrElemPtr(h, 2, indx1, indx2, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        datap = _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3);
+        break;
+    }
     default: datap = _vl_svGetArrElemPtr(h, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
@@ -493,116 +494,134 @@ void* svGetArrElemPtr3(const svOpenArrayHandle h, int indx1, int indx2, int indx
     return _vl_svGetArrElemPtr(h, 3, indx1, indx2, indx3);
 }
 
-void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-                           int indx1, ...) {
+void svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1, ...) {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
     va_list ap;
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svPutBitArrElemVecVal(d, s, 1, indx1, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
+        break;
+    }
     default: _vl_svPutBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
-void svPutBitArrElem1VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-                            int indx1) {
+void svPutBitArrElem1VecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1) {
     _vl_svPutBitArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
-void svPutBitArrElem2VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-                            int indx1, int indx2) {
+void svPutBitArrElem2VecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1,
+                            int indx2) {
     _vl_svPutBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
-void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s,
-                            int indx1, int indx2, int indx3) {
+void svPutBitArrElem3VecVal(const svOpenArrayHandle d, const svBitVecVal* s, int indx1, int indx2,
+                            int indx3) {
     _vl_svPutBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
-void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-                             int indx1, ...) {
+void svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1, ...) {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(d);
     va_list ap;
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svPutLogicArrElemVecVal(d, s, 1, indx1, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
+        break;
+    }
     default: _vl_svPutLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
-void svPutLogicArrElem1VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-                              int indx1) {
+void svPutLogicArrElem1VecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1) {
     _vl_svPutLogicArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
-void svPutLogicArrElem2VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-                              int indx1, int indx2) {
+void svPutLogicArrElem2VecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1,
+                              int indx2) {
     _vl_svPutLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
-void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s,
-                              int indx1, int indx2, int indx3) {
+void svPutLogicArrElem3VecVal(const svOpenArrayHandle d, const svLogicVecVal* s, int indx1,
+                              int indx2, int indx3) {
     _vl_svPutLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 
 //======================================================================
 // From simulator storage into user space
 
-void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
-                           int indx1, ...) {
+void svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1, ...) {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
     va_list ap;
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svGetBitArrElemVecVal(d, s, 1, indx1, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
+        break;
+    }
     default: _vl_svGetBitArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
-void svGetBitArrElem1VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-                            int indx1) {
+void svGetBitArrElem1VecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1) {
     _vl_svGetBitArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
-void svGetBitArrElem2VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-                            int indx1, int indx2) {
+void svGetBitArrElem2VecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1, int indx2) {
     _vl_svGetBitArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
-void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s,
-                            int indx1, int indx2, int indx3) {
+void svGetBitArrElem3VecVal(svBitVecVal* d, const svOpenArrayHandle s, int indx1, int indx2,
+                            int indx3) {
     _vl_svGetBitArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
-void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-                             int indx1, ...) {
+void svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1, ...) {
     const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(s);
     va_list ap;
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svGetLogicArrElemVecVal(d, s, 1, indx1, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
+        break;
+    }
     default: _vl_svGetLogicArrElemVecVal(d, s, -1, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
 }
-void svGetLogicArrElem1VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-                              int indx1) {
+void svGetLogicArrElem1VecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1) {
     _vl_svGetLogicArrElemVecVal(d, s, 1, indx1, 0, 0);
 }
-void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-                              int indx1, int indx2) {
+void svGetLogicArrElem2VecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1, int indx2) {
     _vl_svGetLogicArrElemVecVal(d, s, 2, indx1, indx2, 0);
 }
-void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s,
-                              int indx1, int indx2, int indx3) {
+void svGetLogicArrElem3VecVal(svLogicVecVal* d, const svOpenArrayHandle s, int indx1, int indx2,
+                              int indx3) {
     _vl_svGetLogicArrElemVecVal(d, s, 3, indx1, indx2, indx3);
 }
 
@@ -613,12 +632,24 @@ svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: out = _vl_svGetBitArrElem(s, 1, indx1, 0, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
-    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0);
+        break;
+    }
+    case 4: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        int indx4 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4);
+        break;
+    }
     default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
@@ -641,12 +672,24 @@ svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: out = _vl_svGetBitArrElem(s, 1, indx1, 0, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0); break; }
-    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
-            out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 2, indx1, indx2, 0, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 3, indx1, indx2, indx3, 0);
+        break;
+    }
+    case 4: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        int indx4 = va_arg(ap, int);
+        out = _vl_svGetBitArrElem(s, 4, indx1, indx2, indx3, indx4);
+        break;
+    }
     default: out = _vl_svGetBitArrElem(s, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
@@ -671,12 +714,24 @@ void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svPutBitArrElem(d, value, 1, indx1, 0, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
-    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0);
+        break;
+    }
+    case 4: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        int indx4 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4);
+        break;
+    }
     default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
@@ -697,12 +752,24 @@ void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...)
     va_start(ap, indx1);
     switch (varp->udims()) {
     case 1: _vl_svPutBitArrElem(d, value, 1, indx1, 0, 0, 0); break;
-    case 2: { int indx2=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0); break; }
-    case 3: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0); break; }
-    case 4: { int indx2=va_arg(ap,int); int indx3=va_arg(ap,int); int indx4=va_arg(ap,int);
-            _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4); break; }
+    case 2: {
+        int indx2 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 2, indx1, indx2, 0, 0);
+        break;
+    }
+    case 3: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 3, indx1, indx2, indx3, 0);
+        break;
+    }
+    case 4: {
+        int indx2 = va_arg(ap, int);
+        int indx3 = va_arg(ap, int);
+        int indx4 = va_arg(ap, int);
+        _vl_svPutBitArrElem(d, value, 4, indx1, indx2, indx3, indx4);
+        break;
+    }
     default: _vl_svPutBitArrElem(d, value, -1, 0, 0, 0, 0); break;  // Will error
     }
     va_end(ap);
@@ -711,13 +778,12 @@ void svPutLogicArrElem1(const svOpenArrayHandle d, svLogic value, int indx1) {
     // Verilator doesn't support X/Z so can just call Bit version
     svPutBitArrElem1(d, value, indx1);
 }
-void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value,
-                        int indx1, int indx2) {
+void svPutLogicArrElem2(const svOpenArrayHandle d, svLogic value, int indx1, int indx2) {
     // Verilator doesn't support X/Z so can just call Bit version
     svPutBitArrElem2(d, value, indx1, indx2);
 }
-void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value,
-                        int indx1, int indx2, int indx3) {
+void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int indx2,
+                        int indx3) {
     // Verilator doesn't support X/Z so can just call Bit version
     svPutBitArrElem3(d, value, indx1, indx2, indx3);
 }
@@ -726,7 +792,10 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value,
 // Functions for working with DPI context
 
 svScope svGetScope() {
-    if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return NULL; }
+    if (VL_UNLIKELY(!Verilated::dpiInContext())) {
+        _VL_SVDPI_CONTEXT_WARN();
+        return NULL;
+    }
     // NOLINTNEXTLINE(google-readability-casting)
     return (svScope)(Verilated::dpiScope());
 }
@@ -750,16 +819,19 @@ svScope svGetScopeFromName(const char* scopeName) {
 }
 
 int svPutUserData(const svScope scope, void* userKey, void* userData) {
-    VerilatedImp::userInsert(scope,userKey,userData);
+    VerilatedImp::userInsert(scope, userKey, userData);
     return 0;
 }
 
 void* svGetUserData(const svScope scope, void* userKey) {
-    return VerilatedImp::userFind(scope,userKey);
+    return VerilatedImp::userFind(scope, userKey);
 }
 
-int svGetCallerInfo(const char** fileNamepp, int *lineNumberp) {
-    if (VL_UNLIKELY(!Verilated::dpiInContext())) { _VL_SVDPI_CONTEXT_WARN(); return false; }
+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;

include/verilated_dpi.h

@@ -1,15 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //*************************************************************************
 ///
@@ -36,45 +32,59 @@
 //===================================================================
 // SETTING OPERATORS
 
-/// Return WData from svBitVecVal
+/// Convert svBitVecVal to Verilator internal data
 static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, const svBitVecVal* lwp) VL_MT_SAFE {
     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);
+    for (int i = 0; i < words - 1; ++i) owp[i] = lwp[i];
+    owp[words - 1] = lwp[words - 1] & VL_MASK_I(obits);
 }
-/// Return svBitVecVal from WData
+static inline QData VL_SET_Q_SVBV(const svBitVecVal* lwp) VL_MT_SAFE {
+    return _VL_SET_QII(lwp[1], lwp[0]);
+}
+static inline IData VL_SET_I_SVBV(const svBitVecVal* lwp) VL_MT_SAFE { return lwp[0]; }
+
+/// Convert Verilator internal data to svBitVecVal
 static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
-    for (int i=0; i<words-1; ++i) owp[i]=lwp[i];
-    owp[words-1] = lwp[words-1] & VL_MASK_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_I(int, svBitVecVal* owp, IData ld) VL_MT_SAFE { owp[0] = ld; }
+static inline void VL_SET_SVBV_Q(int, svBitVecVal* owp, QData ld) VL_MT_SAFE {
+    VL_SET_WQ(owp, ld);
 }
 
-/// Convert svLogicVecVal to/from WData
+/// Convert svLogicVecVal to Verilator internal data
 /// Note these functions ignore X/Z in svLogicVecVal
 static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, const svLogicVecVal* lwp) VL_MT_SAFE {
     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);
+    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 QData VL_SET_Q_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE {
     return _VL_SET_QII(lwp[1].aval, lwp[0].aval);
 }
-static inline IData VL_SET_I_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE {
-    return lwp[0].aval;
-}
+static inline IData VL_SET_I_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE { return lwp[0].aval; }
+
+/// Convert Verilator internal data to svLogicVecVal
+/// Note these functions never create X/Z in svLogicVecVal
 static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     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);
+    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);
 }
 static inline void VL_SET_SVLV_I(int, svLogicVecVal* owp, IData ld) VL_MT_SAFE {
-    owp[0].aval=ld; owp[0].bval=0;
+    owp[0].aval = ld;
+    owp[0].bval = 0;
 }
 static inline void VL_SET_SVLV_Q(int, svLogicVecVal* owp, QData ld) VL_MT_SAFE {
-    WData lwp[2]; VL_SET_WQ(lwp,ld);
-    owp[0].aval=lwp[0]; owp[0].bval=0;
-    owp[1].aval=lwp[1]; owp[1].bval=0;
+    WData lwp[2];
+    VL_SET_WQ(lwp, ld);
+    owp[0].aval = lwp[0];
+    owp[0].bval = 0;
+    owp[1].aval = lwp[1];
+    owp[1].bval = 0;
 }
 
 //======================================================================

include/verilated_fst_c.cpp

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -20,17 +17,20 @@
 //=============================================================================
 // SPDIFF_OFF
 
-#include "verilatedos.h"
+// clang-format off
+
+#define __STDC_LIMIT_MACROS  // UINT64_MAX
 #include "verilated.h"
 #include "verilated_fst_c.h"
 
 // GTKWave configuration
-#ifdef VL_TRACE_THREADED
+#ifdef VL_TRACE_FST_WRITER_THREAD
 # define HAVE_LIBPTHREAD
 # define FST_WRITER_PARALLEL
 #endif
 
 // Include the GTKWave implementation directly
+#define FST_CONFIG_INCLUDE "fst_config.h"
 #include "gtkwave/fastlz.c"
 #include "gtkwave/fstapi.c"
 #include "gtkwave/lz4.c"
@@ -46,51 +46,45 @@
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
 #else
+# include <stdint.h>
 # include <unistd.h>
 #endif
 
-//=============================================================================
+// clang-format on
 
-class VerilatedFstCallInfo {
-protected:
-    friend class VerilatedFst;
-    VerilatedFstCallback_t m_initcb;  ///< Initialization Callback function
-    VerilatedFstCallback_t m_fullcb;  ///< Full Dumping Callback function
-    VerilatedFstCallback_t m_changecb;  ///< Incremental Dumping Callback function
-    void* m_userthis;  ///< Fake "this" for caller
-    vluint32_t m_code;  ///< Starting code number
-    // CONSTRUCTORS
-    VerilatedFstCallInfo(VerilatedFstCallback_t icb, VerilatedFstCallback_t fcb,
-                         VerilatedFstCallback_t changecb,
-                         void* ut, vluint32_t code)
-        : m_initcb(icb), m_fullcb(fcb), m_changecb(changecb), m_userthis(ut), m_code(code) {}
-    ~VerilatedFstCallInfo() {}
-};
+//=============================================================================
+// Specialization of the generics for this trace format
+
+#define VL_DERIVED_T VerilatedFst
+#include "verilated_trace_imp.cpp"
+#undef VL_DERIVED_T
 
 //=============================================================================
 // VerilatedFst
 
 VerilatedFst::VerilatedFst(void* fst)
-    : m_fst(fst),
-      m_fullDump(true),
-      m_scopeEscape('.') {
-    m_valueStrBuffer.reserve(64+1);  // Need enough room for quad
+    : m_fst(fst)
+    , m_symbolp(NULL)
+    , m_strbuf(NULL) {}
+
+VerilatedFst::~VerilatedFst() {
+    if (m_fst) fstWriterClose(m_fst);
+    if (m_symbolp) VL_DO_CLEAR(delete[] m_symbolp, m_symbolp = NULL);
+    if (m_strbuf) VL_DO_CLEAR(delete[] m_strbuf, m_strbuf = NULL);
 }
 
 void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
     m_assertOne.check();
     m_fst = fstWriterCreate(filename, 1);
     fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
-#ifdef VL_TRACE_THREADED
+    fstWriterSetTimescaleFromString(m_fst, timeResStr().c_str());  // lintok-begin-on-ref
+#ifdef VL_TRACE_FST_WRITER_THREAD
     fstWriterSetParallelMode(m_fst, 1);
 #endif
+
     m_curScope.clear();
 
-    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
-        VerilatedFstCallInfo* cip = m_callbacks[ent];
-        cip->m_code = 1;
-        (cip->m_initcb)(this, cip->m_userthis, cip->m_code);
-    }
+    VerilatedTrace<VerilatedFst>::traceInit();
 
     // Clear the scope stack
     std::list<std::string>::iterator it = m_curScope.begin();
@@ -98,26 +92,51 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
         fstWriterSetUpscope(m_fst);
         it = m_curScope.erase(it);
     }
+
+    // convert m_code2symbol into an array for fast lookup
+    if (!m_symbolp) {
+        m_symbolp = new fstHandle[nextCode()];
+        for (Code2SymbolType::iterator it = m_code2symbol.begin(); it != m_code2symbol.end();
+             ++it) {
+            m_symbolp[it->first] = it->second;
+        }
+    }
+    m_code2symbol.clear();
+
+    // Allocate string buffer for arrays
+    if (!m_strbuf) { m_strbuf = new char[maxBits() + 32]; }
 }
 
-void VerilatedFst::module(const std::string& name) {
-    m_module = name;
+void VerilatedFst::close() {
+    m_assertOne.check();
+    VerilatedTrace<VerilatedFst>::close();
+    fstWriterClose(m_fst);
+    m_fst = NULL;
 }
 
+void VerilatedFst::flush() {
+    VerilatedTrace<VerilatedFst>::flush();
+    fstWriterFlushContext(m_fst);
+}
+
+void VerilatedFst::emitTimeChange(vluint64_t timeui) { fstWriterEmitTimeChange(m_fst, timeui); }
+
 //=============================================================================
 // Decl
 
 void VerilatedFst::declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
-                                 unsigned int minValbits,
-                                 const char** itemNamesp, const char** itemValuesp) {
-    fstEnumHandle enumNum = fstWriterCreateEnumTable(m_fst, name, elements,
-                                                     minValbits, itemNamesp, itemValuesp);
+                                 unsigned int minValbits, const char** itemNamesp,
+                                 const char** itemValuesp) {
+    fstEnumHandle enumNum
+        = fstWriterCreateEnumTable(m_fst, name, elements, minValbits, itemNamesp, itemValuesp);
     m_local2fstdtype[dtypenum] = enumNum;
 }
 
-void VerilatedFst::declSymbol(vluint32_t code, const char* name,
-                              int dtypenum, fstVarDir vardir, fstVarType vartype,
-                              int arraynum, vluint32_t len) {
+void VerilatedFst::declSymbol(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                              fstVarType vartype, bool array, int arraynum, vluint32_t len,
+                              vluint32_t bits) {
+    VerilatedTrace<VerilatedFst>::declCode(code, bits, false);
+
     std::pair<Code2SymbolType::iterator, bool> p
         = m_code2symbol.insert(std::make_pair(code, static_cast<fstHandle>(NULL)));
     std::istringstream nameiss(name);
@@ -125,14 +144,13 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name,
     std::list<std::string> tokens(beg, end);  // Split name
     std::string symbol_name(tokens.back());
     tokens.pop_back();  // Remove symbol name from hierarchy
-    tokens.insert(tokens.begin(), m_module);  // Add current module to the hierarchy
+    tokens.insert(tokens.begin(), moduleName());  // Add current module to the hierarchy
 
     // Find point where current and new scope diverge
     std::list<std::string>::iterator cur_it = m_curScope.begin();
     std::list<std::string>::iterator new_it = tokens.begin();
     while (cur_it != m_curScope.end() && new_it != tokens.end()) {
-        if (*cur_it != *new_it)
-            break;
+        if (*cur_it != *new_it) break;
         ++cur_it;
         ++new_it;
     }
@@ -152,8 +170,7 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name,
 
     std::stringstream name_ss;
     name_ss << symbol_name;
-    if (arraynum >= 0)
-        name_ss << "(" << arraynum << ")";
+    if (array) name_ss << "(" << arraynum << ")";
     std::string name_str = name_ss.str();
 
     if (dtypenum > 0) {
@@ -168,87 +185,93 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name,
     }
 }
 
-//=============================================================================
-// Callbacks
-
-void VerilatedFst::addCallback(
-    VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
-    VerilatedFstCallback_t changecb, void* userthis) VL_MT_UNSAFE_ONE {
-    m_assertOne.check();
-    if (VL_UNLIKELY(isOpen())) {
-        std::string msg = (std::string("Internal: ")+__FILE__+"::"+__FUNCTION__
-                           +" called with already open file");
-        VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
-    }
-    VerilatedFstCallInfo* vci = new VerilatedFstCallInfo(initcb, fullcb, changecb, userthis, 1);
-    m_callbacks.push_back(vci);
+void VerilatedFst::declBit(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                           fstVarType vartype, bool array, int arraynum) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, 1, 1);
+}
+void VerilatedFst::declBus(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                           fstVarType vartype, bool array, int arraynum, int msb, int lsb) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, msb - lsb + 1,
+               msb - lsb + 1);
+}
+void VerilatedFst::declQuad(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                            fstVarType vartype, bool array, int arraynum, int msb, int lsb) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, msb - lsb + 1,
+               msb - lsb + 1);
+}
+void VerilatedFst::declArray(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                             fstVarType vartype, bool array, int arraynum, int msb, int lsb) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, msb - lsb + 1,
+               msb - lsb + 1);
+}
+void VerilatedFst::declFloat(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                             fstVarType vartype, bool array, int arraynum) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, 1, 32);
+}
+void VerilatedFst::declDouble(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                              fstVarType vartype, bool array, int arraynum) {
+    declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, 2, 64);
 }
 
-//=============================================================================
-// Dumping
+// Note: emit* are only ever called from one place (full* in
+// verilated_trace_imp.cpp, which is included in this file at the top),
+// so always inline them.
 
-void VerilatedFst::dump(vluint64_t timeui) {
-    if (!isOpen()) return;
-    if (VL_UNLIKELY(m_fullDump)) {
-        m_fullDump = false;  // No need for more full dumps
-        for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
-            VerilatedFstCallInfo* cip = m_callbacks[ent];
-            (cip->m_fullcb)(this, cip->m_userthis, cip->m_code);
-        }
-        return;
-    }
-    fstWriterEmitTimeChange(m_fst, timeui);
-    for (vluint32_t ent = 0; ent< m_callbacks.size(); ++ent) {
-        VerilatedFstCallInfo* cip = m_callbacks[ent];
-        (cip->m_changecb)(this, cip->m_userthis, cip->m_code);
-    }
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitBit(vluint32_t code, CData newval) {
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], newval ? "1" : "0");
 }
 
-//=============================================================================
-// Helpers
-
-char* VerilatedFst::word2Str(vluint32_t newval, int bits) {
-    // Constructor makes sure m_valueStrBuffer.reserve() > 32+1
-    char* s = m_valueStrBuffer.data();
-    for (int i = 0; i < bits; ++i) {
-        *s++ = '0' + ((newval>>(bits-i-1))&1);
-    }
-    *s = '\0';
-    return m_valueStrBuffer.data();
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitCData(vluint32_t code, CData newval, int bits) {
+    char buf[VL_BYTESIZE];
+    cvtCDataToStr(buf, newval << (VL_BYTESIZE - bits));
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
 }
 
-char* VerilatedFst::quad2Str(vluint64_t newval, int bits) {
-    // Constructor makes sure m_valueStrBuffer.reserve() > 64+1
-    char* s = m_valueStrBuffer.data();
-    for (int i = 0; i < bits; ++i) {
-        *s++ = '0' + ((newval>>(bits-i-1))&1);
-    }
-    *s = '\0';
-    return m_valueStrBuffer.data();
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitSData(vluint32_t code, SData newval, int bits) {
+    char buf[VL_SHORTSIZE];
+    cvtSDataToStr(buf, newval << (VL_SHORTSIZE - bits));
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
 }
 
-char* VerilatedFst::array2Str(const vluint32_t* newval, int bits) {
-    int bq = VL_BITWORD_I(bits), br = VL_BITBIT_I(bits);
-    m_valueStrBuffer.reserve(bits+1);
-    char* s = m_valueStrBuffer.data();
-    vluint32_t v = newval[bq];
-    for (int i = 0; i < br; ++i) {
-        *s++ = '0' + ((v>>(br-i-1))&1);
-    }
-    for (int w = bq-1; w >= 0; --w) {
-        v = newval[w];
-        for (int i = 28; i >= 0; i-=4) {
-            s[0] = '0' + ((v>>(i+3))&1);
-            s[1] = '0' + ((v>>(i+2))&1);
-            s[2] = '0' + ((v>>(i+1))&1);
-            s[3] = '0' + ((v>>(i+0))&1);
-            s+=4;
-        }
-    }
-    *s = '\0';
-    return m_valueStrBuffer.data();
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitIData(vluint32_t code, IData newval, int bits) {
+    char buf[VL_IDATASIZE];
+    cvtIDataToStr(buf, newval << (VL_IDATASIZE - bits));
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
 }
 
-//********************************************************************
-// Local Variables:
-// End:
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitQData(vluint32_t code, QData newval, int bits) {
+    char buf[VL_QUADSIZE];
+    cvtQDataToStr(buf, newval << (VL_QUADSIZE - bits));
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], buf);
+}
+
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitWData(vluint32_t code, const WData* newvalp, int bits) {
+    int words = VL_WORDS_I(bits);
+    char* wp = m_strbuf;
+    // Convert the most significant word
+    const int bitsInMSW = VL_BITBIT_E(bits) ? VL_BITBIT_E(bits) : VL_EDATASIZE;
+    cvtEDataToStr(wp, newvalp[--words] << (VL_EDATASIZE - bitsInMSW));
+    wp += bitsInMSW;
+    // Convert the remaining words
+    while (words > 0) {
+        cvtEDataToStr(wp, newvalp[--words]);
+        wp += VL_EDATASIZE;
+    }
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], m_strbuf);
+}
+
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitFloat(vluint32_t code, float newval) {
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], &newval);
+}
+
+VL_ATTR_ALWINLINE
+void VerilatedFst::emitDouble(vluint32_t code, double newval) {
+    fstWriterEmitValueChange(m_fst, m_symbolp[code], &newval);
+}

include/verilated_fst_c.h

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -23,8 +20,8 @@
 #ifndef _VERILATED_FST_C_H_
 #define _VERILATED_FST_C_H_ 1
 
-#include "verilatedos.h"
 #include "verilated.h"
+#include "verilated_trace.h"
 
 #include "gtkwave/fstapi.h"
 
@@ -33,161 +30,101 @@
 #include <string>
 #include <vector>
 
-class VerilatedFst;
-class VerilatedFstCallInfo;
-typedef void (*VerilatedFstCallback_t)(VerilatedFst* vcdp, void* userthis, vluint32_t code);
-
 //=============================================================================
 // VerilatedFst
 /// Base class to create a Verilator FST dump
 /// This is an internally used class - see VerilatedFstC for what to call from applications
 
-class VerilatedFst {
+class VerilatedFst : public VerilatedTrace<VerilatedFst> {
+private:
+    // Give the superclass access to private bits (to avoid virtual functions)
+    friend class VerilatedTrace<VerilatedFst>;
+
+    //=========================================================================
+    // FST specific internals
+
     typedef std::map<vluint32_t, fstHandle> Code2SymbolType;
     typedef std::map<int, fstEnumHandle> Local2FstDtype;
-    typedef std::vector<VerilatedFstCallInfo*> CallbackVec;
-private:
+
     void* m_fst;
-    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
-    bool m_fullDump;
-    char m_scopeEscape;
-    std::string m_module;
-    CallbackVec m_callbacks;  ///< Routines to perform dumping
     Code2SymbolType m_code2symbol;
     Local2FstDtype m_local2fstdtype;
     std::list<std::string> m_curScope;
+    fstHandle* m_symbolp;  ///< same as m_code2symbol, but as an array
+    char* m_strbuf;  ///< String buffer long enough to hold maxBits() chars
+
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedFst);
-    void declSymbol(vluint32_t code, const char* name,
-                    int dtypenum, fstVarDir vardir, fstVarType vartype,
-                    int arraynum, vluint32_t len);
-    // helpers
-    std::vector<char> m_valueStrBuffer;
-    char* word2Str(vluint32_t newval, int bits);
-    char* quad2Str(vluint64_t newval, int bits);
-    char* array2Str(const vluint32_t *newval, int bits);
+    void declSymbol(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                    fstVarType vartype, bool array, int arraynum, vluint32_t len, vluint32_t bits);
+
+protected:
+    //=========================================================================
+    // Implementation of VerilatedTrace interface
+
+    // Implementations of protected virtual methods for VerilatedTrace
+    void emitTimeChange(vluint64_t timeui) VL_OVERRIDE;
+
+    // Hooks called from VerilatedTrace
+    bool preFullDump() VL_OVERRIDE { return isOpen(); }
+    bool preChangeDump() VL_OVERRIDE { return isOpen(); }
+
+    // Implementations of duck-typed methods for VerilatedTrace. These are
+    // called from only one place (namely full*) so always inline them.
+    inline void emitBit(vluint32_t code, CData newval);
+    inline void emitCData(vluint32_t code, CData newval, int bits);
+    inline void emitSData(vluint32_t code, SData newval, int bits);
+    inline void emitIData(vluint32_t code, IData newval, int bits);
+    inline void emitQData(vluint32_t code, QData newval, int bits);
+    inline void emitWData(vluint32_t code, const WData* newvalp, int bits);
+    inline void emitFloat(vluint32_t code, float newval);
+    inline void emitDouble(vluint32_t code, double newval);
+
 public:
-    explicit VerilatedFst(void* fst=NULL);
-    ~VerilatedFst() { if (m_fst == NULL) { fstWriterClose(m_fst); } }
-    bool isOpen() const { return m_fst != NULL; }
+    //=========================================================================
+    // External interface to client code
+
+    explicit VerilatedFst(void* fst = NULL);
+    ~VerilatedFst();
+
+    /// Open the file; call isOpen() to see if errors
     void open(const char* filename) VL_MT_UNSAFE;
-    void flush() VL_MT_UNSAFE { fstWriterFlushContext(m_fst); }
-    void close() VL_MT_UNSAFE {
-        m_assertOne.check();
-        fstWriterClose(m_fst);
-        m_fst = NULL;
-    }
-    void set_time_unit(const char* unitp) { fstWriterSetTimescaleFromString(m_fst, unitp); }
-    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    /// Close the file
+    void close() VL_MT_UNSAFE;
+    /// Flush any remaining data to this file
+    void flush() VL_MT_UNSAFE;
+    /// Is file open?
+    bool isOpen() const { return m_fst != NULL; }
 
-    void set_time_resolution(const char* unitp) { if (unitp) {} }
-    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+    //=========================================================================
+    // Internal interface to Verilator generated code
 
-    // double timescaleToDouble(const char* unitp);
-    // std::string doubleToTimescale(double value);
-
-    /// Change character that splits scopes.  Note whitespace are ALWAYS escapes.
-    void scopeEscape(char flag) { m_scopeEscape = flag; }
-    /// Is this an escape?
-    bool isScopeEscape(char c) { return isspace(c) || c == m_scopeEscape; }
-    /// Inside dumping routines, called each cycle to make the dump
-    void dump(vluint64_t timeui);
-    /// Inside dumping routines, declare callbacks for tracings
-    void addCallback(VerilatedFstCallback_t initcb, VerilatedFstCallback_t fullcb,
-                     VerilatedFstCallback_t changecb,
-                     void* userthis) VL_MT_UNSAFE_ONE;
-
-    /// Inside dumping routines, declare a module
-    void module(const std::string& name);
     /// Inside dumping routines, declare a data type
     void declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
-                       unsigned int minValbits,
-                       const char** itemNamesp, const char** itemValuesp);
+                       unsigned int minValbits, const char** itemNamesp, const char** itemValuesp);
+
     /// Inside dumping routines, declare a signal
-    void declBit(vluint32_t code, const char* name,
-                 int dtypenum, fstVarDir vardir, fstVarType vartype,
-                 int arraynum) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
-    }
-    void declBus(vluint32_t code, const char* name,
-                 int dtypenum, fstVarDir vardir, fstVarType vartype,
-                 int arraynum, int msb, int lsb) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
-    }
-    void declDouble(vluint32_t code, const char* name,
-                    int dtypenum, fstVarDir vardir, fstVarType vartype,
-                    int arraynum) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 2);
-    }
-    void declFloat(vluint32_t code, const char* name,
-                   int dtypenum, fstVarDir vardir, fstVarType vartype,
-                   int arraynum) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, 1);
-    }
-    void declQuad(vluint32_t code, const char* name,
-                  int dtypenum, fstVarDir vardir, fstVarType vartype,
-                  int arraynum, int msb, int lsb) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
-    }
-    void declArray(vluint32_t code, const char* name,
-                   int dtypenum, fstVarDir vardir, fstVarType vartype,
-                   int arraynum, int msb, int lsb) {
-        declSymbol(code, name, dtypenum, vardir, vartype, arraynum, msb - lsb + 1);
-    }
-
-    /// Inside dumping routines, dump one signal if it has changed
-    void chgBit(vluint32_t code, const vluint32_t newval) {
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], newval ? "1" : "0");
-    }
-    void chgBus(vluint32_t code, const vluint32_t newval, int bits) {
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], word2Str(newval, bits));
-    }
-    void chgDouble(vluint32_t code, const double newval) {
-        double val = newval;
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
-    }
-    void chgFloat(vluint32_t code, const float newval) {
-        double val = (double)newval;
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], &val);
-    }
-    void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], quad2Str(newval, bits));
-    }
-    void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
-        fstWriterEmitValueChange(m_fst, m_code2symbol[code], array2Str(newval, bits));
-    }
-
-    void fullBit(vluint32_t code, const vluint32_t newval) {
-        chgBit(code, newval); }
-    void fullBus(vluint32_t code, const vluint32_t newval, int bits) {
-        chgBus(code, newval, bits); }
-    void fullDouble(vluint32_t code, const double newval) {
-        chgDouble(code, newval); }
-    void fullFloat(vluint32_t code, const float newval) {
-        chgFloat(code, newval); }
-    void fullQuad(vluint32_t code, const vluint64_t newval, int bits) {
-        chgQuad(code, newval, bits); }
-    void fullArray(vluint32_t code, const vluint32_t* newval, int bits) {
-        chgArray(code, newval, bits); }
-
-    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 fullTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
-    void fullTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
-    void fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
-    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
-    void fullBitX(vluint32_t code);
-    void fullBusX(vluint32_t code, int bits);
-    void fullQuadX(vluint32_t code, int bits);
-    void fullArrayX(vluint32_t code, int bits);
-    void chgTriBit(vluint32_t code, const vluint32_t newval, const vluint32_t newtri);
-    void chgTriBus(vluint32_t code, const vluint32_t newval, const vluint32_t newtri, int bits);
-    void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri, int bits);
-    void chgTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip, int bits);
+    void declBit(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                 fstVarType vartype, bool array, int arraynum);
+    void declBus(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                 fstVarType vartype, bool array, int arraynum, int msb, int lsb);
+    void declQuad(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                  fstVarType vartype, bool array, int arraynum, int msb, int lsb);
+    void declArray(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                   fstVarType vartype, bool array, int arraynum, int msb, int lsb);
+    void declFloat(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                   fstVarType vartype, bool array, int arraynum);
+    void declDouble(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                    fstVarType vartype, bool array, int arraynum);
 };
 
+// Declare specialization here as it's used in VerilatedFstC just below
+template <> void VerilatedTrace<VerilatedFst>::dump(vluint64_t timeui);
+template <> void VerilatedTrace<VerilatedFst>::set_time_unit(const char* unitp);
+template <> void VerilatedTrace<VerilatedFst>::set_time_unit(const std::string& unit);
+template <> void VerilatedTrace<VerilatedFst>::set_time_resolution(const char* unitp);
+template <> void VerilatedTrace<VerilatedFst>::set_time_resolution(const std::string& unit);
+
 //=============================================================================
 // VerilatedFstC
 /// Create a FST dump file in C standalone (no SystemC) simulations.
@@ -199,10 +136,14 @@ class VerilatedFstC {
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedFstC);
+
 public:
-    explicit VerilatedFstC(void* filep=NULL) : m_sptrace(filep) {}
-    ~VerilatedFstC() {}
-public:
+    explicit VerilatedFstC(void* filep = NULL)
+        : m_sptrace(filep) {}
+    ~VerilatedFstC() { close(); }
+    /// Routines can only be called from one thread; allow next call from different thread
+    void changeThread() { spTrace()->changeThread(); }
+
     // ACCESSORS
     /// Is file open?
     bool isOpen() const { return m_sptrace.isOpen(); }
@@ -221,13 +162,13 @@ public:
     void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     /// Set time units (s/ms, defaults to ns)
-    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    /// For Verilated models, these propage from the Verilated default --timeunit
     void set_time_unit(const char* unitp) { m_sptrace.set_time_unit(unitp); }
-    void set_time_unit(const std::string& unit) { set_time_unit(unit.c_str()); }
+    void set_time_unit(const std::string& unit) { m_sptrace.set_time_unit(unit); }
     /// Set time resolution (s/ms, defaults to ns)
-    /// See also VL_TIME_PRECISION, and VL_TIME_MULTIPLIER in verilated.h
+    /// For Verilated models, these propage from the Verilated default --timeunit
     void set_time_resolution(const char* unitp) { m_sptrace.set_time_resolution(unitp); }
-    void set_time_resolution(const std::string& unit) { set_time_resolution(unit.c_str()); }
+    void set_time_resolution(const std::string& unit) { m_sptrace.set_time_resolution(unit); }
 
     /// Internal class access
     inline VerilatedFst* spTrace() { return &m_sptrace; };

include/verilated_heavy.h

@@ -1,15 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2010-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2010-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //*************************************************************************
 ///
@@ -30,63 +26,478 @@
 
 #include "verilated.h"
 
+#include <deque>
+#include <map>
+#include <memory>
 #include <string>
 
+//===================================================================
+// String formatters (required by below containers)
+
+extern std::string VL_TO_STRING(CData lhs);
+extern std::string VL_TO_STRING(SData lhs);
+extern std::string VL_TO_STRING(IData lhs);
+extern std::string VL_TO_STRING(QData lhs);
+inline std::string VL_TO_STRING(const std::string& obj) { return "\"" + obj + "\""; }
+extern std::string VL_TO_STRING_W(int words, WDataInP obj);
+
+//===================================================================
+// Readmem/Writemem operation classes
+
+class VlReadMem {
+    bool m_hex;  // Hex format
+    int m_bits;  // Bit width of values
+    const std::string& m_filename;  // Filename
+    QData m_end;  // End address (as specified by user)
+    FILE* m_fp;  // File handle for filename
+    QData m_addr;  // Next address to read
+    int m_linenum;  // Line number last read from file
+public:
+    VlReadMem(bool hex, int bits, const std::string& filename, QData start, QData end);
+    ~VlReadMem();
+    bool isOpen() const { return m_fp != NULL; }
+    int linenum() const { return m_linenum; }
+    bool get(QData& addrr, std::string& valuer);
+    void setData(void* valuep, const std::string& rhs);
+};
+
+class VlWriteMem {
+    int m_bits;  // Bit width of values
+    FILE* m_fp;  // File handle for filename
+    QData m_addr;  // Next address to write
+public:
+    VlWriteMem(bool hex, int bits, const std::string& filename, QData start, QData end);
+    ~VlWriteMem();
+    bool isOpen() const { return m_fp != NULL; }
+    void print(QData addr, bool addrstamp, const void* valuep);
+};
+
+//===================================================================
+// Verilog array container
+// Similar to std::array<WData, N>, but:
+//   1. Doesn't require C++11
+//   2. Lighter weight, only methods needed by Verilator, to help compile time.
+//
+// This is only used when we need an upper-level container and so can't
+// simply use a C style array (which is just a pointer).
+
+template <std::size_t T_Words> class VlWide {
+    WData m_storage[T_Words];
+
+public:
+    // cppcheck-suppress uninitVar
+    VlWide() {}
+    ~VlWide() {}
+    const WData& at(size_t index) const { return m_storage[index]; }
+    WData& at(size_t index) { return m_storage[index]; }
+    WData* data() { return &m_storage[0]; }
+    const WData* data() const { return &m_storage[0]; }
+    bool operator<(const VlWide<T_Words>& rhs) const {
+        return VL_LT_W(T_Words, data(), rhs.data());
+    }
+};
+
+// Convert a C array to std::array reference by pointer magic, without copy.
+// Data type (second argument) is so the function template can automatically generate.
+template <std::size_t T_Words> VlWide<T_Words>& VL_CVT_W_A(WDataInP inp, const VlWide<T_Words>&) {
+    return *((VlWide<T_Words>*)inp);
+}
+
+template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& obj) {
+    return VL_TO_STRING_W(T_Words, obj.data());
+}
+
+//===================================================================
+// Verilog associative array container
+// There are no multithreaded locks on this; the base variable must
+// be protected by other means
+//
+template <class T_Key, class T_Value> class VlAssocArray {
+private:
+    // TYPES
+    typedef std::map<T_Key, T_Value> Map;
+
+public:
+    typedef typename Map::const_iterator const_iterator;
+
+private:
+    // MEMBERS
+    Map m_map;  // State of the assoc array
+    T_Value m_defaultValue;  // Default value
+
+public:
+    // CONSTRUCTORS
+    VlAssocArray() {
+        // m_defaultValue isn't defaulted. Caller's constructor must do it.
+    }
+    ~VlAssocArray() {}
+    // Standard copy constructor works. Verilog: assoca = assocb
+
+    // METHODS
+    T_Value& atDefault() { return m_defaultValue; }
+
+    // Size of array. Verilog: function int size(), or int num()
+    int size() const { return m_map.size(); }
+    // Clear array. Verilog: function void delete([input index])
+    void clear() { m_map.clear(); }
+    void erase(const T_Key& index) { m_map.erase(index); }
+    // Return 0/1 if element exists. Verilog: function int exists(input index)
+    int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); }
+    // Return first element.  Verilog: function int first(ref index);
+    int first(T_Key& indexr) const {
+        typename Map::const_iterator it = m_map.begin();
+        if (it == m_map.end()) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return last element.  Verilog: function int last(ref index)
+    int last(T_Key& indexr) const {
+        typename Map::const_reverse_iterator it = m_map.rbegin();
+        if (it == m_map.rend()) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return next element. Verilog: function int next(ref index)
+    int next(T_Key& indexr) const {
+        typename Map::const_iterator it = m_map.find(indexr);
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        ++it;
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return prev element. Verilog: function int prev(ref index)
+    int prev(T_Key& indexr) const {
+        typename Map::const_iterator it = m_map.find(indexr);
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        if (VL_UNLIKELY(it == m_map.begin())) return 0;
+        --it;
+        indexr = it->first;
+        return 1;
+    }
+    // Setting. Verilog: assoc[index] = v
+    // Can't just overload operator[] or provide a "at" reference to set,
+    // because we need to be able to insert only when the value is set
+    T_Value& at(const T_Key& index) {
+        typename Map::iterator it = m_map.find(index);
+        if (it == m_map.end()) {
+            std::pair<typename Map::iterator, bool> pit
+                = m_map.insert(std::make_pair(index, m_defaultValue));
+            return pit.first->second;
+        }
+        return it->second;
+    }
+    // Accessing. Verilog: v = assoc[index]
+    const T_Value& at(const T_Key& index) const {
+        typename Map::iterator it = m_map.find(index);
+        if (it == m_map.end()) {
+            return m_defaultValue;
+        } else {
+            return it->second;
+        }
+    }
+    // For save/restore
+    const_iterator begin() const { return m_map.begin(); }
+    const_iterator end() const { return m_map.end(); }
+
+    // Dumping. Verilog: str = $sformatf("%p", assoc)
+    std::string to_string() const {
+        std::string out = "'{";
+        std::string comma;
+        for (typename Map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
+            out += comma + VL_TO_STRING(it->first) + ":" + VL_TO_STRING(it->second);
+            comma = ", ";
+        }
+        // Default not printed - maybe random init data
+        return out + "} ";
+    }
+};
+
+template <class T_Key, class T_Value>
+std::string VL_TO_STRING(const VlAssocArray<T_Key, T_Value>& obj) {
+    return obj.to_string();
+}
+
+template <class T_Key, class T_Value>
+void VL_READMEM_N(bool hex, int bits, const std::string& filename,
+                  VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
+    VlReadMem rmem(hex, bits, filename, start, end);
+    if (VL_UNLIKELY(!rmem.isOpen())) return;
+    while (true) {
+        QData addr;
+        std::string data;
+        if (rmem.get(addr /*ref*/, data /*ref*/)) {
+            rmem.setData(&(obj.at(addr)), data);
+        } else {
+            break;
+        }
+    }
+}
+
+template <class T_Key, class T_Value>
+void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
+                   const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
+    VlWriteMem wmem(hex, bits, filename, start, end);
+    if (VL_UNLIKELY(!wmem.isOpen())) return;
+    for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = obj.begin(); it != obj.end();
+         ++it) {
+        QData addr = it->first;
+        if (addr >= start && addr <= end) wmem.print(addr, true, &(it->second));
+    }
+}
+
+//===================================================================
+// Verilog queue and dynamic array container
+// There are no multithreaded locks on this; the base variable must
+// be protected by other means
+//
+// Bound here is the maximum size() allowed, e.g. 1 + SystemVerilog bound
+// For dynamic arrays it is always zero
+template <class T_Value, size_t T_MaxSize = 0> class VlQueue {
+private:
+    // TYPES
+    typedef std::deque<T_Value> Deque;
+
+public:
+    typedef typename Deque::const_iterator const_iterator;
+
+private:
+    // MEMBERS
+    Deque m_deque;  // State of the assoc array
+    T_Value m_defaultValue;  // Default value
+
+public:
+    // CONSTRUCTORS
+    VlQueue() {
+        // m_defaultValue isn't defaulted. Caller's constructor must do it.
+    }
+    ~VlQueue() {}
+    // Standard copy constructor works. Verilog: assoca = assocb
+
+    // METHODS
+    T_Value& atDefault() { return m_defaultValue; }
+
+    // Size. Verilog: function int size(), or int num()
+    int size() const { return m_deque.size(); }
+    // Clear array. Verilog: function void delete([input index])
+    void clear() { m_deque.clear(); }
+    void erase(size_t index) {
+        if (VL_LIKELY(index < m_deque.size())) m_deque.erase(index);
+    }
+
+    // Dynamic array new[] becomes a renew()
+    void renew(size_t size) {
+        clear();
+        m_deque.resize(size, atDefault());
+    }
+    // Dynamic array new[]() becomes a renew_copy()
+    void renew_copy(size_t size, const VlQueue<T_Value, T_MaxSize>& rhs) {
+        if (size == 0) {
+            clear();
+        } else {
+            *this = rhs;
+            m_deque.resize(size, atDefault());
+        }
+    }
+
+    // function void q.push_front(value)
+    void push_front(const T_Value& value) {
+        m_deque.push_front(value);
+        if (VL_UNLIKELY(T_MaxSize != 0 && m_deque.size() > T_MaxSize)) m_deque.pop_back();
+    }
+    // function void q.push_back(value)
+    void push_back(const T_Value& value) {
+        if (VL_LIKELY(T_MaxSize == 0 || m_deque.size() < T_MaxSize)) m_deque.push_back(value);
+    }
+    // function value_t q.pop_front();
+    T_Value pop_front() {
+        if (m_deque.empty()) return m_defaultValue;
+        T_Value v = m_deque.front();
+        m_deque.pop_front();
+        return v;
+    }
+    // function value_t q.pop_back();
+    T_Value pop_back() {
+        if (m_deque.empty()) return m_defaultValue;
+        T_Value v = m_deque.back();
+        m_deque.pop_back();
+        return v;
+    }
+
+    // Setting. Verilog: assoc[index] = v
+    // Can't just overload operator[] or provide a "at" reference to set,
+    // because we need to be able to insert only when the value is set
+    T_Value& at(size_t index) {
+        static T_Value s_throwAway;
+        // Needs to work for dynamic arrays, so does not use T_MaxSize
+        if (VL_UNLIKELY(index >= m_deque.size())) {
+            s_throwAway = atDefault();
+            return s_throwAway;
+        } else {
+            return m_deque[index];
+        }
+    }
+    // Accessing. Verilog: v = assoc[index]
+    const T_Value& at(size_t index) const {
+        static T_Value s_throwAway;
+        // Needs to work for dynamic arrays, so does not use T_MaxSize
+        if (VL_UNLIKELY(index >= m_deque.size())) {
+            return atDefault();
+        } else {
+            return m_deque[index];
+        }
+    }
+    // function void q.insert(index, value);
+    void insert(size_t index, const T_Value& value) {
+        if (VL_UNLIKELY(index >= m_deque.size())) return;
+        m_deque[index] = value;
+    }
+
+    // For save/restore
+    const_iterator begin() const { return m_deque.begin(); }
+    const_iterator end() const { return m_deque.end(); }
+
+    // Dumping. Verilog: str = $sformatf("%p", assoc)
+    std::string to_string() const {
+        std::string out = "'{";
+        std::string comma;
+        for (typename Deque::const_iterator it = m_deque.begin(); it != m_deque.end(); ++it) {
+            out += comma + VL_TO_STRING(*it);
+            comma = ", ";
+        }
+        return out + "} ";
+    }
+};
+
+template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
+    return obj.to_string();
+}
+
+//===================================================================
+// Verilog class reference container
+// There are no multithreaded locks on this; the base variable must
+// be protected by other means
+//
+
+// clang-format off
+#if (defined(_MSC_VER) && _MSC_VER >= 1900) || (__cplusplus >= 201103L)
+# define VlClassRef std::shared_ptr
+#else
+# define VlClassRef VlClassRef__SystemVerilog_class_support_requires_a_C11_or_newer_compiler
+#endif
+// clang-format on
+
+template <class T>  // T typically of type VlClassRef<x>
+inline T VL_NULL_CHECK(T t, const char* filename, int linenum) {
+    if (VL_UNLIKELY(!t)) Verilated::nullPointerError(filename, linenum);
+    return t;
+}
+
 //======================================================================
 // Conversion functions
 
 extern std::string VL_CVT_PACK_STR_NW(int lwords, WDataInP lwp) VL_MT_SAFE;
 inline std::string VL_CVT_PACK_STR_NQ(QData lhs) VL_PURE {
-    WData lw[2];  VL_SET_WQ(lw, lhs);
-    return VL_CVT_PACK_STR_NW(2, lw);
-}
-inline std::string VL_CVT_PACK_STR_NN(const std::string& lhs) VL_PURE {
-    return lhs;
+    WData lw[VL_WQ_WORDS_E];
+    VL_SET_WQ(lw, lhs);
+    return VL_CVT_PACK_STR_NW(VL_WQ_WORDS_E, lw);
 }
+inline std::string VL_CVT_PACK_STR_NN(const std::string& lhs) VL_PURE { return lhs; }
 inline std::string VL_CVT_PACK_STR_NI(IData lhs) VL_PURE {
-    WData lw[1];  lw[0] = lhs;
+    WData lw[VL_WQ_WORDS_E];
+    VL_SET_WI(lw, lhs);
     return VL_CVT_PACK_STR_NW(1, lw);
 }
 inline std::string VL_CONCATN_NNN(const std::string& lhs, const std::string& rhs) VL_PURE {
     return lhs + rhs;
 }
-inline std::string VL_REPLICATEN_NNQ(int,int,int, const std::string& lhs, IData rep) VL_PURE {
-    std::string out; out.reserve(lhs.length() * rep);
-    for (unsigned times=0; times<rep; ++times) out += lhs;
+inline std::string VL_REPLICATEN_NNQ(int, int, int, const std::string& lhs, IData rep) VL_PURE {
+    std::string out;
+    out.reserve(lhs.length() * rep);
+    for (unsigned times = 0; times < rep; ++times) out += lhs;
     return out;
 }
-inline std::string VL_REPLICATEN_NNI(int obits,int lbits,int rbits,
-                                     const std::string& lhs, IData rep) VL_PURE {
-    return VL_REPLICATEN_NNQ(obits,lbits,rbits,lhs,rep);
+inline std::string VL_REPLICATEN_NNI(int obits, int lbits, int rbits, const std::string& lhs,
+                                     IData rep) VL_PURE {
+    return VL_REPLICATEN_NNQ(obits, lbits, rbits, lhs, rep);
 }
 
 inline IData VL_LEN_IN(const std::string& ld) { return ld.length(); }
+extern std::string VL_TOLOWER_NN(const std::string& ld);
+extern std::string VL_TOUPPER_NN(const std::string& ld);
 
+extern IData VL_FERROR_IN(IData fpi, std::string& outputr) VL_MT_SAFE;
 extern IData VL_FOPEN_NI(const std::string& filename, IData mode) VL_MT_SAFE;
-extern void VL_READMEM_N(bool hex, int width, int depth, int array_lsb,
-                         const std::string& filename,
-                         void* memp, IData start, IData end) VL_MT_SAFE;
-extern void VL_WRITEMEM_N(bool hex, int width, int depth, int array_lsb,
-                          const std::string& filename,
-                          const void* memp, IData start, IData end) VL_MT_SAFE;
-extern IData VL_SSCANF_INX(int lbits, const std::string& ld,
-                           const char* formatp, ...) VL_MT_SAFE;
-extern void VL_SFORMAT_X(int obits_ignored, std::string& output,
-                         const char* formatp, ...) VL_MT_SAFE;
+extern void VL_READMEM_N(bool hex, int bits, QData depth, int array_lsb,
+                         const std::string& filename, void* memp, QData start,
+                         QData end) VL_MT_SAFE;
+extern void VL_WRITEMEM_N(bool hex, int bits, QData depth, int array_lsb,
+                          const std::string& filename, const void* memp, QData start,
+                          QData end) VL_MT_SAFE;
+extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp, ...) VL_MT_SAFE;
+extern void VL_SFORMAT_X(int obits_ignored, std::string& output, const char* formatp,
+                         ...) VL_MT_SAFE;
 extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
+extern void VL_TIMEFORMAT_IINI(int units, int precision, const std::string& suffix,
+                               int width) VL_MT_SAFE;
 extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE;
-inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, CData& rdr) VL_MT_SAFE {
     WData rwp[2];  // WData must always be at least 2
     IData got = VL_VALUEPLUSARGS_INW(rbits, ld, rwp);
     if (got) rdr = rwp[0];
     return got;
 }
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, SData& rdr) VL_MT_SAFE {
+    WData rwp[2];  // WData must always be at least 2
+    IData got = VL_VALUEPLUSARGS_INW(rbits, ld, rwp);
+    if (got) rdr = rwp[0];
+    return got;
+}
+inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, IData& rdr) VL_MT_SAFE {
+    WData rwp[2];
+    IData got = VL_VALUEPLUSARGS_INW(rbits, ld, rwp);
+    if (got) rdr = rwp[0];
+    return got;
+}
 inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, QData& rdr) VL_MT_SAFE {
     WData rwp[2];
     IData got = VL_VALUEPLUSARGS_INW(rbits, ld, rwp);
     if (got) rdr = VL_SET_QW(rwp);
     return got;
 }
+inline IData VL_VALUEPLUSARGS_INQ(int rbits, const std::string& ld, double& rdr) VL_MT_SAFE {
+    WData rwp[2];
+    IData got = VL_VALUEPLUSARGS_INW(rbits, ld, rwp);
+    if (got) rdr = VL_CVT_D_Q(VL_SET_QW(rwp));
+    return got;
+}
 extern IData VL_VALUEPLUSARGS_INN(int, const std::string& ld, std::string& rdr) VL_MT_SAFE;
 
+//======================================================================
+// Strings
+
+extern std::string VL_PUTC_N(const std::string& lhs, IData rhs, CData ths) VL_PURE;
+extern CData VL_GETC_N(const std::string& lhs, IData rhs) VL_PURE;
+extern std::string VL_SUBSTR_N(const std::string& lhs, IData rhs, IData ths) VL_PURE;
+
+inline IData VL_CMP_NN(const std::string& lhs, const std::string& rhs, bool ignoreCase) VL_PURE {
+    // SystemVerilog does not allow a string variable to contain '\0'.
+    // So C functions such as strcmp() can correctly compare strings.
+    int result;
+    if (ignoreCase) {
+        result = VL_STRCASECMP(lhs.c_str(), rhs.c_str());
+    } else {
+        result = std::strcmp(lhs.c_str(), rhs.c_str());
+    }
+    return result;
+}
+
+extern IData VL_ATOI_N(const std::string& str, int base) VL_PURE;
+
+//======================================================================
+// Dumping
+
+extern const char* vl_dumpctl_filenamep(bool setit = false,
+                                        const std::string& filename = "") VL_MT_SAFE;
+
 #endif  // Guard

include/verilated_imp.h

@@ -1,15 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2019 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2020 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License.
+// 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.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=========================================================================
 ///
@@ -23,6 +19,7 @@
 #ifndef _VERILATED_IMP_H_
 #define _VERILATED_IMP_H_ 1  ///< Header Guard
 
+// clang-format off
 #if !defined(_VERILATED_CPP_) && !defined(_VERILATED_DPI_CPP_) && !defined(_VERILATED_VPI_CPP_)
 # error "verilated_imp.h only to be included by verilated*.cpp internals"
 #endif
@@ -39,6 +36,7 @@
 # include <functional>
 # include <queue>
 #endif
+// clang-format on
 
 class VerilatedScope;
 
@@ -51,9 +49,11 @@ class VerilatedMsg {
 public:
     // TYPES
     struct Cmp {
-        bool operator() (const VerilatedMsg& a, const VerilatedMsg& b) const {
-            return a.mtaskId() < b.mtaskId(); }
+        bool operator()(const VerilatedMsg& a, const VerilatedMsg& b) const {
+            return a.mtaskId() < b.mtaskId();
+        }
     };
+
 private:
     // MEMBERS
     vluint32_t m_mtaskId;  ///< MTask that did enqueue
@@ -90,6 +90,7 @@ public:
 
 private:
     VL_UNCOPYABLE(VerilatedEvalMsgQueue);
+
 public:
     // METHODS
     //// Add message to queue (called by producer)
@@ -126,6 +127,7 @@ public:
 /// Each thread has a local queue to build up messages until the end of the eval() call
 class VerilatedThreadMsgQueue {
     std::queue<VerilatedMsg> m_queue;
+
 public:
     // CONSTRUCTORS
     VerilatedThreadMsgQueue() {}
@@ -133,6 +135,7 @@ public:
         // The only call of this with a non-empty queue is a fatal error.
         // So this does not flush the queue, as the destination queue is not known to this class.
     }
+
 private:
     VL_UNCOPYABLE(VerilatedThreadMsgQueue);
     // METHODS
@@ -140,6 +143,7 @@ private:
         static VL_THREAD_LOCAL VerilatedThreadMsgQueue t_s;
         return t_s;
     }
+
 public:
     /// Add message to queue, called by producer
     static void post(const VerilatedMsg& msg) VL_MT_SAFE {
@@ -169,6 +173,8 @@ public:
 
 class VerilatedImp {
     // Whole class is internal use only - Global information shared between verilated*.cpp files.
+protected:
+    friend class Verilated;
 
     // TYPES
     typedef std::vector<std::string> ArgVec;
@@ -178,30 +184,52 @@ class VerilatedImp {
     // MEMBERS
     static VerilatedImp s_s;  ///< Static Singleton; One and only static this
 
-    // Nothing here is save-restored; users expected to re-register appropriately
+    struct Serialized {  // All these members serialized/deserialized
+        int m_timeFormatUnits;  // $timeformat units
+        int m_timeFormatPrecision;  // $timeformat number of decimal places
+        int m_timeFormatWidth;  // $timeformat character width
+        enum { UNITS_NONE = 99 };  // Default based on precision
+        Serialized()
+            : m_timeFormatUnits(UNITS_NONE)
+            , m_timeFormatPrecision(0)
+            , m_timeFormatWidth(20) {}
+        ~Serialized() {}
+    } m_ser;
 
-    VerilatedMutex      m_argMutex;  ///< Protect m_argVec, m_argVecLoaded
-    ArgVec              m_argVec VL_GUARDED_BY(m_argMutex);  ///< Argument list (NOT save-restored, may want different results)
-    bool                m_argVecLoaded VL_GUARDED_BY(m_argMutex);  ///< Ever loaded argument list
+    VerilatedMutex m_sergMutex;  ///< Protect m_ser
+    struct SerializedG {  // All these members serialized/deserialized and guarded
+        std::string m_timeFormatSuffix;  // $timeformat printf format
+    } m_serg VL_GUARDED_BY(m_sergMutex);
 
-    VerilatedMutex      m_userMapMutex;  ///< Protect m_userMap
-    UserMap             m_userMap VL_GUARDED_BY(m_userMapMutex);  ///< Map of <(scope,userkey), userData>
+    // Nothing below here is save-restored; users expected to re-register appropriately
 
-    VerilatedMutex      m_nameMutex;  ///< Protect m_nameMap
-    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);  ///< Map of <scope_name, scope pointer>
+    VerilatedMutex m_argMutex;  ///< Protect m_argVec, m_argVecLoaded
+    /// Argument list (NOT save-restored, may want different results)
+    ArgVec m_argVec VL_GUARDED_BY(m_argMutex);
+    bool m_argVecLoaded VL_GUARDED_BY(m_argMutex);  ///< Ever loaded argument list
 
-    VerilatedMutex      m_hierMapMutex;  ///< Protect m_hierMap
-    VerilatedHierarchyMap m_hierMap VL_GUARDED_BY(m_hierMapMutex);  ///< Map the represents scope hierarchy
+    VerilatedMutex m_userMapMutex;  ///< Protect m_userMap
+    UserMap m_userMap VL_GUARDED_BY(m_userMapMutex);  ///< Map of <(scope,userkey), userData>
+
+    VerilatedMutex m_nameMutex;  ///< Protect m_nameMap
+    /// Map of <scope_name, scope pointer>
+    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);
+
+    VerilatedMutex m_hierMapMutex;  ///< Protect m_hierMap
+    /// Map the represents scope hierarchy
+    VerilatedHierarchyMap m_hierMap VL_GUARDED_BY(m_hierMapMutex);
 
     // Slow - somewhat static:
-    VerilatedMutex      m_exportMutex;  ///< Protect m_nameMap
-    ExportNameMap       m_exportMap VL_GUARDED_BY(m_exportMutex);  ///< Map of <export_func_proto, func number>
-    int                 m_exportNext VL_GUARDED_BY(m_exportMutex);  ///< Next export funcnum
+    VerilatedMutex m_exportMutex;  ///< Protect m_nameMap
+    /// Map of <export_func_proto, func number>
+    ExportNameMap m_exportMap VL_GUARDED_BY(m_exportMutex);
+    int m_exportNext VL_GUARDED_BY(m_exportMutex);  ///< Next export funcnum
 
     // File I/O
-    VerilatedMutex      m_fdMutex;  ///< Protect m_fdps, m_fdFree
-    std::vector<FILE*>  m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
-    std::deque<IData>   m_fdFree VL_GUARDED_BY(m_fdMutex);  ///< List of free descriptors (SLOW - FOPEN/CLOSE only)
+    VerilatedMutex m_fdMutex;  ///< Protect m_fdps, m_fdFree
+    std::vector<FILE*> m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
+    /// List of free descriptors (SLOW - FOPEN/CLOSE only)
+    std::deque<IData> m_fdFree VL_GUARDED_BY(m_fdMutex);
 
 public:  // But only for verilated*.cpp
     // CONSTRUCTORS
@@ -214,8 +242,10 @@ public:  // But only for verilated*.cpp
         m_fdps[2] = stderr;
     }
     ~VerilatedImp() {}
+
 private:
     VL_UNCOPYABLE(VerilatedImp);
+
 public:
     // METHODS - debug
     static void internalsDump() VL_MT_SAFE;
@@ -242,11 +272,12 @@ public:
         }
         return "";
     }
+
 private:
     static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex);
     static void commandArgVl(const std::string& arg);
-    static bool commandArgVlValue(const std::string& arg,
-                                  const std::string& prefix, std::string& valuer);
+    static bool commandArgVlValue(const std::string& arg, const std::string& prefix,
+                                  std::string& valuer);
 
 public:
     // METHODS - user scope tracking
@@ -256,16 +287,19 @@ public:
     static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
         VerilatedLockGuard lock(s_s.m_userMapMutex);
         UserMap::iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
-        if (it != s_s.m_userMap.end()) it->second = userData;
-        // When we support VL_THREADs, we need a lock around this insert, as it's runtime
-        else s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep, userKey), userData));
+        if (it != s_s.m_userMap.end()) {
+            it->second = userData;
+        } else {
+            s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep, userKey), userData));
+        }
     }
     static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
         VerilatedLockGuard lock(s_s.m_userMapMutex);
-        UserMap::const_iterator it=s_s.m_userMap.find(std::make_pair(scopep, userKey));
-        if (VL_LIKELY(it != s_s.m_userMap.end())) return it->second;
-        else return NULL;
+        UserMap::const_iterator it = s_s.m_userMap.find(std::make_pair(scopep, userKey));
+        if (VL_UNLIKELY(it == s_s.m_userMap.end())) return NULL;
+        return it->second;
     }
+
 private:
     /// Symbol table destruction cleans up the entries for each scope.
     static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
@@ -282,10 +316,13 @@ private:
     static void userDump() VL_MT_SAFE {
         VerilatedLockGuard lock(s_s.m_userMapMutex);  // Avoid it changing in middle of dump
         bool first = true;
-        for (UserMap::const_iterator it=s_s.m_userMap.begin(); it!=s_s.m_userMap.end(); ++it) {
-            if (first) { VL_PRINTF_MT("  userDump:\n"); first=false; }
-            VL_PRINTF_MT("    DPI_USER_DATA scope %p key %p: %p\n",
-                      it->first.first, it->first.second, it->second);
+        for (UserMap::const_iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end(); ++it) {
+            if (first) {
+                VL_PRINTF_MT("  userDump:\n");
+                first = false;
+            }
+            VL_PRINTF_MT("    DPI_USER_DATA scope %p key %p: %p\n", it->first.first,
+                         it->first.second, it->second);
         }
     }
 
@@ -302,9 +339,9 @@ public:  // But only for verilated*.cpp
     static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
         VerilatedLockGuard lock(s_s.m_nameMutex);
         // If too slow, can assume this is only VL_MT_SAFE_POSINIT
-        VerilatedScopeNameMap::const_iterator it=s_s.m_nameMap.find(namep);
-        if (VL_LIKELY(it != s_s.m_nameMap.end())) return it->second;
-        else return NULL;
+        VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.find(namep);
+        if (VL_UNLIKELY(it == s_s.m_nameMap.end())) return NULL;
+        return it->second;
     }
     static void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
         // Slow ok - called once/scope at destruction
@@ -364,8 +401,8 @@ public:  // But only for verilated*.cpp
         VerilatedLockGuard lock(s_s.m_exportMutex);
         ExportNameMap::const_iterator it = s_s.m_exportMap.find(namep);
         if (VL_LIKELY(it != s_s.m_exportMap.end())) return it->second;
-        std::string msg = (std::string("%Error: Testbench C called ")+namep
-                           +" but no such DPI export function name exists in ANY model");
+        std::string msg = (std::string("%Error: Testbench C called ") + namep
+                           + " but no such DPI export function name exists in ANY model");
         VL_FATAL_MT("unknown", 0, "", msg.c_str());
         return -1;
     }
@@ -381,15 +418,34 @@ public:  // But only for verilated*.cpp
     static void exportsDump() VL_MT_SAFE {
         VerilatedLockGuard lock(s_s.m_exportMutex);
         bool first = true;
-        for (ExportNameMap::const_iterator it=s_s.m_exportMap.begin();
-             it!=s_s.m_exportMap.end(); ++it) {
-            if (first) { VL_PRINTF_MT("  exportDump:\n"); first=false; }
+        for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin();
+             it != s_s.m_exportMap.end(); ++it) {
+            if (first) {
+                VL_PRINTF_MT("  exportDump:\n");
+                first = false;
+            }
             VL_PRINTF_MT("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
         }
     }
     // We don't free up m_exportMap until the end, because we can't be sure
     // what other models are using the assigned funcnum's.
 
+public:  // But only for verilated*.cpp
+    // METHODS - timeformat
+    static std::string timeFormatSuffix() VL_MT_SAFE;
+    static void timeFormatSuffix(const std::string& value) VL_MT_SAFE;
+    static int timeFormatUnits() VL_MT_SAFE {
+        if (s_s.m_ser.m_timeFormatUnits == Serialized::UNITS_NONE) {
+            return Verilated::timeprecision();
+        }
+        return s_s.m_ser.m_timeFormatUnits;
+    }
+    static int timeFormatPrecision() VL_MT_SAFE { return s_s.m_ser.m_timeFormatPrecision; }
+    static int timeFormatWidth() VL_MT_SAFE { return s_s.m_ser.m_timeFormatWidth; }
+    static void timeFormatUnits(int value) VL_MT_SAFE;
+    static void timeFormatPrecision(int value) VL_MT_SAFE;
+    static void timeFormatWidth(int value) VL_MT_SAFE;
+
 public:  // But only for verilated*.cpp
     // METHODS - file IO
     static IData fdNew(FILE* fp) VL_MT_SAFE {
@@ -399,17 +455,20 @@ public:  // But only for verilated*.cpp
         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(static_cast<IData>(i));
+            s_s.m_fdps.resize(start * 2);
+            for (size_t i = start; i < start * 2; ++i) {
+                s_s.m_fdFree.push_back(static_cast<IData>(i));
+            }
         }
-        IData idx = s_s.m_fdFree.back(); s_s.m_fdFree.pop_back();
+        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
+        return (idx | (1UL << 31));  // bit 31 indicates not MCD
     }
     static void fdDelete(IData fdi) VL_MT_SAFE {
         IData idx = VL_MASK_I(31) & fdi;
         VerilatedLockGuard lock(s_s.m_fdMutex);
-        if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return;
+        if (VL_UNLIKELY(!(fdi & (VL_ULL(1) << 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);
@@ -417,7 +476,7 @@ public:  // But only for verilated*.cpp
     static inline FILE* fdToFp(IData fdi) VL_MT_SAFE {
         IData idx = VL_MASK_I(31) & fdi;
         VerilatedLockGuard lock(s_s.m_fdMutex);  // This might get slow, if it does we can cache it
-        if (VL_UNLIKELY(!(fdi & (1ULL<<31)) || idx >= s_s.m_fdps.size())) return NULL;
+        if (VL_UNLIKELY(!(fdi & (VL_ULL(1) << 31)) || idx >= s_s.m_fdps.size())) return NULL;
         return s_s.m_fdps[idx];
     }
 };

include/verilated_intrinsics.h

@@ -0,0 +1,41 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//*************************************************************************
+//
+// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
+// redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+//
+//*************************************************************************
+///
+/// \file
+/// \brief Verilator: Common include for target specific intrinsics.
+///
+///     Code using machine specific intrinsics for optimization should
+///     include this header rather than directly including he target
+///     specific headers. We provide macros to check for availability
+///     of instruction sets, and a common mechanism to disable them.
+///
+//*************************************************************************
+
+#ifndef _VERILATED_INTRINSICS_H_
+#define _VERILATED_INTRINSICS_H_ 1  ///< Header Guard
+
+// clang-format off
+
+// Use VL_DISABLE_INTRINSICS to disable all intrinsics based optimization
+#if !defined(VL_DISABLE_INTRINSICS) && !defined(VL_PORTABLE_ONLY)
+# if defined(__SSE2__) && !defined(VL_DISABLE_SSE2)
+#  define VL_HAVE_SSE2 1
+#  include <emmintrin.h>
+# endif
+# if defined(__AVX2__) && defined(VL_HAVE_SSE2) && !defined(VL_DISABLE_AVX2)
+#  define VL_HAVE_AVX2 1
+#  include <immintrin.h>
+# endif
+#endif
+
+// clang-format on
+
+#endif  // Guard

include/verilated_save.cpp

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -26,6 +23,7 @@
 #include <cerrno>
 #include <fcntl.h>
 
+// clang-format off
 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
 #else
@@ -41,9 +39,11 @@
 #ifndef O_CLOEXEC
 # define O_CLOEXEC 0
 #endif
+// clang-format on
 
 // CONSTANTS
-static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";  ///< Value of first bytes of each file
+static const char* const VLTSAVE_HEADER_STR
+    = "verilatorsave01\n";  ///< Value of first bytes of each file
 static const char* const VLTSAVE_TRAILER_STR = "vltsaved";  ///< Value of last bytes of each file
 
 //=============================================================================
@@ -51,22 +51,21 @@ static const char* const VLTSAVE_TRAILER_STR = "vltsaved";  ///< Value of last b
 //=============================================================================
 // Searalization
 
-bool VerilatedDeserialize::readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+bool VerilatedDeserialize::readDiffers(const void* __restrict datap,
+                                       size_t size) VL_MT_UNSAFE_ONE {
     bufferCheck();
     const vluint8_t* __restrict dp = static_cast<const vluint8_t* __restrict>(datap);
     vluint8_t miss = 0;
-    while (size--) {
-        miss |= (*dp++ ^ *m_cp++);
-    }
-    return (miss!=0);
+    while (size--) miss |= (*dp++ ^ *m_cp++);
+    return (miss != 0);
 }
 
 VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict datap,
                                                        size_t size) VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(readDiffers(datap, size))) {
         std::string fn = filename();
-        std::string msg = "Can't deserialize save-restore file as was made from different model:"
-            +filename();
+        std::string msg
+            = "Can't deserialize save-restore file as was made from different model:" + filename();
         VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
         close();
     }
@@ -80,19 +79,21 @@ void VerilatedSerialize::header() VL_MT_UNSAFE_ONE {
 
     // 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());
+    os.write(Verilated::serialized1Ptr(), Verilated::serialized1Size());
+    os.write(Verilated::serialized2Ptr(), Verilated::serialized2Size());
 }
 
 void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
     VerilatedDeserialize& os = *this;  // So can cut and paste standard >> code below
     if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR)))) {
         std::string fn = filename();
-        std::string msg = std::string("Can't deserialize; file has wrong header signature: ")
-            +filename();
+        std::string msg
+            = std::string("Can't deserialize; file has wrong header signature: ") + filename();
         VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
         close();
     }
-    os.read(Verilated::serializedPtr(), Verilated::serializedSize());
+    os.read(Verilated::serialized1Ptr(), Verilated::serialized1Size());
+    os.read(Verilated::serialized2Ptr(), Verilated::serialized2Size());
 }
 
 void VerilatedSerialize::trailer() VL_MT_UNSAFE_ONE {
@@ -106,7 +107,7 @@ void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(os.readDiffers(VLTSAVE_TRAILER_STR, strlen(VLTSAVE_TRAILER_STR)))) {
         std::string fn = filename();
         std::string msg = std::string("Can't deserialize; file has wrong end-of-file signature: ")
-            +filename();
+                          + filename();
         VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
         close();
     }
@@ -122,13 +123,13 @@ void VerilatedSave::open(const char* filenamep) VL_MT_UNSAFE_ONE {
     if (isOpen()) return;
     VL_DEBUG_IF(VL_DBG_MSGF("- save: opening save file %s\n", filenamep););
 
-    if (filenamep[0]=='|') {
+    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|O_CLOEXEC
-                      , 0666);
-        if (m_fd<0) {
+        m_fd = ::open(filenamep,
+                      O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE | O_NONBLOCK | O_CLOEXEC, 0666);
+        if (m_fd < 0) {
             // User code can check isOpen()
             m_isOpen = false;
             return;
@@ -145,13 +146,12 @@ void VerilatedRestore::open(const char* filenamep) VL_MT_UNSAFE_ONE {
     if (isOpen()) return;
     VL_DEBUG_IF(VL_DBG_MSGF("- restore: opening restore file %s\n", filenamep););
 
-    if (filenamep[0]=='|') {
+    if (filenamep[0] == '|') {
         assert(0);  // Not supported yet.
     } else {
         // cppcheck-suppress duplicateExpression
-        m_fd = ::open(filenamep, O_CREAT|O_RDONLY|O_LARGEFILE|O_CLOEXEC
-                      , 0666);
-        if (m_fd<0) {
+        m_fd = ::open(filenamep, O_CREAT | O_RDONLY | O_LARGEFILE | O_CLOEXEC, 0666);
+        if (m_fd < 0) {
             // User code can check isOpen()
             m_isOpen = false;
             return;
@@ -187,17 +187,17 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
     m_assertOne.check();
     if (VL_UNLIKELY(!isOpen())) return;
     vluint8_t* wp = m_bufp;
-    while (1) {
+    while (true) {
         ssize_t remaining = (m_cp - wp);
-        if (remaining==0) break;
+        if (remaining == 0) break;
         errno = 0;
         ssize_t got = ::write(m_fd, wp, remaining);
-        if (got>0) {
+        if (got > 0) {
             wp += got;
         } else if (got < 0) {
             if (errno != EAGAIN && errno != EINTR) {
                 // write failed, presume error (perhaps out of disk space)
-                std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+                std::string msg = std::string(__FUNCTION__) + ": " + strerror(errno);
                 VL_FATAL_MT("", 0, "", msg.c_str());
                 close();
                 break;
@@ -212,21 +212,21 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
     if (VL_UNLIKELY(!isOpen())) return;
     // Move remaining characters down to start of buffer.  (No memcpy, overlaps allowed)
     vluint8_t* rp = m_bufp;
-    for (vluint8_t* sp=m_cp; sp < m_endp;) *rp++ = *sp++;  // Overlaps
+    for (vluint8_t* sp = m_cp; sp < m_endp; *rp++ = *sp++) {}  // Overlaps
     m_endp = m_bufp + (m_endp - m_cp);
     m_cp = m_bufp;  // Reset buffer
     // Read into buffer starting at m_endp
-    while (1) {
-        ssize_t remaining = (m_bufp+bufferSize() - m_endp);
-        if (remaining==0) break;
+    while (true) {
+        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) {
+        if (got > 0) {
             m_endp += got;
         } else if (got < 0) {
             if (errno != EAGAIN && errno != EINTR) {
                 // write failed, presume error (perhaps out of disk space)
-                std::string msg = std::string(__FUNCTION__)+": "+strerror(errno);
+                std::string msg = std::string(__FUNCTION__) + ": " + strerror(errno);
                 VL_FATAL_MT("", 0, "", msg.c_str());
                 close();
                 break;
@@ -234,7 +234,7 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
         } 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';
+            while (m_endp < m_bufp + bufferSize()) *m_endp++ = '\0';
             break;
         }
     }

include/verilated_save.h

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-2019 by Wilson Snyder.  This program is free software;
-// you can redistribute it and/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.
+// Copyright 2000-2020 by Wilson Snyder. This program is free software; you
+// can redistribute it and/or modify it under the terms of either the GNU
+// Lesser General Public License Version 3 or the Perl Artistic License
+// Version 2.0.
+// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 //
 //=============================================================================
 ///
@@ -23,6 +20,7 @@
 #define _VERILATED_SAVE_C_H_ 1
 
 #include "verilatedos.h"
+#include "verilated_heavy.h"
 
 #include <string>
 
@@ -34,20 +32,21 @@ class VerilatedSerialize {
 protected:
     // MEMBERS
     // For speed, keep m_cp as the first member of this structure
-    vluint8_t*          m_cp;           ///< Current pointer into m_bufp buffer
-    vluint8_t*          m_bufp;         ///< Output buffer
-    bool                m_isOpen;       ///< True indicates open file/stream
-    std::string         m_filename;     ///< Filename, for error messages
+    vluint8_t* m_cp;  ///< Current pointer into m_bufp buffer
+    vluint8_t* m_bufp;  ///< Output buffer
+    bool m_isOpen;  ///< True indicates open file/stream
+    std::string m_filename;  ///< Filename, for error messages
     VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
 
-    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
-    inline static size_t bufferInsertSize() { return 16*1024; }
+    inline static size_t bufferSize() { return 256 * 1024; }  // See below for slack calculation
+    inline static size_t bufferInsertSize() { return 16 * 1024; }
 
     void header() VL_MT_UNSAFE_ONE;
     void trailer() VL_MT_UNSAFE_ONE;
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedSerialize);
+
 public:
     VerilatedSerialize() {
         m_isOpen = false;
@@ -56,7 +55,7 @@ public:
     }
     virtual ~VerilatedSerialize() {
         close();
-        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+        if (m_bufp) VL_DO_CLEAR(delete m_bufp, m_bufp = NULL);
     }
     // METHODS
     bool isOpen() const { return m_isOpen; }
@@ -67,20 +66,20 @@ public:
         const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
         while (size) {
             bufferCheck();
-            size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+            size_t blk = size;
+            if (blk > bufferInsertSize()) blk = bufferInsertSize();
             const vluint8_t* __restrict maxp = dp + blk;
-            while (dp < maxp) *m_cp++ = *dp++;
+            for (; dp < maxp; *m_cp++ = *dp++) {}
             size -= blk;
         }
         return *this;  // For function chaining
     }
+
 private:
     VerilatedSerialize& bufferCheck() VL_MT_UNSAFE_ONE {
         // Flush the write buffer if there's not enough space left for new information
         // We only call this once per vector, so we need enough slop for a very wide "b###" line
-        if (VL_UNLIKELY(m_cp > (m_bufp+(bufferSize()-bufferInsertSize())))) {
-            flush();
-        }
+        if (VL_UNLIKELY(m_cp > (m_bufp + (bufferSize() - bufferInsertSize())))) flush();
         return *this;  // For function chaining
     }
 };
@@ -93,15 +92,15 @@ class VerilatedDeserialize {
 protected:
     // MEMBERS
     // For speed, keep m_cp as the first member of this structure
-    vluint8_t*          m_cp;           ///< Current pointer into m_bufp buffer
-    vluint8_t*          m_bufp;         ///< Output buffer
-    vluint8_t*          m_endp;         ///< Last valid byte in m_bufp buffer
-    bool                m_isOpen;       ///< True indicates open file/stream
-    std::string         m_filename;     ///< Filename, for error messages
-    VerilatedAssertOneThread m_assertOne;       ///< Assert only called from single thread
+    vluint8_t* m_cp;  ///< Current pointer into m_bufp buffer
+    vluint8_t* m_bufp;  ///< Output buffer
+    vluint8_t* m_endp;  ///< Last valid byte in m_bufp buffer
+    bool m_isOpen;  ///< True indicates open file/stream
+    std::string m_filename;  ///< Filename, for error messages
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
 
-    inline static size_t bufferSize() { return 256*1024; }  // See below for slack calculation
-    inline static size_t bufferInsertSize() { return 16*1024; }
+    inline static size_t bufferSize() { return 256 * 1024; }  // See below for slack calculation
+    inline static size_t bufferInsertSize() { return 16 * 1024; }
 
     virtual void fill() = 0;
     void header() VL_MT_UNSAFE_ONE;
@@ -109,6 +108,7 @@ protected:
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedDeserialize);
+
 public:
     VerilatedDeserialize() {
         m_isOpen = false;
@@ -118,7 +118,7 @@ public:
     }
     virtual ~VerilatedDeserialize() {
         close();
-        if (m_bufp) { delete m_bufp; m_bufp=NULL; }
+        if (m_bufp) VL_DO_CLEAR(delete m_bufp, m_bufp = NULL);
     }
     // METHODS
     bool isOpen() const { return m_isOpen; }
@@ -126,12 +126,13 @@ public:
     virtual void close() VL_MT_UNSAFE_ONE { flush(); }
     virtual void flush() VL_MT_UNSAFE_ONE {}
     inline VerilatedDeserialize& read(void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
-        vluint8_t* __restrict dp = (vluint8_t* __restrict)datap;
+        vluint8_t* __restrict dp = static_cast<vluint8_t* __restrict>(datap);
         while (size) {
             bufferCheck();
-            size_t blk = size;  if (blk>bufferInsertSize()) blk = bufferInsertSize();
+            size_t blk = size;
+            if (blk > bufferInsertSize()) blk = bufferInsertSize();
             const vluint8_t* __restrict maxp = dp + blk;
-            while (dp < maxp) *dp++ = *m_cp++;
+            for (; dp < maxp; *dp++ = *m_cp++) {}
             size -= blk;
         }
         return *this;  // For function chaining
@@ -139,15 +140,15 @@ public:
     // Read a datum and compare with expected value
     VerilatedDeserialize& readAssert(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
     VerilatedDeserialize& readAssert(vluint64_t data) VL_MT_UNSAFE_ONE {
-        return readAssert(&data, sizeof(data)); }
+        return readAssert(&data, sizeof(data));
+    }
+
 private:
     bool readDiffers(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE;
     VerilatedDeserialize& bufferCheck() VL_MT_UNSAFE_ONE {
         // Flush the write buffer if there's not enough space left for new information
         // We only call this once per vector, so we need enough slop for a very wide "b###" line
-        if (VL_UNLIKELY((m_cp+bufferInsertSize()) > m_endp)) {
-            fill();
-        }
+        if (VL_UNLIKELY((m_cp + bufferInsertSize()) > m_endp)) fill();
         return *this;  // For function chaining
     }
 };
@@ -162,13 +163,15 @@ private:
 
 public:
     // CONSTRUCTORS
-    VerilatedSave() { m_fd = -1; }
-    virtual ~VerilatedSave() { close(); }
+    VerilatedSave()
+        : m_fd(-1) {}
+    virtual ~VerilatedSave() VL_OVERRIDE { close(); }
     // METHODS
-    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    /// Open the file; call isOpen() to see if errors
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;
     void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
-    virtual void close() VL_MT_UNSAFE_ONE;
-    virtual void flush() VL_MT_UNSAFE_ONE;
+    virtual void close() VL_OVERRIDE VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE;
 };
 
 //=============================================================================
@@ -181,71 +184,101 @@ private:
 
 public:
     // CONSTRUCTORS
-    VerilatedRestore() { m_fd = -1; }
-    virtual ~VerilatedRestore() { close(); }
+    VerilatedRestore()
+        : m_fd(-1) {}
+    virtual ~VerilatedRestore() VL_OVERRIDE { close(); }
 
     // METHODS
-    void open(const char* filenamep) VL_MT_UNSAFE_ONE;  ///< Open the file; call isOpen() to see if errors
+    /// Open the file; call isOpen() to see if errors
+    void open(const char* filenamep) VL_MT_UNSAFE_ONE;
     void open(const std::string& filename) VL_MT_UNSAFE_ONE { open(filename.c_str()); }
-    virtual void close() VL_MT_UNSAFE_ONE;
-    virtual void flush() VL_MT_UNSAFE_ONE {}
-    virtual void fill() VL_MT_UNSAFE_ONE;
+    virtual void close() VL_OVERRIDE VL_MT_UNSAFE_ONE;
+    virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE {}
+    virtual void fill() VL_OVERRIDE VL_MT_UNSAFE_ONE;
 };
 
 //=============================================================================
 
-inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint64_t& rhs) {
+inline VerilatedSerialize& operator<<(VerilatedSerialize& os, vluint64_t& rhs) {
     return os.write(&rhs, sizeof(rhs));
 }
-inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint64_t& rhs){
+inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, vluint64_t& rhs) {
     return os.read(&rhs, sizeof(rhs));
 }
-inline VerilatedSerialize&   operator<<(VerilatedSerialize& os,   vluint32_t& 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) {
+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) {
+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) {
+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) {
+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) {
+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,   std::string& rhs) {
+inline VerilatedSerialize& operator<<(VerilatedSerialize& os, std::string& rhs) {
     vluint32_t len = rhs.length();
-    os<<len;
+    os << len;
     return os.write(rhs.data(), len);
 }
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& rhs) {
     vluint32_t len = 0;
-    os>>len;
+    os >> len;
     rhs.resize(len);
     return os.read((void*)rhs.data(), len);
 }
+template <class T_Key, class T_Value>
+VerilatedSerialize& operator<<(VerilatedSerialize& os, VlAssocArray<T_Key, T_Value>& rhs) {
+    os << rhs.atDefault();
+    vluint32_t len = rhs.size();
+    os << len;
+    for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = rhs.begin(); it != rhs.end();
+         ++it) {
+        T_Key index = it->first;  // Copy to get around const_iterator
+        T_Value value = it->second;
+        os << index << value;
+    }
+    return os;
+}
+template <class T_Key, class T_Value>
+VerilatedDeserialize& operator>>(VerilatedDeserialize& os, VlAssocArray<T_Key, T_Value>& rhs) {
+    os >> rhs.atDefault();
+    vluint32_t len = 0;
+    os >> len;
+    rhs.clear();
+    for (vluint32_t i = 0; i < len; ++i) {
+        T_Key index;
+        T_Value value;
+        os >> index;
+        os >> value;
+        rhs.at(index) = value;
+    }
+    return os;
+}
 
 #endif  // Guard