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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -11,4 +11,6 @@ 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.)
 
-May we assist you in trying to fix this yourself?
+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?

.travis.yml

@@ -1,8 +1,10 @@
 # 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
 
@@ -17,7 +19,6 @@ env:
     - VERILATOR_NUM_JOBS=$(echo `nproc` + 1 | bc)
     - VERILATOR_CONFIG_FLAGS="--enable-maintainer-mode --enable-longtests"
     - VERILATOR_AUTHOR_SITE=1
-    - OBJCACHE=ccache
 
 cache:
   directories:
@@ -25,7 +26,9 @@ cache:
 
 before_install:
 # Perl modules needed for testing
-  - yes yes | sudo cpan -fi Unix::Processors Parallel::Forker Bit::Vector
+# 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:
@@ -58,9 +61,14 @@ jobs:
       script: ci/test.sh vlt
     - if: type != cron
       stage: test
-      name: Vltmt test
+      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"

Changes

@@ -3,6 +3,104 @@ Revision history for Verilator
 The contributors that suggested a given feature are shown in []. Thanks!
 
 
+* Verilator 4.034 2020-05-03
+
+**    Add simplistic class support with many restrictions, see manual, #377.
+
+**    Support IEEE time units and time precisions, #234.
+      Includes `timescale, $printtimescale, $timeformat.
+      VL_TIME_MULTIPLIER, VL_TIME_PRECISION, VL_TIME_UNIT have been removed
+      and the time precision must now match the SystemC time precision.  To
+      get closer behavior to older versions, use e.g. --timescale-override
+      "1ps/1ps".
+
+**    Add --build to call make automatically, #2249. [Yutetsu TAKATSUKASA]
+
+**    Configuring with ccache present now defaults to using it; see OBJCACHE.
+
+**    Fix DPI import/export to be standard compliant, #2236. [Geza Lore]
+
+**    Add --trace-threads for general multithreaded tracing, #2269. [Geza Lore]
+
+***   Add --flatten for use with --xml-only, #2270. [James Hanlon]
+
+****  Greatly improve FST/VCD dump performance, #2244, #2246, #2250, #2257. [Geza Lore]
+
+****  Support $ferror, and $fflush without arguments, #1638.
+
+****  Support event data type (with some restrictions).
+
+****  Support $root, #2150. [Keyi Zhang]
+
+****  Add error if use SystemC 2.2 and earlier (pre-2011) as is deprecated.
+
+****  Fix build of fast path tracing code to use OPT_FAST, #2245. [Geza Lore]
+
+****  Fix arrayed instances connecting to slices, #2263. [Don/engr248]
+
+****  Fix error on unpacked connecting to packed, #2288. [Joseph Shaker]
+
+****  Fix logical not optimization with empty begin, #2291. [Baltazar Ortiz]
+
+****  Fix reduction OR on wide data, broke in v4.026, #2300. [Jack Koenig]
+
+****  Fix clock enables with bit-extends, #2299. [Marco Widmer]
+
+****  Fix MacOs Homebrew by removing default LIBS, #2298. [Ryan Clarke]
+
+
+* Verilator 4.032 2020-04-04
+
+***   Add column numbers to errors and warnings.
+
+***   Add GCC 9-style line number prefix when showing source text for errors.
+
+***   Add setting VM_PARALLEL_BUILDS=1 when using --output-split, #2185.
+
+***   Change --quiet-exit to also suppress 'Exiting due to N errors'.
+
+****  Suppress REALCVT for whole real numbers.
+
+****  Support split_var in vlt files, #2219. [Marco Widmer]
+
+****  Fix parameter type redeclaring a type, #2195. [hdzhangdoc]
+
+****  Fix VCD open with empty filename, #2198. [Julius Baxter]
+
+****  Fix packages as enum base types, #2202. [Driss Hafdi]
+
+****  Fix duplicate typedefs in generate for, #2205. [hdzhangdoc]
+
+****  Fix MinW portability, #2114. [Sean Cross]
+
+****  Fix assertions with unique case inside, #2199. [hdzhangdoc]
+
+****  Fix implicit conversion of floats to wide integers.
+
+
+* Verilator 4.030 2020-03-08
+
+**    Add split_var metacomment to assist UNOPTFLAT fixes, #2066. [Yutetsu TAKATSUKASA]
+
+**    Add support for $dumpfile and $dumpvars, #2126. [Alexander Grobman]
+
+**    Add support for dynamic arrays, #379.
+
+***   Add +verilator+noassert flag to disable assertion checking. [Tobias Wölfel]
+
+***   Add check for assertOn for asserts, #2162. [Tobias Wölfel]
+
+***   Add --structs-packed for forward compatibility.
+
+***   Fix genblk naming with directly nested generate blocks, #2176. [Alexander Grobman]
+
+****  Implement $displayb/o/h, $writeb/o/h, etc, #1637.
+
+****  Use gcc -Os in examples instead of -O2 for better average performance.
+
+****  Fix undeclared VL_SHIFTR_WWQ, #2114. [Alex Solomatnikov]
+
+
 * Verilator 4.028 2020-02-08
 
 **    Support attributes (public, isolate_assignments, etc.) in configuration files.
@@ -45,6 +143,8 @@ The contributors that suggested a given feature are shown in []. Thanks!
 
 ****  Fix OpenSolaris issues, #2154. [brancoliticus]
 
+****  Fix gated clocks under --protect-lib, #2169. [Todd Strader]
+
 
 * Verilator 4.026 2020-01-11
 
@@ -3513,10 +3613,11 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs.  See C-h m [M-x describe-mode].
 
-Copyright 2001-2020 by Wilson Snyder.  This program is free software; you
+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
 
 Local variables:
 mode: outline

MANIFEST.SKIP

@@ -28,7 +28,7 @@
 /obj_vcs/
 /obj_vlt/
 /obj_vltmt/
-/INCA_libs/
+INCA_libs/
 /cov_work/
 /logs/
 ^Makefile$
@@ -37,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-2020 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
 #
 #****************************************************************************/
 #
@@ -208,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
 
@@ -346,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; \
@@ -380,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)
 
@@ -465,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:

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/48478c986f13400682ffe4a5e0939b3a[Code Quality,link=https://www.codacy.com/gh/verilator/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::[]
 
@@ -22,10 +22,10 @@ endif::[]
 
 [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]
 
@@ -56,7 +56,7 @@ endif::[]
 == 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.
@@ -72,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

bin/verilator_coverage

@@ -6,11 +6,6 @@
 # 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;
@@ -269,10 +264,12 @@ Specifies a module search directory.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2003-2020 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

@@ -233,9 +233,12 @@ Do not show differences in line numbering.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2005-2020 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

@@ -123,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;
         }
     }
 
@@ -538,9 +538,12 @@ verilator_gantt.vcd.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2018-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.
+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,9 +1,11 @@
 #!/usr/bin/env perl
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2020 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

@@ -228,9 +228,12 @@ Displays this message and program version and exits.
 
 The latest version is available from L<https://verilator.org>.
 
-Copyright 2007-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.
+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

@@ -1,10 +1,11 @@
 #!/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
+# 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

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

@@ -1,9 +1,10 @@
 # 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.
+# 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
 

ci/docker/buildenv/README.adoc

@@ -1,7 +1,7 @@
-= Verilator Build Environment
+= Verilator Docker Build Environment
 
-This container is set up to compile and test a Verilator build based
-on the following parameters:
+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)
@@ -10,7 +10,7 @@ on the following parameters:
 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 of current master:
+To run the basic build using the current Verilator master:
 
     docker run -ti verilator/verilator-buildenv
 
@@ -18,7 +18,7 @@ To also run tests:
 
     docker run -ti verilator/verilator-buildenv test
 
-Change the compiler:
+To change the compiler:
 
     docker run -ti -e CC=gcc-4.8 -e CXX=g++-4.8 verilator/verilator-buildenv test
 
@@ -29,22 +29,21 @@ 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
 ....
 
-You may want to avoid pushing your changes to a remote repository and
-instead use a local working copy. You can mount the local working copy
-path as a volume and use this as repo. Be careful, that it can only
-use committed changes, so you may want to use a work-in-progress
-commit or so. To build the current HEAD from top of a repository:
+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
 ....
 
-== Under the Hood
+== Rebuilding
 
-To rebuild the image, simply run:
+To rebuild the Verilator-buildenv docker image, run:
 
     docker build .
 
-It will build SystemC in all supported compiler variants to reduce the
-impact on testing cycles. A build script will be the entrypoint to the
-container that will perform a standard build and test procedure.
+This will also build SystemC under all supported compiler variants to
+reduce the SystemC testing time.

ci/docker/buildenv/build-systemc.sh

@@ -1,10 +1,11 @@
 #!/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.
+# 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}')

ci/docker/buildenv/build.sh

@@ -1,10 +1,11 @@
 #!/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.
+# 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}"

ci/docker/run/Dockerfile

@@ -1,9 +1,10 @@
 # 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.
+# 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
 
@@ -14,11 +15,13 @@ RUN apt-get update \
                         bison=2:3.0.4.dfsg-1build1 \
                         build-essential=12.4ubuntu1 \
                         ca-certificates=20180409 \
+                        ccache \
                         flex=2.6.4-6 \
-                        git=1:2.17.1-1ubuntu0.5 \
+                        git \
                         libfl-dev=2.6.4-6 \
-                        perl=5.26.1-6ubuntu0.3 \
-                        python3=3.6.7-1~18.04 \
+                        libgoogle-perftools-dev \
+                        perl \
+                        python3 \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 

ci/docker/run/README.adoc

@@ -1,49 +1,59 @@
-= Docker Container as Verilator executable
+= Verilator Executable Docker Container
 
-This allows you to run Verilator easily as a docker image, e.g.:
+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 is in particular useful to compare against older version or to
-check when an issue was introduced.
+This will install the container, run the latest Verilator and print
+Verilator's version.
 
-You will need to give it access to your files as a volume and fix the
-user rights:
+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
 ....
 
-The caveat is that it can only access files below the current
-directory then, a workaround is to adopt the volume and set
-`-workdir`.
+This method can only access files below the current directory. An
+alternative is setup the volume `-workdir`.
 
-There is a convenience script in this folder that wraps around the
-docker calls:
-
-    $ verilator-docker 3.922 --version
-    Verilator 3.922 2018-03-17 rev UNKNOWN_REV
-
-Finally, you can also work in the container by setting the entrypoint
+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
 
-The other files in this folder all for building the containers and to
-store in them. You could use it to build Verilator at a specific
+You can also use the container to build Verilator at a specific
 commit:
 
     docker build --build-arg SOURCE_COMMIT=<commit> .
 
 == Internals
 
-The Dockerfile is pretty straight-forward, it builds Verilator and
-removes the tree after that to reduce the image size. It sets a
-wrapper script (`verilator-wrap.sh`) as entrypoint. This script calls
-Verilator but also copies the verilated runtime files to the `obj_dir`
-or the `-Mdir` respectively. This allows the user to build the C++
-output with the matching runtime files. The wrapper patches the
-generated Makefile accordingly.
+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

@@ -1,9 +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.FROM ubuntu:18.04
+# 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

@@ -1,10 +1,11 @@
 #!/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.FROM ubuntu:18.04
+# 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

ci/docker/run/verilator-docker

@@ -1,10 +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.
+# 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

@@ -1,13 +1,18 @@
-#!/bin/bash -e
+#!/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.
+# 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+')

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-2020 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.028 2020-02-06],
+AC_INIT([Verilator],[4.034 2020-05-03],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 # When releasing, also update header of Changes file
@@ -158,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
@@ -301,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)
 
@@ -328,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],
@@ -369,8 +376,13 @@ 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,

docs/CONTRIBUTING.adoc

@@ -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,13 +1,12 @@
 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 200+ additional contributors. Thanks to
-all.
+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
@@ -15,25 +14,36 @@ 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-2020 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

@@ -4,6 +4,7 @@
 // redistribute it and/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/install.adoc

@@ -78,17 +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
-
-The following are optional, but improve compilation speed:
-
-   sudo apt-get install libgoogle-perftools-dev
-
-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
@@ -96,11 +86,25 @@ 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
 
@@ -301,3 +305,4 @@ or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].
 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

@@ -405,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.
@@ -414,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
@@ -625,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
@@ -716,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]
@@ -987,3 +1001,4 @@ list in `src/Makefile_obj.in` and reconfigure.
 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

@@ -21,7 +21,7 @@ parser.
 
 == Structure
 
-The XML document is consists of 4 sections within the top level `verilator_xml`
+The XML document consists of 4 sections within the top level `verilator_xml`
 element:
 
 `<files>`...`</files>`::
@@ -63,3 +63,10 @@ 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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-2020 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
@@ -67,11 +68,13 @@ run:
 	$(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 ---------------------"

examples/make_tracing_c/Makefile_obj

@@ -5,10 +5,11 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# 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
+# 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-2020 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
@@ -76,10 +77,12 @@ run:
 
 	@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
+# 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 ---------------------"

examples/make_tracing_sc/Makefile_obj

@@ -5,10 +5,11 @@
 #
 # This is executed in the object directory, and called by ../Makefile
 #
-# 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
+# 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-2020 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/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"

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
  */
 
 /*
@@ -1024,7 +1026,9 @@ if(!xc->curval_mem)
 
 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;

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

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

include/verilated.mk.in

@@ -2,16 +2,19 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# 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.
+# 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@
@@ -86,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 =
 
@@ -112,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
@@ -139,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))
 
@@ -159,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
@@ -178,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

@@ -6,13 +6,9 @@
 //
 // 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

@@ -3,13 +3,9 @@
 //
 // 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-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 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,7 +66,7 @@ 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
@@ -77,7 +74,10 @@ public:
     virtual void zero() const VL_OVERRIDE { *m_countp = 0; }
     // CONSTRUCTORS
     // cppcheck-suppress noExplicitConstructor
-    VerilatedCoverItemSpec(T* countp) : m_countp(countp) { *m_countp = 0; }
+    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,17 +221,23 @@ 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);
             VL_DO_DANGLING(delete itemp, itemp);
         }
@@ -241,7 +258,7 @@ 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)) {
                     VL_DO_DANGLING(delete itemp, 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-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 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-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 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

@@ -3,13 +3,9 @@
 //
 // 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

@@ -3,13 +3,9 @@
 //
 // 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-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 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,13 +17,14 @@
 //=============================================================================
 // SPDIFF_OFF
 
+// clang-format off
+
 #define __STDC_LIMIT_MACROS  // UINT64_MAX
-#include "verilatedos.h"
 #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
@@ -52,48 +50,41 @@
 # 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();
@@ -101,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,
-                              bool array, 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);
@@ -128,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;
     }
@@ -170,42 +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");
 }
 
-//********************************************************************
-// Local Variables:
-// End:
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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-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 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,158 +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,
-                    bool array, int arraynum, vluint32_t len);
-    // helpers
-    std::vector<char> m_valueStrBuffer;
+    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,
-                 bool array, int arraynum) {
-        declSymbol(code, name, dtypenum, vardir, vartype, array, arraynum, 1);
-    }
-    void 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);
-    }
-    void 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);
-    }
-    void 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);
-    }
-    void 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);
-    }
-    void 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);
-    }
-
-    /// 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) {
-        fstWriterEmitValueChange32(m_fst, m_code2symbol[code], bits, newval);
-    }
-    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) {
-        fstWriterEmitValueChange64(m_fst, m_code2symbol[code], bits, newval);
-    }
-    void chgArray(vluint32_t code, const vluint32_t* newval, int bits) {
-        fstWriterEmitValueChangeVec32(m_fst, m_code2symbol[code], bits, newval);
-    }
-
-    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.
@@ -196,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(); }
@@ -218,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

@@ -3,13 +3,9 @@
 //
 // 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
 //
 //*************************************************************************
 ///
@@ -32,15 +28,16 @@
 
 #include <deque>
 #include <map>
+#include <memory>
 #include <string>
 
 //===================================================================
 // String formatters (required by below containers)
 
-extern std::string VL_TO_STRING(CData obj);
-extern std::string VL_TO_STRING(SData obj);
-extern std::string VL_TO_STRING(IData obj);
-extern std::string VL_TO_STRING(QData obj);
+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);
 
@@ -86,8 +83,11 @@ public:
 
 template <std::size_t T_Words> class VlWide {
     WData m_storage[T_Words];
+
 public:
-    // Default constructor/destructor/copy are fine
+    // 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]; }
@@ -99,13 +99,11 @@ public:
 
 // 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>&) {
+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) {
+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());
 }
 
@@ -118,6 +116,7 @@ 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;
 
@@ -162,7 +161,7 @@ public:
     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++;
+        ++it;
         if (VL_UNLIKELY(it == m_map.end())) return 0;
         indexr = it->first;
         return 1;
@@ -191,8 +190,11 @@ public:
     // 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;
+        if (it == m_map.end()) {
+            return m_defaultValue;
+        } else {
+            return it->second;
+        }
     }
     // For save/restore
     const_iterator begin() const { return m_map.begin(); }
@@ -221,7 +223,7 @@ 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 (1) {
+    while (true) {
         QData addr;
         std::string data;
         if (rmem.get(addr /*ref*/, data /*ref*/)) {
@@ -245,15 +247,17 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
 }
 
 //===================================================================
-// Verilog queue container
+// 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;
 
@@ -277,7 +281,24 @@ public:
     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); }
+    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) {
@@ -291,12 +312,16 @@ public:
     // 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;
+        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;
+        T_Value v = m_deque.back();
+        m_deque.pop_back();
+        return v;
     }
 
     // Setting. Verilog: assoc[index] = v
@@ -304,17 +329,23 @@ public:
     // 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];
         }
-        else return m_deque[index];
     }
     // Accessing. Verilog: v = assoc[index]
     const T_Value& at(size_t index) const {
         static T_Value s_throwAway;
-        if (VL_UNLIKELY(index >= m_deque.size())) return atDefault();
-        else return m_deque[index];
+        // 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) {
@@ -338,36 +369,56 @@ public:
     }
 };
 
-template <class T_Value>
-std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
+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[VL_WQ_WORDS_E]; VL_SET_WQ(lw, 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_NN(const std::string& lhs) VL_PURE { return lhs; }
 inline std::string VL_CVT_PACK_STR_NI(IData lhs) VL_PURE {
-    WData lw[VL_WQ_WORDS_E];  VL_SET_WI(lw, 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 {
+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);
 }
 
@@ -375,6 +426,7 @@ 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 bits, QData depth, int array_lsb,
                          const std::string& filename, void* memp, QData start,
@@ -382,11 +434,12 @@ extern void VL_READMEM_N(bool hex, int bits, QData depth, int array_lsb,
 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 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, CData& rdr) VL_MT_SAFE {
     WData rwp[2];  // WData must always be at least 2
@@ -441,4 +494,10 @@ inline IData VL_CMP_NN(const std::string& lhs, const std::string& rhs, bool igno
 
 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

@@ -3,13 +3,9 @@
 //
 // 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,12 +455,15 @@ 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;

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-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 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-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 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
 //
 //=============================================================================
 ///
@@ -49,6 +46,7 @@ protected:
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedSerialize);
+
 public:
     VerilatedSerialize() {
         m_isOpen = false;
@@ -57,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; }
@@ -68,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
     }
 };
@@ -110,6 +108,7 @@ protected:
 
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedDeserialize);
+
 public:
     VerilatedDeserialize() {
         m_isOpen = false;
@@ -119,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; }
@@ -127,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
@@ -140,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
     }
 };
@@ -163,10 +163,12 @@ private:
 
 public:
     // CONSTRUCTORS
-    VerilatedSave() { m_fd = -1; }
+    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_OVERRIDE VL_MT_UNSAFE_ONE;
     virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE;
@@ -182,11 +184,13 @@ private:
 
 public:
     // CONSTRUCTORS
-    VerilatedRestore() { m_fd = -1; }
+    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_OVERRIDE VL_MT_UNSAFE_ONE;
     virtual void flush() VL_OVERRIDE VL_MT_UNSAFE_ONE {}
@@ -253,8 +257,8 @@ VerilatedSerialize& operator<<(VerilatedSerialize& os, VlAssocArray<T_Key, T_Val
     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) {
+    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;

include/verilated_sc.h

@@ -3,13 +3,9 @@
 //
 // 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
 //
 //*************************************************************************
 ///

include/verilated_sym_props.h

@@ -3,13 +3,9 @@
 //
 // 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
 //
 //*************************************************************************
 ///
@@ -39,14 +35,23 @@
 
 // See also V3Ast::VNumRange
 class VerilatedRange {
-    int         m_left;
-    int         m_right;
+    int m_left;
+    int m_right;
+
 protected:
     friend class VerilatedVarProps;
     friend class VerilatedScope;
-    VerilatedRange() : m_left(0), m_right(0) {}
-    VerilatedRange(int left, int right) : m_left(left), m_right(right) {}
-    void init(int left, int right) { m_left=left; m_right=right; }
+    VerilatedRange()
+        : m_left(0)
+        , m_right(0) {}
+    VerilatedRange(int left, int right)
+        : m_left(left)
+        , m_right(right) {}
+    void init(int left, int right) {
+        m_left = left;
+        m_right = right;
+    }
+
 public:
     ~VerilatedRange() {}
     int left() const { return m_left; }
@@ -54,7 +59,8 @@ public:
     int low() const { return (m_left < m_right) ? m_left : m_right; }
     int high() const { return (m_left > m_right) ? m_left : m_right; }
     int elements() const {
-        return (VL_LIKELY(m_left>=m_right) ? (m_left-m_right+1) : (m_right-m_left+1)); }
+        return (VL_LIKELY(m_left >= m_right) ? (m_left - m_right + 1) : (m_right - m_left + 1));
+    }
     int increment() const { return (m_left >= m_right) ? 1 : -1; }
 };
 
@@ -66,71 +72,112 @@ class VerilatedVarProps {
     // TYPES
     enum { MAGIC = 0xddc4f829 };
     // MEMBERS
-    const vluint32_t            m_magic;        // Magic number
-    const VerilatedVarType      m_vltype;       // Data type
-    const VerilatedVarFlags     m_vlflags;      // Direction
-    const int                   m_pdims;        // Packed dimensions
-    const int                   m_udims;        // Unpacked dimensions
-    VerilatedRange              m_packed;       // Packed array range
-    VerilatedRange              m_unpacked[3];  // Unpacked array range
+    const vluint32_t m_magic;  // Magic number
+    const VerilatedVarType m_vltype;  // Data type
+    const VerilatedVarFlags m_vlflags;  // Direction
+    const int m_pdims;  // Packed dimensions
+    const int m_udims;  // Unpacked dimensions
+    VerilatedRange m_packed;  // Packed array range
+    VerilatedRange m_unpacked[3];  // Unpacked array range
     // CONSTRUCTORS
 protected:
     friend class VerilatedScope;
-    VerilatedVarProps(VerilatedVarType vltype, VerilatedVarFlags vlflags,
-                      int pdims, int udims)
-        : m_magic(MAGIC), m_vltype(vltype), m_vlflags(vlflags), m_pdims(pdims), m_udims(udims) {}
+    VerilatedVarProps(VerilatedVarType vltype, VerilatedVarFlags vlflags, int pdims, int udims)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(vlflags)
+        , m_pdims(pdims)
+        , m_udims(udims) {}
+
 public:
     class Unpacked {};
     // Without packed
     VerilatedVarProps(VerilatedVarType vltype, int vlflags)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(0) { }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Unpacked, int u0l, int u0r)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(1) {
-        m_unpacked[0].init(u0l, u0r); }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Unpacked, int u0l, int u0r, int u1l, int u1r)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(2) {
-        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Unpacked, int u0l, int u0r, int u1l, int u1r, int u2l, int u2r)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(0), m_udims(3) {
-        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); m_unpacked[2].init(u2l, u2r); }
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(0)
+        , m_udims(0) {}
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Unpacked, int u0l, int u0r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(0)
+        , m_udims(1) {
+        m_unpacked[0].init(u0l, u0r);
+    }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Unpacked, int u0l, int u0r, int u1l,
+                      int u1r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(0)
+        , m_udims(2) {
+        m_unpacked[0].init(u0l, u0r);
+        m_unpacked[1].init(u1l, u1r);
+    }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Unpacked, int u0l, int u0r, int u1l,
+                      int u1r, int u2l, int u2r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(0)
+        , m_udims(3) {
+        m_unpacked[0].init(u0l, u0r);
+        m_unpacked[1].init(u1l, u1r);
+        m_unpacked[2].init(u2l, u2r);
+    }
     // With packed
     class Packed {};
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Packed, int pl, int pr)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(0), m_packed(pl,pr) { }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Packed, int pl, int pr,
-                      Unpacked, int u0l, int u0r)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(1), m_packed(pl,pr) {
-        m_unpacked[0].init(u0l, u0r); }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Packed, int pl, int pr,
-                      Unpacked, int u0l, int u0r, int u1l, int u1r)
-        : m_magic(MAGIC), m_vltype(vltype), m_vlflags(VerilatedVarFlags(vlflags)),
-          m_pdims(1), m_udims(2), m_packed(pl,pr) {
-        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); }
-    VerilatedVarProps(VerilatedVarType vltype, int vlflags,
-                      Packed, int pl, int pr,
-                      Unpacked, int u0l, int u0r, int u1l, int u1r, int u2l, int u2r)
-        : m_magic(MAGIC), m_vltype(vltype),
-          m_vlflags(VerilatedVarFlags(vlflags)), m_pdims(1), m_udims(3), m_packed(pl,pr) {
-        m_unpacked[0].init(u0l, u0r); m_unpacked[1].init(u1l, u1r); m_unpacked[2].init(u2l, u2r); }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Packed, int pl, int pr)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(1)
+        , m_udims(0)
+        , m_packed(pl, pr) {}
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Packed, int pl, int pr, Unpacked,
+                      int u0l, int u0r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(1)
+        , m_udims(1)
+        , m_packed(pl, pr) {
+        m_unpacked[0].init(u0l, u0r);
+    }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Packed, int pl, int pr, Unpacked,
+                      int u0l, int u0r, int u1l, int u1r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(1)
+        , m_udims(2)
+        , m_packed(pl, pr) {
+        m_unpacked[0].init(u0l, u0r);
+        m_unpacked[1].init(u1l, u1r);
+    }
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Packed, int pl, int pr, Unpacked,
+                      int u0l, int u0r, int u1l, int u1r, int u2l, int u2r)
+        : m_magic(MAGIC)
+        , m_vltype(vltype)
+        , m_vlflags(VerilatedVarFlags(vlflags))
+        , m_pdims(1)
+        , m_udims(3)
+        , m_packed(pl, pr) {
+        m_unpacked[0].init(u0l, u0r);
+        m_unpacked[1].init(u1l, u1r);
+        m_unpacked[2].init(u2l, u2r);
+    }
+
 public:
     ~VerilatedVarProps() {}
     // METHODS
     bool magicOk() const { return m_magic == MAGIC; }
     VerilatedVarType vltype() const { return m_vltype; }
     VerilatedVarFlags vldir() const {
-        return static_cast<VerilatedVarFlags>(static_cast<int>(m_vlflags) & VLVF_MASK_DIR); }
+        return static_cast<VerilatedVarFlags>(static_cast<int>(m_vlflags) & VLVF_MASK_DIR);
+    }
     vluint32_t entSize() const;
     bool isPublicRW() const { return ((m_vlflags & VLVF_PUB_RW) != 0); }
     /// DPI compatible C standard layout
@@ -141,28 +188,28 @@ public:
     const VerilatedRange& unpacked() const { return m_unpacked[0]; }
     // DPI accessors
     int left(int dim) const {
-        return dim==0 ? m_packed.left()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].left() : 0;
+        return dim == 0 ? m_packed.left()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].left() : 0;
     }
     int right(int dim) const {
-        return dim==0 ? m_packed.right()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].right() : 0;
+        return dim == 0 ? m_packed.right()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].right() : 0;
     }
     int low(int dim) const {
-        return dim==0 ? m_packed.low()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].low() : 0;
+        return dim == 0 ? m_packed.low()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].low() : 0;
     }
     int high(int dim) const {
-        return dim==0 ? m_packed.high()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].high() : 0;
+        return dim == 0 ? m_packed.high()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].high() : 0;
     }
     int increment(int dim) const {
-        return dim==0 ? m_packed.increment()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].increment() : 0;
+        return dim == 0 ? m_packed.increment()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].increment() : 0;
     }
     int elements(int dim) const {
-        return dim==0 ? m_packed.elements()
-            : VL_LIKELY(dim>=1 && dim<=3) ? m_unpacked[dim-1].elements() : 0;
+        return dim == 0 ? m_packed.elements()
+                        : VL_LIKELY(dim >= 1 && dim <= 3) ? m_unpacked[dim - 1].elements() : 0;
     }
     /// Total size in bytes (note DPI limited to 4GB)
     size_t totalSize() const;
@@ -203,7 +250,8 @@ public:
     int elements(int dim) const { return m_propsp->elements(dim); }
     size_t totalSize() const { return m_propsp->totalSize(); }
     void* datapAdjustIndex(void* datap, int dim, int indx) const {
-        return m_propsp->datapAdjustIndex(datap, dim, indx); }
+        return m_propsp->datapAdjustIndex(datap, dim, indx);
+    }
 };
 
 //===========================================================================
@@ -217,10 +265,12 @@ class VerilatedVar : public VerilatedVarProps {
 protected:
     friend class VerilatedScope;
     // CONSTRUCTORS
-    VerilatedVar(const char* namep, void* datap,
-                 VerilatedVarType vltype, VerilatedVarFlags vlflags, int dims)
-        : VerilatedVarProps(vltype, vlflags, (dims>0?1:0), ((dims>1)?dims-1:0))
-        , m_datap(datap), m_namep(namep) {}
+    VerilatedVar(const char* namep, void* datap, VerilatedVarType vltype,
+                 VerilatedVarFlags vlflags, int dims)
+        : VerilatedVarProps(vltype, vlflags, (dims > 0 ? 1 : 0), ((dims > 1) ? dims - 1 : 0))
+        , m_datap(datap)
+        , m_namep(namep) {}
+
 public:
     ~VerilatedVar() {}
     // ACCESSORS

include/verilated_syms.h

@@ -3,13 +3,9 @@
 //
 // 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
 //
 //*************************************************************************
 ///

include/verilated_threads.cpp

@@ -1,16 +1,11 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //=============================================================================
 //
-// THIS MODULE IS PUBLICLY LICENSED
-//
-// Copyright 2012-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 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 2012-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
 //
 //=============================================================================
 ///
@@ -32,8 +27,8 @@ VL_THREAD_LOCAL VlThreadPool::ProfileTrace* VlThreadPool::t_profilep = NULL;
 // VlMTaskVertex
 
 VlMTaskVertex::VlMTaskVertex(vluint32_t upstreamDepCount)
-    : m_upstreamDepsDone(0),
-      m_upstreamDepCount(upstreamDepCount) {
+    : m_upstreamDepsDone(0)
+    , m_upstreamDepCount(upstreamDepCount) {
     assert(atomic_is_lock_free(&m_upstreamDepsDone));
 }
 
@@ -41,11 +36,12 @@ VlMTaskVertex::VlMTaskVertex(vluint32_t upstreamDepCount)
 // VlWorkerThread
 
 VlWorkerThread::VlWorkerThread(VlThreadPool* poolp, bool profiling)
-    : m_ready_size(0)
+    : m_waiting(false)
+    , m_ready_size(0)
     , m_poolp(poolp)
     , m_profiling(profiling)
     , m_exiting(false)
-      // Must init this last -- after setting up fields that it might read:
+    // Must init this last -- after setting up fields that it might read:
     , m_cthread(startWorker, this) {}
 
 VlWorkerThread::~VlWorkerThread() {
@@ -56,21 +52,16 @@ VlWorkerThread::~VlWorkerThread() {
 }
 
 void VlWorkerThread::workerLoop() {
-    if (VL_UNLIKELY(m_profiling)) {
-        m_poolp->setupProfilingClientThread();
-    }
+    if (VL_UNLIKELY(m_profiling)) m_poolp->setupProfilingClientThread();
 
     ExecRec work;
     work.m_fnp = NULL;
 
-    while (1) {
-        if (VL_LIKELY(!work.m_fnp)) {
-            dequeWork(&work);
-        }
+    while (true) {
+        if (VL_LIKELY(!work.m_fnp)) dequeWork(&work);
 
         // Do this here, not above, to avoid a race with the destructor.
-        if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire)))
-            break;
+        if (VL_UNLIKELY(m_exiting.load(std::memory_order_acquire))) break;
 
         if (VL_LIKELY(work.m_fnp)) {
             work.m_fnp(work.m_evenCycle, work.m_sym);
@@ -78,14 +69,10 @@ void VlWorkerThread::workerLoop() {
         }
     }
 
-    if (VL_UNLIKELY(m_profiling)) {
-        m_poolp->tearDownProfilingClientThread();
-    }
+    if (VL_UNLIKELY(m_profiling)) m_poolp->tearDownProfilingClientThread();
 }
 
-void VlWorkerThread::startWorker(VlWorkerThread* workerp) {
-    workerp->workerLoop();
-}
+void VlWorkerThread::startWorker(VlWorkerThread* workerp) { workerp->workerLoop(); }
 
 //=============================================================================
 // VlThreadPool
@@ -94,23 +81,22 @@ VlThreadPool::VlThreadPool(int nThreads, bool profiling)
     : m_profiling(profiling) {
     // --threads N passes nThreads=N-1, as the "main" threads counts as 1
     unsigned cpus = std::thread::hardware_concurrency();
-    if (cpus < nThreads+1) {
+    if (cpus < nThreads + 1) {
         static int warnedOnce = 0;
         if (!warnedOnce++) {
             VL_PRINTF_MT("%%Warning: System has %u CPUs but model Verilated with"
-                         " --threads %d; may run slow.\n", cpus, nThreads+1);
+                         " --threads %d; may run slow.\n",
+                         cpus, nThreads + 1);
         }
     }
     // Create'em
-    for (int i=0; i<nThreads; ++i) {
+    for (int i = 0; i < nThreads; ++i) {
         m_workers.push_back(new VlWorkerThread(this, profiling));
     }
     // Set up a profile buffer for the current thread too -- on the
     // assumption that it's the same thread that calls eval and may be
     // donated to run mtasks during the eval.
-    if (VL_UNLIKELY(m_profiling)) {
-        setupProfilingClientThread();
-    }
+    if (VL_UNLIKELY(m_profiling)) setupProfilingClientThread();
 }
 
 VlThreadPool::~VlThreadPool() {
@@ -118,9 +104,7 @@ VlThreadPool::~VlThreadPool() {
         // Each ~WorkerThread will wait for its thread to exit.
         delete m_workers[i];
     }
-    if (VL_UNLIKELY(m_profiling)) {
-        tearDownProfilingClientThread();
-    }
+    if (VL_UNLIKELY(m_profiling)) tearDownProfilingClientThread();
 }
 
 void VlThreadPool::tearDownProfilingClientThread() {
@@ -143,8 +127,7 @@ void VlThreadPool::setupProfilingClientThread() {
 
 void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
     VerilatedLockGuard lk(m_mutex);
-    for (ProfileSet::iterator it = m_allProfiles.begin();
-         it != m_allProfiles.end(); ++it) {
+    for (ProfileSet::iterator it = m_allProfiles.begin(); it != m_allProfiles.end(); ++it) {
         // Every thread's profile trace gets a copy of rec.
         (*it)->emplace_back(rec);
     }
@@ -157,52 +140,45 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
     FILE* fp = fopen(filenamep, "w");
     if (VL_UNLIKELY(!fp)) {
         VL_FATAL_MT(filenamep, 0, "", "+prof+threads+file file not writable");
+        // cppcheck-suppress resourceLeak   // bug, doesn't realize fp is nullptr
         return;
     }
 
     // TODO Perhaps merge with verilated_coverage output format, so can
     // have a common merging and reporting tool, etc.
     fprintf(fp, "VLPROFTHREAD 1.0 # Verilator thread profile dump version 1.0\n");
-    fprintf(fp, "VLPROF arg --threads %" VL_PRI64 "u\n",
-            vluint64_t(m_workers.size()+1));
+    fprintf(fp, "VLPROF arg --threads %" VL_PRI64 "u\n", vluint64_t(m_workers.size() + 1));
     fprintf(fp, "VLPROF arg +verilator+prof+threads+start+%" VL_PRI64 "u\n",
             Verilated::profThreadsStart());
-    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n",
-            Verilated::profThreadsWindow());
-    fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n",
-            VlMTaskVertex::yields());
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n", Verilated::profThreadsWindow());
+    fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n", VlMTaskVertex::yields());
 
     vluint32_t thread_id = 0;
-    for (ProfileSet::iterator pit = m_allProfiles.begin();
-         pit != m_allProfiles.end(); ++pit) {
+    for (ProfileSet::const_iterator pit = m_allProfiles.begin(); pit != m_allProfiles.end();
+         ++pit) {
         ++thread_id;
 
         bool printing = false;  // False while in warmup phase
-        for (ProfileTrace::iterator eit = (*pit)->begin();
-             eit != (*pit)->end(); ++eit) {
+        for (ProfileTrace::const_iterator eit = (*pit)->begin(); eit != (*pit)->end(); ++eit) {
             switch (eit->m_type) {
-            case VlProfileRec::TYPE_BARRIER:
+            case VlProfileRec::TYPE_BARRIER:  //
                 printing = true;
                 break;
             case VlProfileRec::TYPE_MTASK_RUN:
                 if (!printing) break;
-                fprintf(fp, "VLPROF mtask %d"
-                        " start %" VL_PRI64"u end %" VL_PRI64"u elapsed %" VL_PRI64 "u"
+                fprintf(fp,
+                        "VLPROF mtask %d"
+                        " start %" VL_PRI64 "u end %" VL_PRI64 "u elapsed %" VL_PRI64 "u"
                         " predict_time %u cpu %u on thread %u\n",
-                        eit->m_mtaskId,
-                        eit->m_startTime,
-                        eit->m_endTime,
-                        (eit->m_endTime - eit->m_startTime),
-                        eit->m_predictTime,
-                        eit->m_cpu,
+                        eit->m_mtaskId, eit->m_startTime, eit->m_endTime,
+                        (eit->m_endTime - eit->m_startTime), eit->m_predictTime, eit->m_cpu,
                         thread_id);
                 break;
             default: assert(false); break;  // LCOV_EXCL_LINE
             }
         }
     }
-    fprintf(fp, "VLPROF stat ticks %" VL_PRI64 "u\n",
-            ticksElapsed);
+    fprintf(fp, "VLPROF stat ticks %" VL_PRI64 "u\n", ticksElapsed);
 
     fclose(fp);
 }

include/verilated_threads.h

@@ -3,14 +3,11 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-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 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 2012-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
 //
 //=============================================================================
 ///
@@ -28,12 +25,15 @@
 #include <condition_variable>
 #include <set>
 #include <vector>
+
+// clang-format off
 #if defined(__linux)
-#include <sched.h>  // For sched_getcpu()
+# include <sched.h>  // For sched_getcpu()
 #endif
 #if defined(__APPLE__)
 # include <cpuid.h>  // For __cpuid_count()
 #endif
+// clang-format on
 
 // VlMTaskVertex and VlThreadpool will work with multiple symbol table types.
 // Since the type is opaque to VlMTaskVertex and VlThreadPool, represent it
@@ -118,10 +118,7 @@ public:
 class VlProfileRec {
 protected:
     friend class VlThreadPool;
-    enum VlProfileE {
-        TYPE_MTASK_RUN,
-        TYPE_BARRIER
-    };
+    enum VlProfileE { TYPE_MTASK_RUN, TYPE_BARRIER };
     VlProfileE m_type;  // Record type
     vluint32_t m_mtaskId;  // Mtask we're logging
     vluint32_t m_predictTime;  // How long scheduler predicted would take
@@ -176,9 +173,14 @@ private:
         VlExecFnp m_fnp;  // Function to execute
         VlThrSymTab m_sym;  // Symbol table to execute
         bool m_evenCycle;  // Even/odd for flag alternation
-        ExecRec() : m_fnp(NULL), m_sym(NULL), m_evenCycle(false) {}
+        ExecRec()
+            : m_fnp(NULL)
+            , m_sym(NULL)
+            , m_evenCycle(false) {}
         ExecRec(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
-            : m_fnp(fnp), m_sym(sym), m_evenCycle(evenCycle) {}
+            : m_fnp(fnp)
+            , m_sym(sym)
+            , m_evenCycle(evenCycle) {}
     };
 
     // MEMBERS
@@ -211,7 +213,7 @@ public:
     inline void dequeWork(ExecRec* workp) {
         // Spin for a while, waiting for new data
         for (int i = 0; i < VL_LOCK_SPINS; ++i) {
-            if (VL_LIKELY(m_ready_size.load(std::memory_order_relaxed))) {
+            if (VL_LIKELY(m_ready_size.load(std::memory_order_relaxed))) {  //
                 break;
             }
             VL_CPU_RELAX();
@@ -287,6 +289,7 @@ public:
     // this once to setup profiling state:
     void setupProfilingClientThread();
     void tearDownProfilingClientThread();
+
 private:
     VL_UNCOPYABLE(VlThreadPool);
 };

include/verilated_trace.h

@@ -0,0 +1,388 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// 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
+//
+//=============================================================================
+///
+/// \file
+/// \brief Tracing functionality common to all formats
+///
+//=============================================================================
+// SPDIFF_OFF
+
+#ifndef _VERILATED_TRACE_H_
+#define _VERILATED_TRACE_H_ 1
+
+// clang-format off
+
+#include "verilated.h"
+
+#include <string>
+#include <vector>
+
+#ifdef VL_TRACE_THREADED
+# include <condition_variable>
+# include <deque>
+# include <thread>
+#endif
+
+// clang-format on
+
+#ifdef VL_TRACE_THREADED
+//=============================================================================
+// Threaded tracing
+
+// A simple synchronized first in first out queue
+template <class T> class VerilatedThreadQueue {
+private:
+    VerilatedMutex m_mutex;  // Protects m_queue
+    std::condition_variable_any m_cv;
+    std::deque<T> m_queue VL_GUARDED_BY(m_mutex);
+
+public:
+    // Put an element at the back of the queue
+    void put(T value) {
+        VerilatedLockGuard lock(m_mutex);
+        m_queue.push_back(value);
+        m_cv.notify_one();
+    }
+
+    // Put an element at the front of the queue
+    void put_front(T value) {
+        VerilatedLockGuard lock(m_mutex);
+        m_queue.push_front(value);
+        m_cv.notify_one();
+    }
+
+    // Get an element from the front of the queue. Blocks if none available
+    T get() {
+        VerilatedLockGuard lock(m_mutex);
+        m_cv.wait(lock, [this]() VL_REQUIRES(m_mutex) { return !m_queue.empty(); });
+        assert(!m_queue.empty());
+        T value = m_queue.front();
+        m_queue.pop_front();
+        return value;
+    }
+
+    // Non blocking get
+    bool tryGet(T& result) {
+        VerilatedLockGuard lockGuard(m_mutex);
+        if (m_queue.empty()) { return false; }
+        result = m_queue.front();
+        m_queue.pop_front();
+        return true;
+    }
+};
+
+// Commands used by thread tracing. Anonymous enum in class, as we want
+// it scoped, but we also want the automatic conversion to integer types.
+class VerilatedTraceCommand {
+public:
+    // These must all fit in 4 bit at the moment, as the tracing routines
+    // pack parameters in the top bits.
+    enum {
+        CHG_BIT_0 = 0x0,
+        CHG_BIT_1 = 0x1,
+        CHG_CDATA = 0x2,
+        CHG_SDATA = 0x3,
+        CHG_IDATA = 0x4,
+        CHG_QDATA = 0x5,
+        CHG_WDATA = 0x6,
+        CHG_FLOAT = 0x7,
+        CHG_DOUBLE = 0x8,
+        // TODO: full..
+        TIME_CHANGE = 0xd,
+        END = 0xe,  // End of buffer
+        SHUTDOWN = 0xf  // Shutdown worker thread, also marks end of buffer
+    };
+};
+#endif
+
+class VerilatedTraceCallInfo;
+
+//=============================================================================
+// VerilatedTrace
+
+// VerilatedTrace uses F-bounded polymorphism to access duck-typed
+// implementations in the format specific derived class, which must be passed
+// as the type parameter T_Derived
+template <class T_Derived> class VerilatedTrace {
+private:
+    //=========================================================================
+    // Generic tracing internals
+
+    vluint32_t* m_sigs_oldvalp;  ///< Old value store
+    vluint64_t m_timeLastDump;  ///< Last time we did a dump
+    std::vector<VerilatedTraceCallInfo*> m_callbacks;  ///< Routines to perform dumping
+    bool m_fullDump;  ///< Whether a full dump is required on the next call to 'dump'
+    vluint32_t m_nextCode;  ///< Next code number to assign
+    vluint32_t m_numSignals;  ///< Number of distinct signals
+    vluint32_t m_maxBits;  ///< Number of bits in the widest signal
+    std::string m_moduleName;  ///< Name of module being trace initialized now
+    char m_scopeEscape;
+    double m_timeRes;  ///< Time resolution (ns/ms etc)
+    double m_timeUnit;  ///< Time units (ns/ms etc)
+
+    // Equivalent to 'this' but is of the sub-type 'T_Derived*'. Use 'self()->'
+    // to access duck-typed functions to avoid a virtual function call.
+    T_Derived* self() { return static_cast<T_Derived*>(this); }
+
+#ifdef VL_TRACE_THREADED
+    // Number of total trace buffers that have been allocated
+    vluint32_t m_numTraceBuffers;
+
+    // Size of trace buffers
+    size_t m_traceBufferSize;
+
+    // Buffers handed to worker for processing
+    VerilatedThreadQueue<vluint32_t*> m_buffersToWorker;
+    // Buffers returned from worker after processing
+    VerilatedThreadQueue<vluint32_t*> m_buffersFromWorker;
+
+    // Get a new trace buffer that can be populated. May block if none available
+    vluint32_t* getTraceBuffer();
+
+    // Write pointer into current buffer
+    vluint32_t* m_traceBufferWritep;
+
+    // End of trace buffer
+    vluint32_t* m_traceBufferEndp;
+
+    // The worker thread itself
+    std::unique_ptr<std::thread> m_workerThread;
+
+    // The function executed by the worker thread
+    void workerThreadMain();
+
+    // Wait until given buffer is placed in m_buffersFromWorker
+    void waitForBuffer(const vluint32_t* bufferp);
+
+    // Shut down and join worker, if it's running, otherwise do nothing
+    void shutdownWorker();
+#endif
+
+    // CONSTRUCTORS
+    VL_UNCOPYABLE(VerilatedTrace);
+
+protected:
+    //=========================================================================
+    // Internals available to format specific implementations
+
+    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
+
+    vluint32_t nextCode() const { return m_nextCode; }
+    vluint32_t numSignals() const { return m_numSignals; }
+    vluint32_t maxBits() const { return m_maxBits; }
+    const std::string& moduleName() const { return m_moduleName; }
+    void fullDump(bool value) { m_fullDump = value; }
+    vluint64_t timeLastDump() { return m_timeLastDump; }
+
+    double timeRes() const { return m_timeRes; }
+    double timeUnit() const { return m_timeUnit; }
+    std::string timeResStr() const;
+    std::string timeUnitStr() const;
+
+    void traceInit() VL_MT_UNSAFE;
+
+    void declCode(vluint32_t code, vluint32_t bits, bool tri);
+
+    /// Is this an escape?
+    bool isScopeEscape(char c) { return isspace(c) || c == m_scopeEscape; }
+    /// Character that splits scopes.  Note whitespace are ALWAYS escapes.
+    char scopeEscape() { return m_scopeEscape; }
+
+    void close();
+    void flush();
+
+    //=========================================================================
+    // Virtual functions to be provided by the format specific implementation
+
+    // Called when the trace moves forward to a new time point
+    virtual void emitTimeChange(vluint64_t timeui) = 0;
+
+    // These hooks are called before a full or change based dump is produced.
+    // The return value indicates whether to proceed with the dump.
+    virtual bool preFullDump() { return true; }
+    virtual bool preChangeDump() { return true; }
+
+public:
+    //=========================================================================
+    // External interface to client code
+
+    explicit VerilatedTrace();
+    ~VerilatedTrace();
+
+    // Set time units (s/ms, defaults to ns)
+    void set_time_unit(const char* unitp);
+    void set_time_unit(const std::string& unit);
+    // Set time resolution (s/ms, defaults to ns)
+    void set_time_resolution(const char* unitp);
+    void set_time_resolution(const std::string& unit);
+
+    // Call
+    void dump(vluint64_t timeui);
+
+    //=========================================================================
+    // Non-hot path internal interface to Verilator generated code
+
+    typedef void (*callback_t)(T_Derived* tracep, void* userthis, vluint32_t code);
+
+    void changeThread() { m_assertOne.changeThread(); }
+
+    void addCallback(callback_t initcb, callback_t fullcb, callback_t changecb,
+                     void* userthis) VL_MT_UNSAFE_ONE;
+
+    void module(const std::string& name) VL_MT_UNSAFE_ONE {
+        m_assertOne.check();
+        m_moduleName = name;
+    }
+
+    void scopeEscape(char flag) { m_scopeEscape = flag; }
+
+    //=========================================================================
+    // Hot path internal interface to Verilator generated code
+
+    // Implementation note: We rely on the following duck-typed implementations
+    // in the derived class T_Derived. These emit* functions record a format
+    // specific trace entry. Normally one would use pure virtual functions for
+    // these here, but we cannot afford dynamic dispatch for calling these as
+    // this is very hot code during tracing.
+
+    // duck-typed void emitBit(vluint32_t code, CData newval) = 0;
+    // duck-typed void emitCData(vluint32_t code, CData newval, int bits) = 0;
+    // duck-typed void emitSData(vluint32_t code, SData newval, int bits) = 0;
+    // duck-typed void emitIData(vluint32_t code, IData newval, int bits) = 0;
+    // duck-typed void emitQData(vluint32_t code, QData newval, int bits) = 0;
+    // duck-typed void emitWData(vluint32_t code, const WData* newvalp, int bits) = 0;
+    // duck-typed void emitFloat(vluint32_t code, float newval) = 0;
+    // duck-typed void emitDouble(vluint32_t code, double newval) = 0;
+
+    vluint32_t* oldp(vluint32_t code) { return m_sigs_oldvalp + code; }
+
+    // Write to previous value buffer value and emit trace entry.
+    void fullBit(vluint32_t* oldp, CData newval);
+    void fullCData(vluint32_t* oldp, CData newval, int bits);
+    void fullSData(vluint32_t* oldp, SData newval, int bits);
+    void fullIData(vluint32_t* oldp, IData newval, int bits);
+    void fullQData(vluint32_t* oldp, QData newval, int bits);
+    void fullWData(vluint32_t* oldp, const WData* newvalp, int bits);
+    void fullFloat(vluint32_t* oldp, float newval);
+    void fullDouble(vluint32_t* oldp, double newval);
+
+#ifdef VL_TRACE_THREADED
+    // Threaded tracing. Just dump everything in the trace buffer
+    inline void chgBit(vluint32_t code, CData newval) {
+        m_traceBufferWritep[0] = VerilatedTraceCommand::CHG_BIT_0 | newval;
+        m_traceBufferWritep[1] = code;
+        m_traceBufferWritep += 2;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgCData(vluint32_t code, CData newval, int bits) {
+        m_traceBufferWritep[0] = (bits << 4) | VerilatedTraceCommand::CHG_CDATA;
+        m_traceBufferWritep[1] = code;
+        m_traceBufferWritep[2] = newval;
+        m_traceBufferWritep += 3;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgSData(vluint32_t code, SData newval, int bits) {
+        m_traceBufferWritep[0] = (bits << 4) | VerilatedTraceCommand::CHG_SDATA;
+        m_traceBufferWritep[1] = code;
+        m_traceBufferWritep[2] = newval;
+        m_traceBufferWritep += 3;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgIData(vluint32_t code, IData newval, int bits) {
+        m_traceBufferWritep[0] = (bits << 4) | VerilatedTraceCommand::CHG_IDATA;
+        m_traceBufferWritep[1] = code;
+        m_traceBufferWritep[2] = newval;
+        m_traceBufferWritep += 3;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgQData(vluint32_t code, QData newval, int bits) {
+        m_traceBufferWritep[0] = (bits << 4) | VerilatedTraceCommand::CHG_QDATA;
+        m_traceBufferWritep[1] = code;
+        *reinterpret_cast<QData*>(m_traceBufferWritep + 2) = newval;
+        m_traceBufferWritep += 4;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgWData(vluint32_t code, const WData* newvalp, int bits) {
+        m_traceBufferWritep[0] = (bits << 4) | VerilatedTraceCommand::CHG_WDATA;
+        m_traceBufferWritep[1] = code;
+        m_traceBufferWritep += 2;
+        for (int i = 0; i < (bits + 31) / 32; ++i) { *m_traceBufferWritep++ = newvalp[i]; }
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgFloat(vluint32_t code, float newval) {
+        m_traceBufferWritep[0] = VerilatedTraceCommand::CHG_FLOAT;
+        m_traceBufferWritep[1] = code;
+        // cppcheck-suppress invalidPointerCast
+        *reinterpret_cast<float*>(m_traceBufferWritep + 2) = newval;
+        m_traceBufferWritep += 3;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+    inline void chgDouble(vluint32_t code, double newval) {
+        m_traceBufferWritep[0] = VerilatedTraceCommand::CHG_DOUBLE;
+        m_traceBufferWritep[1] = code;
+        // cppcheck-suppress invalidPointerCast
+        *reinterpret_cast<double*>(m_traceBufferWritep + 2) = newval;
+        m_traceBufferWritep += 4;
+        VL_DEBUG_IF(assert(m_traceBufferWritep <= m_traceBufferEndp););
+    }
+
+#define CHG(name) chg##name##Impl
+#else
+#define CHG(name) chg##name
+#endif
+
+    // In non-threaded mode, these are called directly by the trace callbacks,
+    // and are called chg*. In threaded mode, they are called by the worker
+    // thread and are called chg*Impl
+
+    // Check previous dumped value of signal. If changed, then emit trace entry
+    inline void CHG(Bit)(vluint32_t* oldp, CData newval) {
+        const vluint32_t diff = *oldp ^ newval;
+        if (VL_UNLIKELY(diff)) fullBit(oldp, newval);
+    }
+    inline void CHG(CData)(vluint32_t* oldp, CData newval, int bits) {
+        const vluint32_t diff = *oldp ^ newval;
+        if (VL_UNLIKELY(diff)) fullCData(oldp, newval, bits);
+    }
+    inline void CHG(SData)(vluint32_t* oldp, SData newval, int bits) {
+        const vluint32_t diff = *oldp ^ newval;
+        if (VL_UNLIKELY(diff)) fullSData(oldp, newval, bits);
+    }
+    inline void CHG(IData)(vluint32_t* oldp, IData newval, int bits) {
+        const vluint32_t diff = *oldp ^ newval;
+        if (VL_UNLIKELY(diff)) fullIData(oldp, newval, bits);
+    }
+    inline void CHG(QData)(vluint32_t* oldp, QData newval, int bits) {
+        const vluint64_t diff = *reinterpret_cast<QData*>(oldp) ^ newval;
+        if (VL_UNLIKELY(diff)) fullQData(oldp, newval, bits);
+    }
+    inline void CHG(WData)(vluint32_t* oldp, const WData* newvalp, int bits) {
+        for (int i = 0; i < (bits + 31) / 32; ++i) {
+            if (VL_UNLIKELY(oldp[i] ^ newvalp[i])) {
+                fullWData(oldp, newvalp, bits);
+                return;
+            }
+        }
+    }
+    inline void CHG(Float)(vluint32_t* oldp, float newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY(*reinterpret_cast<float*>(oldp) != newval)) fullFloat(oldp, newval);
+    }
+    inline void CHG(Double)(vluint32_t* oldp, double newval) {
+        // cppcheck-suppress invalidPointerCast
+        if (VL_UNLIKELY(*reinterpret_cast<double*>(oldp) != newval)) fullDouble(oldp, newval);
+    }
+
+#undef CHG
+};
+#endif  // guard

include/verilated_trace_imp.cpp

@@ -0,0 +1,640 @@
+// -*- mode: C++; c-file-style: "cc-mode" -*-
+//=============================================================================
+//
+// THIS MODULE IS PUBLICLY LICENSED
+//
+// 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
+//
+//=============================================================================
+///
+/// \file
+/// \brief Implementation of tracing functionality common to all trace formats
+///
+//=============================================================================
+// SPDIFF_OFF
+
+// clang-format off
+
+#ifndef VL_DERIVED_T
+# error "This file should be included in trace format implementations"
+#endif
+
+#include "verilated_intrinsics.h"
+#include "verilated_trace.h"
+
+#if 0
+# include <iostream>
+# define VL_TRACE_THREAD_DEBUG(msg) std::cout << "TRACE THREAD: " << msg << std::endl
+#else
+# define VL_TRACE_THREAD_DEBUG(msg)
+#endif
+
+// clang-format on
+
+//=============================================================================
+// Static utility functions
+
+static double timescaleToDouble(const char* unitp) {
+    char* endp;
+    double value = strtod(unitp, &endp);
+    // On error so we allow just "ns" to return 1e-9.
+    if (value == 0.0 && endp == unitp) value = 1;
+    unitp = endp;
+    for (; *unitp && isspace(*unitp); unitp++) {}
+    switch (*unitp) {
+    case 's': value *= 1e1; break;
+    case 'm': value *= 1e-3; break;
+    case 'u': value *= 1e-6; break;
+    case 'n': value *= 1e-9; break;
+    case 'p': value *= 1e-12; break;
+    case 'f': value *= 1e-15; break;
+    case 'a': value *= 1e-18; break;
+    }
+    return value;
+}
+
+static std::string doubleToTimescale(double value) {
+    const char* suffixp = "s";
+    // clang-format off
+    if      (value >= 1e0)   { suffixp = "s"; value *= 1e0; }
+    else if (value >= 1e-3 ) { suffixp = "ms"; value *= 1e3; }
+    else if (value >= 1e-6 ) { suffixp = "us"; value *= 1e6; }
+    else if (value >= 1e-9 ) { suffixp = "ns"; value *= 1e9; }
+    else if (value >= 1e-12) { suffixp = "ps"; value *= 1e12; }
+    else if (value >= 1e-15) { suffixp = "fs"; value *= 1e15; }
+    else if (value >= 1e-18) { suffixp = "as"; value *= 1e18; }
+    // clang-format on
+    char valuestr[100];
+    sprintf(valuestr, "%3.0f%s", value, suffixp);
+    return valuestr;  // Gets converted to string, so no ref to stack
+}
+
+//=============================================================================
+// Internal callback routines for each module being traced.
+
+// Each module that wishes to be traced registers a set of callbacks stored in
+// this class.  When the trace file is being constructed, this class provides
+// the callback routines to be executed.
+class VerilatedTraceCallInfo {
+public:  // This is in .cpp file so is not widely visible
+    typedef VerilatedTrace<VL_DERIVED_T>::callback_t callback_t;
+
+    callback_t m_initcb;  ///< Initialization Callback function
+    callback_t m_fullcb;  ///< Full Dumping Callback function
+    callback_t m_changecb;  ///< Incremental Dumping Callback function
+    void* m_userthis;  ///< User data pointer for callback
+    vluint32_t m_code;  ///< Starting code number (set later by traceInit)
+    // CONSTRUCTORS
+    VerilatedTraceCallInfo(callback_t icb, callback_t fcb, callback_t changecb, void* ut)
+        : m_initcb(icb)
+        , m_fullcb(fcb)
+        , m_changecb(changecb)
+        , m_userthis(ut)
+        , m_code(1) {}
+    ~VerilatedTraceCallInfo() {}
+};
+
+#ifdef VL_TRACE_THREADED
+//=========================================================================
+// Buffer management
+
+template <> vluint32_t* VerilatedTrace<VL_DERIVED_T>::getTraceBuffer() {
+    vluint32_t* bufferp;
+    // Some jitter is expected, so some number of alternative trace buffers are
+    // required, but don't allocate more than 8 buffers.
+    if (m_numTraceBuffers < 8) {
+        // Allocate a new buffer if none is available
+        if (!m_buffersFromWorker.tryGet(bufferp)) {
+            ++m_numTraceBuffers;
+            // Note: over allocate a bit so pointer comparison is well defined
+            // if we overflow only by a small amount
+            bufferp = new vluint32_t[m_traceBufferSize + 16];
+        }
+    } else {
+        // Block until a buffer becomes available
+        bufferp = m_buffersFromWorker.get();
+    }
+    return bufferp;
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::waitForBuffer(const vluint32_t* buffp) {
+    // Slow path code only called on flush/shutdown, so use a simple algorithm.
+    // Collect buffers from worker and stash them until we get the one we want.
+    std::deque<vluint32_t*> stash;
+    do { stash.push_back(m_buffersFromWorker.get()); } while (stash.back() != buffp);
+    // Now put them back in the queue, in the original order.
+    while (!stash.empty()) {
+        m_buffersFromWorker.put_front(stash.back());
+        stash.pop_back();
+    }
+}
+
+//=========================================================================
+// Worker thread
+
+template <> void VerilatedTrace<VL_DERIVED_T>::workerThreadMain() {
+    bool shutdown = false;
+
+    do {
+        vluint32_t* const bufferp = m_buffersToWorker.get();
+
+        VL_TRACE_THREAD_DEBUG("");
+        VL_TRACE_THREAD_DEBUG("Got buffer: " << bufferp);
+
+        const vluint32_t* readp = bufferp;
+
+        while (true) {
+            const vluint32_t cmd = readp[0];
+            const vluint32_t top = cmd >> 4;
+            // Always set this up, as it is almost always needed
+            vluint32_t* const oldp = m_sigs_oldvalp + readp[1];
+            // Note this increment needs to be undone on commands which do not
+            // actually contain a code, but those are the rare cases.
+            readp += 2;
+
+            switch (cmd & 0xF) {
+                //===
+                // CHG_* commands
+            case VerilatedTraceCommand::CHG_BIT_0:
+                VL_TRACE_THREAD_DEBUG("Command CHG_BIT_0 " << top);
+                chgBitImpl(oldp, 0);
+                continue;
+            case VerilatedTraceCommand::CHG_BIT_1:
+                VL_TRACE_THREAD_DEBUG("Command CHG_BIT_1 " << top);
+                chgBitImpl(oldp, 1);
+                continue;
+            case VerilatedTraceCommand::CHG_CDATA:
+                VL_TRACE_THREAD_DEBUG("Command CHG_CDATA " << top);
+                // Bits stored in bottom byte of command
+                chgCDataImpl(oldp, *readp, top);
+                readp += 1;
+                continue;
+            case VerilatedTraceCommand::CHG_SDATA:
+                VL_TRACE_THREAD_DEBUG("Command CHG_SDATA " << top);
+                // Bits stored in bottom byte of command
+                chgSDataImpl(oldp, *readp, top);
+                readp += 1;
+                continue;
+            case VerilatedTraceCommand::CHG_IDATA:
+                VL_TRACE_THREAD_DEBUG("Command CHG_IDATA " << top);
+                // Bits stored in bottom byte of command
+                chgIDataImpl(oldp, *readp, top);
+                readp += 1;
+                continue;
+            case VerilatedTraceCommand::CHG_QDATA:
+                VL_TRACE_THREAD_DEBUG("Command CHG_QDATA " << top);
+                // Bits stored in bottom byte of command
+                chgQDataImpl(oldp, *reinterpret_cast<const QData*>(readp), top);
+                readp += 2;
+                continue;
+            case VerilatedTraceCommand::CHG_WDATA:
+                VL_TRACE_THREAD_DEBUG("Command CHG_WDATA " << top);
+                chgWDataImpl(oldp, readp, top);
+                readp += VL_WORDS_I(top);
+                continue;
+            case VerilatedTraceCommand::CHG_FLOAT:
+                VL_TRACE_THREAD_DEBUG("Command CHG_FLOAT " << top);
+                chgFloatImpl(oldp, *reinterpret_cast<const float*>(readp));
+                readp += 1;
+                continue;
+            case VerilatedTraceCommand::CHG_DOUBLE:
+                VL_TRACE_THREAD_DEBUG("Command CHG_DOUBLE " << top);
+                chgDoubleImpl(oldp, *reinterpret_cast<const double*>(readp));
+                readp += 2;
+                continue;
+
+                //===
+                // Rare commands
+            case VerilatedTraceCommand::TIME_CHANGE:
+                VL_TRACE_THREAD_DEBUG("Command TIME_CHANGE " << top);
+                readp -= 1;  // No code in this command, undo increment
+                emitTimeChange(*reinterpret_cast<const vluint64_t*>(readp));
+                readp += 2;
+                continue;
+
+                //===
+                // Commands ending this buffer
+            case VerilatedTraceCommand::END: VL_TRACE_THREAD_DEBUG("Command END"); break;
+            case VerilatedTraceCommand::SHUTDOWN:
+                VL_TRACE_THREAD_DEBUG("Command SHUTDOWN");
+                shutdown = true;
+                break;
+
+                //===
+                // Unknown command
+            default:
+                VL_TRACE_THREAD_DEBUG("Command UNKNOWN");
+                VL_PRINTF_MT("Trace command: 0x%08x\n", cmd);
+                VL_FATAL_MT(__FILE__, __LINE__, "", "Unknown trace command");
+                break;
+            }
+
+            // The above switch will execute 'continue' when necessary,
+            // so if we ever reach here, we are done with the buffer.
+            break;
+        }
+
+        VL_TRACE_THREAD_DEBUG("Returning buffer");
+
+        // Return buffer
+        m_buffersFromWorker.put(bufferp);
+    } while (VL_LIKELY(!shutdown));
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::shutdownWorker() {
+    // If the worker thread is not running, done..
+    if (!m_workerThread) return;
+
+    // Hand an buffer with a shutdown command to the worker thread
+    vluint32_t* const bufferp = getTraceBuffer();
+    bufferp[0] = VerilatedTraceCommand::SHUTDOWN;
+    m_buffersToWorker.put(bufferp);
+    // Wait for it to return
+    waitForBuffer(bufferp);
+    // Join the thread and delete it
+    m_workerThread->join();
+    m_workerThread.reset(nullptr);
+}
+
+#endif
+
+//=============================================================================
+// Life cycle
+
+template <> void VerilatedTrace<VL_DERIVED_T>::close() {
+#ifdef VL_TRACE_THREADED
+    shutdownWorker();
+    while (m_numTraceBuffers) {
+        delete[] m_buffersFromWorker.get();
+        m_numTraceBuffers--;
+    }
+#endif
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::flush() {
+#ifdef VL_TRACE_THREADED
+    // Hand an empty buffer to the worker thread
+    vluint32_t* const bufferp = getTraceBuffer();
+    *bufferp = VerilatedTraceCommand::END;
+    m_buffersToWorker.put(bufferp);
+    // Wait for it to be returned. As the processing is in-order,
+    // this ensures all previous buffers have been processed.
+    waitForBuffer(bufferp);
+#endif
+}
+
+//=============================================================================
+// VerilatedTrace
+
+template <>
+VerilatedTrace<VL_DERIVED_T>::VerilatedTrace()
+    : m_sigs_oldvalp(NULL)
+    , m_timeLastDump(0)
+    , m_fullDump(true)
+    , m_nextCode(0)
+    , m_numSignals(0)
+    , m_maxBits(0)
+    , m_scopeEscape('.')
+    , m_timeRes(1e-9)
+    , m_timeUnit(1e-9)
+#ifdef VL_TRACE_THREADED
+    , m_numTraceBuffers(0)
+#endif
+{
+    set_time_unit(Verilated::timeunitString());
+    set_time_resolution(Verilated::timeprecisionString());
+}
+
+template <> VerilatedTrace<VL_DERIVED_T>::~VerilatedTrace() {
+    if (m_sigs_oldvalp) VL_DO_CLEAR(delete[] m_sigs_oldvalp, m_sigs_oldvalp = NULL);
+    while (!m_callbacks.empty()) {
+        delete m_callbacks.back();
+        m_callbacks.pop_back();
+    }
+#ifdef VL_TRACE_THREADED
+    close();
+#endif
+}
+
+//=========================================================================
+// Internals available to format specific implementations
+
+template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
+    m_assertOne.check();
+
+    // Note: It is possible to re-open a trace file (VCD in particular),
+    // so we must reset the next code here, but it must have the same number
+    // of codes on re-open
+    const vluint32_t expectedCodes = nextCode();
+    m_nextCode = 1;
+    m_numSignals = 0;
+    m_maxBits = 0;
+
+    // Call all initialize callbacks, which will call decl* for each signal.
+    for (vluint32_t ent = 0; ent < m_callbacks.size(); ++ent) {
+        VerilatedTraceCallInfo* cip = m_callbacks[ent];
+        cip->m_code = nextCode();
+        (cip->m_initcb)(self(), cip->m_userthis, cip->m_code);
+    }
+
+    if (expectedCodes && nextCode() != expectedCodes) {
+        VL_FATAL_MT(__FILE__, __LINE__, "",
+                    "Reopening trace file with different number of signals");
+    }
+
+    // Now that we know the number of codes, allocate space for the buffer
+    // holding previous signal values.
+    if (!m_sigs_oldvalp) m_sigs_oldvalp = new vluint32_t[nextCode()];
+
+#ifdef VL_TRACE_THREADED
+    // Compute trace buffer size. we need to be able to store a new value for
+    // each signal, which is 'nextCode()' entries after the init callbacks
+    // above have been run, plus up to 2 more words of metadata per signal,
+    // plus fixed overhead of 1 for a termination flag and 3 for a time stamp
+    // update.
+    m_traceBufferSize = nextCode() + numSignals() * 2 + 4;
+
+    // Start the worker thread
+    m_workerThread.reset(new std::thread(&VerilatedTrace<VL_DERIVED_T>::workerThreadMain, this));
+#endif
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::declCode(vluint32_t code, vluint32_t bits, bool tri) {
+    if (!code) {
+        VL_FATAL_MT(__FILE__, __LINE__, "", "Internal: internal trace problem, code 0 is illegal");
+    }
+    // Note: The tri-state flag is not used by Verilator, but is here for
+    // compatibility with some foreign code.
+    int codesNeeded = VL_WORDS_I(bits);
+    if (tri) codesNeeded *= 2;
+    m_nextCode = std::max(m_nextCode, code + codesNeeded);
+    ++m_numSignals;
+    m_maxBits = std::max(m_maxBits, bits);
+}
+
+//=========================================================================
+// Internals available to format specific implementations
+
+template <> std::string VerilatedTrace<VL_DERIVED_T>::timeResStr() const {
+    return doubleToTimescale(m_timeRes);
+}
+
+template <> std::string VerilatedTrace<VL_DERIVED_T>::timeUnitStr() const {
+    return doubleToTimescale(m_timeUnit);
+}
+
+//=========================================================================
+// External interface to client code
+
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const char* unitp) {
+    m_timeUnit = timescaleToDouble(unitp);
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const std::string& unit) {
+    set_time_unit(unit.c_str());
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const char* unitp) {
+    m_timeRes = timescaleToDouble(unitp);
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const std::string& unit) {
+    set_time_resolution(unit.c_str());
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
+    m_assertOne.check();
+    if (VL_UNLIKELY(m_timeLastDump && timeui <= m_timeLastDump)) {
+        VL_PRINTF_MT("%%Warning: previous dump at t=%" VL_PRI64 "u, requesting t=%" VL_PRI64
+                     "u, dump call ignored\n",
+                     m_timeLastDump, timeui);
+        return;
+    }
+    m_timeLastDump = timeui;
+
+    Verilated::quiesce();
+
+    // Call hook for format specific behaviour
+    if (VL_UNLIKELY(m_fullDump)) {
+        if (!preFullDump()) return;
+    } else {
+        if (!preChangeDump()) return;
+    }
+
+#ifdef VL_TRACE_THREADED
+    // Currently only incremental dumps run on the worker thread
+    vluint32_t* bufferp = nullptr;
+    if (VL_LIKELY(!m_fullDump)) {
+        // Get the trace buffer we are about to fill
+        bufferp = getTraceBuffer();
+        m_traceBufferWritep = bufferp;
+        m_traceBufferEndp = bufferp + m_traceBufferSize;
+
+        // Tell worker to update time point
+        m_traceBufferWritep[0] = VerilatedTraceCommand::TIME_CHANGE;
+        *reinterpret_cast<vluint64_t*>(m_traceBufferWritep + 1) = timeui;
+        m_traceBufferWritep += 3;
+    } else {
+        // Update time point
+        flush();
+        emitTimeChange(timeui);
+    }
+#else
+    // Update time point
+    emitTimeChange(timeui);
+#endif
+
+    // Run the callbacks
+    if (VL_UNLIKELY(m_fullDump)) {
+        m_fullDump = false;  // No more need for next dump to be full
+        for (vluint32_t ent = 0; ent < m_callbacks.size(); ++ent) {
+            VerilatedTraceCallInfo* cip = m_callbacks[ent];
+            (cip->m_fullcb)(self(), cip->m_userthis, cip->m_code);
+        }
+    } else {
+        for (vluint32_t ent = 0; ent < m_callbacks.size(); ++ent) {
+            VerilatedTraceCallInfo* cip = m_callbacks[ent];
+            (cip->m_changecb)(self(), cip->m_userthis, cip->m_code);
+        }
+    }
+
+#ifdef VL_TRACE_THREADED
+    if (VL_LIKELY(bufferp)) {
+        // Mark end of the trace buffer we just filled
+        *m_traceBufferWritep++ = VerilatedTraceCommand::END;
+
+        // Assert no buffer overflow
+        assert(m_traceBufferWritep - bufferp <= m_traceBufferSize);
+
+        // Pass it to the worker thread
+        m_buffersToWorker.put(bufferp);
+    }
+#endif
+}
+
+//=============================================================================
+// Non-hot path internal interface to Verilator generated code
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::addCallback(callback_t initcb, callback_t fullcb,
+                                               callback_t changecb,
+                                               void* userthis) VL_MT_UNSAFE_ONE {
+    m_assertOne.check();
+    if (VL_UNLIKELY(timeLastDump() != 0)) {
+        std::string msg = (std::string("Internal: ") + __FILE__ + "::" + __FUNCTION__
+                           + " called with already open file");
+        VL_FATAL_MT(__FILE__, __LINE__, "", msg.c_str());
+    }
+    VerilatedTraceCallInfo* cip = new VerilatedTraceCallInfo(initcb, fullcb, changecb, userthis);
+    m_callbacks.push_back(cip);
+}
+
+//=========================================================================
+// Hot path internal interface to Verilator generated code
+
+// These functions must write the new value back into the old value store,
+// and subsequently call the format specific emit* implementations. Note
+// that this file must be included in the format specific implementation, so
+// the emit* functions can be inlined for performance.
+
+template <> void VerilatedTrace<VL_DERIVED_T>::fullBit(vluint32_t* oldp, CData newval) {
+    *oldp = newval;
+    self()->emitBit(oldp - m_sigs_oldvalp, newval);
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::fullCData(vluint32_t* oldp, CData newval, int bits) {
+    *oldp = newval;
+    self()->emitCData(oldp - m_sigs_oldvalp, newval, bits);
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::fullSData(vluint32_t* oldp, SData newval, int bits) {
+    *oldp = newval;
+    self()->emitSData(oldp - m_sigs_oldvalp, newval, bits);
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::fullIData(vluint32_t* oldp, IData newval, int bits) {
+    *oldp = newval;
+    self()->emitIData(oldp - m_sigs_oldvalp, newval, bits);
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::fullQData(vluint32_t* oldp, QData newval, int bits) {
+    *reinterpret_cast<QData*>(oldp) = newval;
+    self()->emitQData(oldp - m_sigs_oldvalp, newval, bits);
+}
+
+template <>
+void VerilatedTrace<VL_DERIVED_T>::fullWData(vluint32_t* oldp, const WData* newvalp, int bits) {
+    for (int i = 0; i < VL_WORDS_I(bits); ++i) oldp[i] = newvalp[i];
+    self()->emitWData(oldp - m_sigs_oldvalp, newvalp, bits);
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::fullFloat(vluint32_t* oldp, float newval) {
+    // cppcheck-suppress invalidPointerCast
+    *reinterpret_cast<float*>(oldp) = newval;
+    self()->emitFloat(oldp - m_sigs_oldvalp, newval);
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::fullDouble(vluint32_t* oldp, double newval) {
+    // cppcheck-suppress invalidPointerCast
+    *reinterpret_cast<double*>(oldp) = newval;
+    self()->emitDouble(oldp - m_sigs_oldvalp, newval);
+}
+
+//=========================================================================
+// Primitives converting binary values to strings...
+
+// All of these take a destination pointer where the string will be emitted,
+// and a value to convert. There are a couple of variants for efficiency.
+
+inline static void cvtCDataToStr(char* dstp, CData value) {
+#ifdef VL_HAVE_SSE2
+    // Similar to cvtSDataToStr but only the bottom 8 byte lanes are used
+    const __m128i a = _mm_cvtsi32_si128(value);
+    const __m128i b = _mm_unpacklo_epi8(a, a);
+    const __m128i c = _mm_shufflelo_epi16(b, 0);
+    const __m128i m = _mm_set1_epi64x(0x0102040810204080);
+    const __m128i d = _mm_cmpeq_epi8(_mm_and_si128(c, m), m);
+    const __m128i result = _mm_sub_epi8(_mm_set1_epi8('0'), d);
+    _mm_storel_epi64(reinterpret_cast<__m128i*>(dstp), result);
+#else
+    dstp[0] = '0' | static_cast<char>((value >> 7) & 1);
+    dstp[1] = '0' | static_cast<char>((value >> 6) & 1);
+    dstp[2] = '0' | static_cast<char>((value >> 5) & 1);
+    dstp[3] = '0' | static_cast<char>((value >> 4) & 1);
+    dstp[4] = '0' | static_cast<char>((value >> 3) & 1);
+    dstp[5] = '0' | static_cast<char>((value >> 2) & 1);
+    dstp[6] = '0' | static_cast<char>((value >> 1) & 1);
+    dstp[7] = '0' | static_cast<char>(value & 1);
+#endif
+}
+
+inline static void cvtSDataToStr(char* dstp, SData value) {
+#ifdef VL_HAVE_SSE2
+    // We want each bit in the 16-bit input value to end up in a byte lane
+    // within the 128-bit XMM register. Note that x86 is little-endian and we
+    // want the MSB of the input at the low address, so we will bit-reverse
+    // at the same time.
+
+    // Put value in bottom of 128-bit register a[15:0] = value
+    const __m128i a = _mm_cvtsi32_si128(value);
+    // Interleave bytes with themselves
+    // b[15: 0] = {2{a[ 7:0]}} == {2{value[ 7:0]}}
+    // b[31:16] = {2{a[15:8]}} == {2{value[15:8]}}
+    const __m128i b = _mm_unpacklo_epi8(a, a);
+    // Shuffle bottom 64 bits, note swapping high bytes with low bytes
+    // c[31: 0] = {2{b[31:16]}} == {4{value[15:8}}
+    // c[63:32] = {2{b[15: 0]}} == {4{value[ 7:0}}
+    const __m128i c = _mm_shufflelo_epi16(b, 0x05);
+    // Shuffle whole register
+    // d[ 63: 0] = {2{c[31: 0]}} == {8{value[15:8}}
+    // d[126:54] = {2{c[63:32]}} == {8{value[ 7:0}}
+    const __m128i d = _mm_shuffle_epi32(c, 0x50);
+    // Test each bit within the bytes, this sets each byte lane to 0
+    // if the bit for that lane is 0 and to 0xff if the bit is 1.
+    const __m128i m = _mm_set1_epi64x(0x0102040810204080);
+    const __m128i e = _mm_cmpeq_epi8(_mm_and_si128(d, m), m);
+    // Convert to ASCII by subtracting the masks from ASCII '0':
+    // '0' - 0 is '0', '0' - -1 is '1'
+    const __m128i result = _mm_sub_epi8(_mm_set1_epi8('0'), e);
+    // Store the 16 characters to the un-aligned buffer
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(dstp), result);
+#else
+    cvtCDataToStr(dstp, value >> 8);
+    cvtCDataToStr(dstp + 8, value);
+#endif
+}
+
+inline static void cvtIDataToStr(char* dstp, IData value) {
+#ifdef VL_HAVE_AVX2
+    // Similar to cvtSDataToStr but the bottom 16-bits are processed in the
+    // top half of the YMM registerss
+    const __m256i a = _mm256_insert_epi32(_mm256_undefined_si256(), value, 0);
+    const __m256i b = _mm256_permute4x64_epi64(a, 0);
+    const __m256i s = _mm256_set_epi8(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
+                                      2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3);
+    const __m256i c = _mm256_shuffle_epi8(b, s);
+    const __m256i m = _mm256_set1_epi64x(0x0102040810204080);
+    const __m256i d = _mm256_cmpeq_epi8(_mm256_and_si256(c, m), m);
+    const __m256i result = _mm256_sub_epi8(_mm256_set1_epi8('0'), d);
+    _mm256_storeu_si256(reinterpret_cast<__m256i*>(dstp), result);
+#else
+    cvtSDataToStr(dstp, value >> 16);
+    cvtSDataToStr(dstp + 16, value);
+#endif
+}
+
+inline static void cvtQDataToStr(char* dstp, QData value) {
+    cvtIDataToStr(dstp, value >> 32);
+    cvtIDataToStr(dstp + 32, value);
+}
+
+#define cvtEDataToStr cvtIDataToStr