Version bump

Fix flexfix to directly run with python.
Tests: Fix leak found by previous commit
2026-10-03 16:44:11 +02:00 · 2021-02-25 21:43:33 -05:00 · 2021-02-25 21:19:37 -05:00 · 2021-02-25 20:38:38 -05:00 · 2021-02-25 20:13:13 -05:00 · 2021-02-25 20:05:54 -05:00
2538 changed files with 71966 additions and 35906 deletions
@@ -104,7 +104,7 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp03
+Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
 ...
@@ -1,4 +1,4 @@
-Checks:          'clang-diagnostic-*,clang-analyzer-*,*,-modernize*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-default-arguments,-fuchsia-overloaded-operator,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
+Checks:          '*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-modernize-use-auto,-modernize-use-trailing-return-type,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
 WarningsAsErrors: ''
 HeaderFilterRegex: ''
 FormatStyle:     none
@@ -3,3 +3,4 @@ exclude_paths:
  - '.github/**'
  - 'ci/build_verilator.sh'
  - 'include/vltstd/**'
+  - 'nodist/fastcov.py'
@@ -1,6 +1,6 @@
 ---
 name: Bug report
-about: Something isn't working as expected, and it isn't "Unsupported." (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+about: Something isn't working as expected, and it isn't "Unsupported." (Note our contributor agreement at https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.adoc)
 title: ''
 labels: new
 assignees: ''
@@ -1,6 +1,6 @@
 ---
 name: Feature Request
-about: Request something should be supported, or a new feature added. (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+about: Request something should be supported, or a new feature added. (Note our contributor agreement at https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.adoc)
 title: ''
 labels: new
 assignees: ''
@@ -1,6 +1,6 @@
 ---
 name: Q and A, or Other
-about: Ask a question, not related to a specific bug or feature request. (Note our contributor agreement at https://github.com/verilator/verilator/.github/blob/master/CONTRIBUTING.adoc)
+about: Ask a question, not related to a specific bug or feature request. (Note our contributor agreement at https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.adoc)
 title: ''
 labels: new
 assignees: ''
@@ -0,0 +1,137 @@
+# DESCRIPTION: Github actions config
+# This name is key to badges in README.adoc, so we use the name build
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: build
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+  schedule:
+  - cron: '0 0 * * 0' # weekly
+
+env:
+  CI_OS_NAME: linux
+  CI_COMMIT: ${{ github.sha }}
+  CCACHE_COMPRESS: 1
+  CCACHE_DIR: ${{ github.workspace }}/.ccache
+  CCACHE_MAXSIZE: 2Gi  # 2GiB for clang and gcc, 4GiB in total
+
+jobs:
+
+
+  Matrix:
+    runs-on: ubuntu-latest
+    name: Generate Build matrix
+    outputs:
+      matrix: ${{ steps.generate.outputs.matrix }}
+    steps:
+    - uses: actions/checkout@v2
+    - id: generate
+      name: Run 'generate_matrix.sh'
+      run: |
+        if [ '${{ github.event_name}}' = 'pull_request' ]; then
+          matrix='[ "ubuntu-20.04" ]'
+        else
+          matrix='[ "ubuntu-16.04", "ubuntu-18.04", "ubuntu-20.04" ]'
+        fi
+        echo "::set-output name=matrix::$matrix"
+
+
+  Build:
+    needs: Matrix
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ${{ fromJson(needs.Matrix.outputs.matrix) }}
+        debug: [ opt, dbg ]
+        compiler:
+          - { cc: clang, cxx: clang++ }
+          - { cc: gcc,   cxx: g++     }
+    runs-on: ${{ matrix.os }}
+    name: Build | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.debug }}
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ${{ matrix.os }}
+      CI_MAKE_SRC_TARGET: ${{ matrix.debug }}
+      CC: ${{ matrix.compiler.cc }}
+      CXX: ${{ matrix.compiler.cxx }}
+      CACHE_KEY: ${{ matrix.os }}-${{ matrix.compiler.cc }}
+    steps:
+
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Cache
+      uses: actions/cache@v2
+      env:
+        cache-name: ccache
+      with:
+        path: ${{ github.workspace }}/.ccache
+        key: ${{ env.CACHE_KEY }}-${{ env.cache-name }}-${{ github.sha }}
+        restore-keys: ${{ env.CACHE_KEY }}-${{ env.cache-name }}
+
+    - name: Install packages for build
+      run: ./ci/ci-install.bash
+
+    - name: Build
+      run: |
+        ./ci/ci-script.bash
+        tar cvzf verilator-${{ matrix.os}}-${CI_COMMIT}-${{ matrix.compiler.cc }}-${{ matrix.debug }}.tgz ./bin
+
+    - uses: actions/upload-artifact@v2
+      with:
+        path: verilator-${{ matrix.os}}-${{ env.CI_COMMIT }}-${{ matrix.compiler.cc }}-${{ matrix.debug }}.tgz
+
+
+  Test:
+    needs: [ Matrix, Build ]
+    strategy:
+      fail-fast: false
+      max-parallel: 8
+      matrix:
+        os: ${{ fromJson(needs.Matrix.outputs.matrix) }}
+        compiler:
+          - { cc: clang, cxx: clang++ }
+          - { cc: gcc,   cxx: g++     }
+        suite:
+          - dist-vlt-0
+          - dist-vlt-1
+          - vltmt-0
+          - vltmt-1
+    runs-on: ${{ matrix.os }}
+    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.suite }}
+    env:
+      CI_BUILD_STAGE_NAME: test
+      CI_RUNS_ON: ${{ matrix.os }}
+      CC: ${{ matrix.compiler.cc }}
+      CXX: ${{ matrix.compiler.cxx }}
+      CACHE_KEY: ${{ matrix.os }}-${{ matrix.compiler.cc }}
+    steps:
+
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Cache
+      uses: actions/cache@v2
+      env:
+        cache-name: ccache
+      with:
+        path: ${{ github.workspace }}/.ccache
+        key: ${{ env.CACHE_KEY }}-${{ env.cache-name }}-${{ github.sha }}
+        restore-keys: ${{ env.CACHE_KEY }}-${{ env.cache-name }}
+
+    - uses: actions/download-artifact@v2
+
+    - name: Install Verilator and test dependencies
+      run: |
+        tar xvzf artifact/verilator-${{ matrix.os}}-${CI_COMMIT}-${{ matrix.compiler.cc }}-opt.tgz
+        tar xvzf artifact/verilator-${{ matrix.os}}-${CI_COMMIT}-${{ matrix.compiler.cc }}-dbg.tgz
+        rm -rf artifact
+        ./ci/ci-install.bash
+
+    - name: Test
+      env:
+        TESTS: ${{ matrix.suite }}
+      run: ./ci/ci-script.bash
@@ -0,0 +1,44 @@
+# DESCRIPTION: Github actions config
+# This name is key to badges in README.adoc, so we use the name build
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: clang-format
+
+on:
+  push:
+  pull_request_target:
+  workflow_dispatch:
+
+jobs:
+  format:
+    runs-on: ubuntu-20.04
+    name: Ubuntu 20.04 | format
+    env:
+      CI_OS_NAME: linux
+      CI_RUNS_ON: ubuntu-20.04
+      CI_COMMIT: ${{ github.sha }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install packages for build
+        env:
+          CI_BUILD_STAGE_NAME: build
+        run: |
+          bash ci/ci-install.bash &&
+          sudo apt-get install clang-10 yapf3 &&
+          git config --global user.email "[email protected]" &&
+          git config --global user.name "github action"
+      - name: Format code
+        run: |
+          autoconf &&
+          ./configure &&
+          make -j 2 format CLANGFORMAT=clang-format-10 &&
+          git status
+      - name: Push
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            git commit . -m "Apply clang-format" &&
+            git push origin
+          fi
@@ -0,0 +1,17 @@
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: Contributor Agreement
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  Test:
+    name: "'docs/CONTRIBUTORS' was signed"
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v2
+    - run: test_regress/t/t_dist_contributors.pl
@@ -0,0 +1,100 @@
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: coverage
+
+on:
+  workflow_dispatch:
+  schedule:
+  - cron: '0 0 * * 0' # weekly
+
+env:
+  CI_OS_NAME: linux
+  CI_COMMIT: ${{ github.sha }}
+  CCACHE_COMPRESS: 1
+  CCACHE_DIR: ${{ github.workspace }}/.ccache
+  CCACHE_MAXSIZE: 2Gi  # 2GiB for clang and gcc, 4GiB in total
+  COVERAGE: 1
+
+jobs:
+
+
+  Build:
+    runs-on: ubuntu-20.04
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ${{ matrix.os }}
+      CACHE_KEY: ${{ matrix.os }}-${{ matrix.compiler.cc }}-coverage
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - uses: actions/cache@v2
+      env:
+        cache-name: ccache
+      with:
+        path: ${{ github.workspace }}/.ccache
+        key: ${{ env.CACHE_KEY }}-${{ env.cache-name }}-${{ github.sha }}
+        restore-keys: coverage-${{ env.cache-name }}
+
+    - name: Install dependencies for build
+      env:
+        CI_BUILD_STAGE_NAME: build
+      run: ./ci/ci-install.bash
+
+    - name: Build Verilator
+      run: |
+        ./ci/ci-script.bash
+
+        tar cvzf verilator-${CI_COMMIT}-coverage.tgz bin src/obj*/*.o src/obj*/*.gcno
+
+    - uses: actions/upload-artifact@v2
+      with:
+        path: verilator-${{ env.CI_COMMIT }}-coverage.tgz
+
+
+  Test:
+    needs: Build
+    strategy:
+      fail-fast: false
+      matrix:
+        test:
+        - vlt-
+        - vltmt-
+        num:
+        - 0
+        - 1
+        - 2
+        - 3
+        include:
+        - { test: dist, num: '' }
+    name: test-${{ matrix.test }}${{ matrix.num }}
+    runs-on: ubuntu-20.04
+    env:
+      CI_BUILD_STAGE_NAME: test
+      CI_RUNS_ON: ${{ matrix.os }}
+      CACHE_KEY: ${{ matrix.os }}-${{ matrix.compiler.cc }}-coverage
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - uses: actions/cache@v2
+      env:
+        cache-name: ccache
+      with:
+        path: ${{ github.workspace }}/.ccache
+        key: ${{ env.CACHE_KEY }}-${{ env.cache-name }}-${{ github.sha }}
+        restore-keys: coverage-${{ env.cache-name }}
+
+    - uses: actions/download-artifact@v2
+
+    - name: Install Verilator and test dependencies
+      run: |
+        tar xvzf artifact/verilator-${CI_COMMIT}-coverage.tgz
+        touch src/obj*/*.o src/obj*/*.gcno
+        ./ci/ci-install.bash
+
+    - name: Test
+      env:
+        TESTS: coverage-${{ matrix.test }}${{ matrix.num }}
+      run: ./ci/ci-script.bash
@@ -1,5 +1,6 @@
 \#*
 .#*
+.nfs*
 *~
 *.tidy
 *.old
@@ -14,6 +15,8 @@
 *.tex
 *.pdf
 /Makefile
+/.ccache
+/artifact/
 README
 TAGS
 autom4te.cache
@@ -1,187 +0,0 @@
-# DESCRIPTION: Travis-CI config
-#
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-version: ~> 1.0
-
-os: linux
-language: cpp
-cache: ccache
-
-env:
-  global:
-    - VERILATOR_CACHE=$HOME/verilator_cache
-    - VERILATOR_ROOT=$PWD
-    - VERILATOR_NUM_JOBS=$(echo `nproc` + 1 | bc)
-    - VERILATOR_CONFIG_FLAGS="--enable-maintainer-mode --enable-longtests"
-    - VERILATOR_AUTHOR_SITE=1
-
-cache:
-  directories:
-    - $VERILATOR_CACHE
-
-before_install:
-# Perl modules needed for testing
-# Not listing Bit::Vector as slow to install, and only skips one test
-  - touch temp.cpp ; g++ -E -dM -c temp.cpp | sort ; rm -rf temp.cpp
-  - yes yes | sudo cpan -fi Unix::Processors Parallel::Forker
-  - sudo apt-get install gdb gtkwave
-  - sudo apt-get install libgoogle-perftools-dev
-before_script:
-  - bash -x ci/build_vcddiff.sh
-  - bash -x ci/build_verilator.sh
-after_script:
-  - ccache -s
-
-stages:
-  - "Build Verilator"
-  - test
-
-jobs:
-  include:
-    - if: type != cron
-      stage: "Build Verilator"
-      name: Build Verilator
-      compiler: gcc
-      script: echo "Done building Verilator"
-# Non-cron build will just run on whatever linux flavor we get
-    - if: type != cron
-      stage: test
-      name: Dist test
-      compiler: gcc
-      script: ci/test.sh dist
-    - if: type != cron
-      stage: test
-      name: Vlt test
-      compiler: gcc
-      script: ci/test.sh vlt
-    - if: type != cron
-      stage: test
-      name: Vltmt set 0 test
-      compiler: gcc
-      script: ci/test.sh vltmt0
-    - if: type != cron
-      stage: test
-      name: Vltmt set 1 test
-      compiler: gcc
-      script: ci/test.sh vltmt1
-# Cron builds try different OS/compiler combinations
-    - if: type = cron
-      stage: "Build Verilator"
-      name: Build xenial gcc Verilator
-      os: linux
-      dist: xenial
-      compiler: gcc
-      script: echo "Done building Verilator"
-    - if: type = cron
-      stage: test
-      name: Xenial gcc dist test
-      os: linux
-      dist: xenial
-      compiler: gcc
-      script: ci/test.sh dist
-    - if: type = cron
-      stage: test
-      name: Xenial gcc vlt test
-      os: linux
-      dist: xenial
-      compiler: gcc
-      script: ci/test.sh vlt
-    - if: type = cron
-      stage: test
-      name: Xenial gcc vltmt test
-      os: linux
-      dist: xenial
-      compiler: gcc
-      script: ci/test.sh vltmt
-    - if: type = cron
-      stage: "Build Verilator"
-      name: Build xenial clang Verilator
-      os: linux
-      dist: xenial
-      compiler: clang
-      script: echo "Done building Verilator"
-    - if: type = cron
-      stage: test
-      name: Xenial clang dist test
-      os: linux
-      dist: xenial
-      compiler: clang
-      script: ci/test.sh dist
-    - if: type = cron
-      stage: test
-      name: Xenial clang vlt test
-      os: linux
-      dist: xenial
-      compiler: clang
-      script: ci/test.sh vlt
-    - if: type = cron
-      stage: test
-      name: Xenial clang vltmt test
-      os: linux
-      dist: xenial
-      compiler: clang
-      script: ci/test.sh vltmt
-#    - if: type = cron
-#      stage: "Build Verilator"
-#      name: Build OSX gcc Verilator
-#      os: osx
-#      compiler: gcc
-#      script: echo "Done building Verilator"
-#    - if: type = cron
-#      stage: test
-#      name: OSX gcc dist test
-#      os: osx
-#      compiler: gcc
-#      script: ci/test.sh dist
-#    - if: type = cron
-#      stage: test
-#      name: OSX gcc vlt test
-#      os: osx
-#      compiler: gcc
-#      script: ci/test.sh vlt
-#    - if: type = cron
-#      stage: test
-#      name: OSX gcc vltmt test
-#      os: osx
-#      compiler: gcc
-#      script: ci/test.sh vltmt
-    - if: type = cron
-      stage: "Build Verilator"
-      name: Build trusty gcc Verilator
-      os: linux
-      dist: trusty
-      compiler: gcc
-      script: echo "Done building Verilator"
-    - if: type = cron
-      stage: test
-      name: Trusty gcc dist test
-      os: linux
-      dist: trusty
-      compiler: gcc
-      script: ci/test.sh dist
-    - if: type = cron
-      stage: test
-      name: Trusty gcc vlt test
-      os: linux
-      dist: trusty
-      compiler: gcc
-      script: ci/test.sh vlt
-    - if: type = cron
-      stage: test
-      os: linux
-      dist: trusty
-      name: Trusty gcc vltmt test
-      compiler: gcc
-      script: ci/test.sh vltmt
-
-notifications:
-  email:
-    if: repo = verilator/verilator
-    recipients:
-      - [email protected]
-      - [email protected]
@@ -1,3 +1,4 @@
+\.ccache/
 \.clang-format
 \.clang-tidy
 \.git/
@@ -23,6 +24,7 @@
 /obj_dir/
 /obj_dist/
 /obj_iv/
+/obj_ms/
 /obj_nc/
 /obj_opt/
 /obj_vcs/
@@ -45,6 +47,8 @@ src/Makefile$
 src/Makefile_obj$
 include/verilated.mk$
 test_regress/.gdbinit$
+test_regress/transcript
+codecov.yml
 config.cache$
 config.status$
 verilator\.log
@@ -65,4 +69,5 @@ ci/
 /csrc/
 obj_dir.*
 TAGS
+gmon.out
 .*~
@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2021 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.
@@ -89,7 +89,6 @@ datarootdir = @datarootdir@
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
-CFG_WITH_THREADED = @CFG_WITH_THREADED@
 PACKAGE_VERSION = @PACKAGE_VERSION@

 #### End of system configuration section. ####
@@ -154,6 +153,7 @@ DISTFILES_INC = $(INFOS) .gitignore \
 	.*attributes */.*attributes  */*/.*attributes \
 	src/.*ignore src/*.in src/*.cpp src/*.[chly] \
 	src/astgen src/bisonpre src/*fix src/cppcheck_filtered \
+	src/config_rev \
 	src/vlcovgen src/mkinstalldirs \
 	src/.gdbinit \
 	src/*.pl src/*.pod \
@@ -171,6 +171,8 @@ DISTFILES_INC = $(INFOS) .gitignore \
 	test_regress/t/t*/*.v* \
 	test_regress/t/t*/*/*.sv* \
 	test_regress/t/t*/*/*.v* \
+	test_regress/t/t*/*.cpp \
+	test_regress/t/t*/CMakeLists.txt \
 	test_regress/t/*.cpp \
 	test_regress/t/*.h \
 	test_regress/t/*.dat \
@@ -218,7 +220,7 @@ all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 verilator_exe verilator_bin verilator_bin_dbg verilator_coverage_bin_dbg:
 	@echo ------------------------------------------------------------
 	@echo "making verilator in src"
-	$(MAKE) -C src $(OBJCACHE_JOBS)
+	$(MAKE) -C src $(OBJCACHE_JOBS) $(CI_MAKE_SRC_TARGET)

 .PHONY:msg_test
 msg_test: all_nomsg
@@ -420,12 +422,16 @@ endif

 # Use --xml flag to see the cppcheck code to use for suppression
 CPPCHECK_CPP = $(wildcard \
+	$(srcdir)/examples/*/*.cpp \
 	$(srcdir)/include/*.cpp \
 	$(srcdir)/src/*.cpp )
 CPPCHECK_H = $(wildcard \
 	$(srcdir)/include/*.h \
 	$(srcdir)/src/*.h )
-CPPCHECK = src/cppcheck_filtered
+CPPCHECK_YL = $(wildcard \
+	$(srcdir)/src/*.y \
+	$(srcdir)/src/*.l )
+CPPCHECK = src/cppcheck_filtered cppcheck
 CPPCHECK_FLAGS = --enable=all --inline-suppr \
 	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList \
 	--suppress=nullPointerRedundantCheck
@@ -435,18 +441,19 @@ CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/src/obj_dbg -I$(srcdir)/src

 cppcheck: $(CPPCHECK_DEP)
 %.cppcheck: %.cpp
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $<
+	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 -DVL_THREADED=1 $(CPPCHECK_INC) $<

 CLANGTIDY = clang-tidy
-CLANGTIDY_FLAGS = -config=''
+CLANGTIDY_FLAGS = -config='' -checks='-fuchsia-*,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-init-variables'
 CLANGTIDY_DEP = $(subst .h,.h.tidy,$(CPPCHECK_H)) \
 	$(subst .cpp,.cpp.tidy,$(CPPCHECK_CPP))
+CLANGTIDY_DEFS = -DVL_DEBUG=1 -DVL_THREADED=1 -DVL_CPPCHECK=1

-clangtidy: $(CLANGTIDY_DEP)
+clang-tidy: $(CLANGTIDY_DEP)
 %.cpp.tidy: %.cpp
-	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- $(CLANGTIDY_DEFS) $(CPPCHECK_INC) | 2>&1 tee $@
 %.h.tidy: %.h
-	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) | 2>&1 tee $@
+	$(CLANGTIDY) $(CLANGTIDY_FLAGS) $< -- $(CLANGTIDY_DEFS) $(CPPCHECK_INC) | 2>&1 tee $@

 analyzer-src:
 	-rm -rf src/obj_dbg
@@ -456,13 +463,41 @@ analyzer-include:
 	-rm -rf examples/*/obj*
 	scan-build $(MAKE) -k examples

+format: clang-format yapf format-pl-exec
+
 CLANGFORMAT = clang-format
 CLANGFORMAT_FLAGS = -i
+CLANGFORMAT_FILES = $(CPPCHECK_CPP) $(CPPCHECK_H) $(CPPCHECK_YL) test_regress/t/*.c* test_regress/t/*.h

 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)
+	$(CLANGFORMAT) $(CLANGFORMAT_FLAGS) $(CLANGFORMAT_FILES)
+
+YAPF = yapf3
+YAPF_FLAGS = -i
+YAPF_FILES = \
+	examples/xml_py/vl_file_copy \
+	examples/xml_py/vl_hier_graph \
+	src/astgen \
+	src/bisonpre \
+	src/config_rev \
+	src/cppcheck_filtered \
+	src/flexfix \
+	src/vlcovgen \
+	nodist/code_coverage \
+	nodist/code_coverage.dat \
+	nodist/dot_importer \
+	nodist/fuzzer/actual_fail \
+	nodist/fuzzer/generate_dictionary \
+	nodist/install_test \
+
+yapf:
+	$(YAPF) $(YAPF_FLAGS) $(YAPF_FILES)
+
+format-pl-exec:
+	-chmod a+x test_regress/t/*.pl
+

 ftp: info

@@ -543,9 +578,6 @@ dist-file-list:
 	@echo $(wildcard $(DISTFILES))
 	@echo "end-dist-file-list:";  # Scripts look for this

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

@@ -5,7 +5,8 @@ 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/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]
+image:https://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg[Coverage,link=https://codecov.io/gh/verilator/verilator]
+image:https://github.com/verilator/verilator/workflows/build/badge.svg[Build Status (GitHub),link=https://github.com/verilator/verilator/actions?query=workflow%3Abuild]
 endif::[]

 ifdef::env-github[]
@@ -20,9 +21,9 @@ endif::[]

 == Welcome to Verilator

-[cols="a,a",indent=0,frame="none"]
+[cols="a,a",indent=0,frame="none",grid="rows"]
 |===
-^.^| *Welcome to Verilator, the fastest Verilog HDL simulator.*
+^.^| *Welcome to Verilator, the fastest Verilog/SystemVerilog simulator.*
 +++ <br/> +++ &bullet; Accepts synthesizable Verilog or SystemVerilog
 +++ <br/> +++ &bullet; Performs lint code-quality checks
 +++ <br/> +++ &bullet; Compiles into multithreaded {cpp}, or SystemC
@@ -73,15 +74,15 @@ 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 SystemVerilog to
-{cpp} or SystemC, and your team is comfortable writing just a
-touch of {cpp} code, Verilator is the tool for you.
+{cpp} or SystemC, or 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,
 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
+{cpp}/SystemC 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
@@ -112,9 +113,11 @@ For more information:
 * https://verilator.org/verilator_doc.html[Verilator manual (HTML)],
 or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)]

+* https://github.com/verilator/verilator-announce[Subscribe to verilator announcements]
+
 * https://verilator.org/forum[Verilator forum]

-* https://verilator.org/issues[Verilator Issues]
+* https://verilator.org/issues[Verilator issues]

 == Support

@@ -142,7 +145,7 @@ perhaps Icarus may.

 == Open License

-Verilator is Copyright 2003-2020 by Wilson Snyder.  (Report bugs to
+Verilator is Copyright 2003-2021 by Wilson Snyder.  (Report bugs to
 https://verilator.org/issues[Verilator Issues].)

 Verilator is free software; you can redistribute it and/or modify it under
@@ -1,7 +1,7 @@
 #!/usr/bin/env perl
 ######################################################################
 #
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2021 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.
@@ -156,6 +156,8 @@ verilator_coverage - Verilator coverage analyzer

    verilator_coverage  -write merged.dat -read <datafiles>...

+    verilator_coverage  -write-info merged.info -read <datafiles>...
+
 Verilator_coverage processes Verilator coverage reports.

 With --anotate, it reads the specified data file and generates annotated
@@ -224,8 +226,20 @@ Displays program version and exits.
 =item --write I<filename>

 Specifies the aggregate coverage results, summed across all the files,
-should be written to the given filename.  This is useful in scripts to
-combine many sequential runs into one master coverage file.
+should be written to the given filename in verilator_coverage data format.
+This is useful in scripts to combine many sequential runs into one master
+coverage file.
+
+=item --write-info I<filename.info>
+
+Specifies the aggregate coverage results, summed across all the files,
+should be written to the given filename in C<lcov> .info format.
+This may be used to use C<lcov> to aggregate or generate reports.
+
+The info format loses data compared to the Verilator coverage data format;
+the info will all forms of coverage converted to line style coverage, and
+if there are multiple coverage points on a single line, the minimum
+coverage across those points will be used to report coverage of the line.

 =back

@@ -264,7 +278,7 @@ Specifies a module search directory.

 The latest version is available from L<https://verilator.org>.

-Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+Copyright 2003-2021 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.
@@ -277,7 +291,7 @@ Wilson Snyder <[email protected]>

 =head1 SEE ALSO

-C<verilator>
+C<verilator>, C<lcov>

 L<verilator_coverage --help> which is the source for this document.

@@ -9,22 +9,6 @@ use Pod::Usage;
 use strict;
 use vars qw($Debug);

-#======================================================================
-
-# Old version 1 dump nodes with no dtypep's
-our %Ver1_Non_Dtyped = map {$_ => 1} qw(
-  ACTIVE ALWAYS ALWAYSPOST ALWAYSPUBLIC ATTROF BEGIN BREAK CASE CASEITEM
-  CCALL CELL CELLINLINE CFILE CFUNC CHANGEDET CLOCKING COMMENT CONTINUE
-  COVERDECL COVERINC COVERTOGGLE CRETURN CSTMT DEFPARAM DISABLE DISPLAY DOT
-  DPIEXPORT FCLOSE FFLUSH FINAL FINISH FOPEN GENCASE GENERATE GENFOR GENIF
-  IF IMPLICIT INITARRAY INITIAL JUMPGO JUMPLABEL MODULE NETLIST
-  NOTFOUNDMODULE PACKAGE PACKAGEIMPORT PARSEREF PIN PORT PRAGMA PRIMITIVE
-  PSLASSERT PSLCOVER PSLDEFCLOCK PULL RANGE READMEM REPEAT RETURN SCCTOR
-  SCDTOR SCHDR SCIMP SCIMPHDR SCINT SCOPE SELBIT SELEXTRACT SELMINUS
-  SELPLUS SENGATE SENITEM SENTREE SFORMAT SFORMATF STOP SYSIGNORE SYSTEMT
-  TASK TASKREF TEXT TOPSCOPE TYPEDEFFWD TYPETABLE UCSTMT UDPTABLE
-  UDPTABLELINE UNTILSTABLE VASSERT WHILE );
-
 #======================================================================
 # main

@@ -133,8 +117,6 @@ sub filter {
        $line =~ s/{[a-z]*\d+}/{}/g if !$Opt_Lineno;
        if ($verCvt) {
            next if $line =~ /^     NETLIST/;
-            $line =~ s!\@dt=0x\(G?/?([^)]+)\)!$1!g;  # NEW: @dt -> OLD: non @dt format
-            #                                        # Below Ver1_Non_Dtyped may replace above further
            if ($line =~ /: ([A-Z]+) /) {
                my $type = $1;
                next if $type =~ 'DTYPE';
@@ -147,14 +129,7 @@ sub filter {
                    }
                    next;
                }
-                if ($Ver1_Non_Dtyped{$type}) {
-                    $line =~ s! w[0-9]+!!g;
-                }
            }
-            $line =~ s!\@dt=0$!NoW!g;   # NEW: dt=null -> common format
-            $line =~ s!\@dt=0 !NoW !g;  # NEW: dt=null -> common format
-            $line =~ s! s?w0$! NoW!g;   # OLD: no width -> common format
-            $line =~ s! s?w0 ! NoW !g;  # OLD: no width -> common format
        }
        print $f2 $line;
    }
@@ -233,7 +208,7 @@ Do not show differences in line numbering.

 The latest version is available from L<https://verilator.org>.

-Copyright 2005-2020 by Wilson Snyder. This program is free software; you
+Copyright 2005-2021 by Wilson Snyder. This program is free software; you
 can redistribute it and/or modify it under the terms of either the GNU
 Lesser General Public License Version 3 or the Perl Artistic License
 Version 2.0.
@@ -60,6 +60,7 @@ sub process {
    my $filename = shift;

    read_data($filename);
+    read_cpuinfo();
    report();
 }

@@ -70,7 +71,7 @@ sub read_data {

    %Global = (rdtsc_cycle_time => 0);

-    my $fh = IO::File->new ($filename) or die "%Error: $! $filename,";
+    my $fh = IO::File->new("<$filename") or die "%Error: $! $filename,";
    while (my $line = $fh->getline) {
        if ($line =~ m/VLPROF mtask\s(\d+)\sstart\s(\d+)\send\s(\d+)\selapsed\s(\d+)\spredict_time\s(\d+)\scpu\s(\d+)\son thread (\d+)/) {
            my $mtask = $1;
@@ -113,6 +114,27 @@ sub read_data {
    }
 }

+sub read_cpuinfo {
+    my $filename = "/proc/cpuinfo";
+    my $fh = IO::File->new("<$filename") or return;
+    my $cpu;
+    while (my $line = $fh->getline) {
+        chomp $line;
+        if ($line =~ m/^processor\s*:\s*(\d+)\s*$/) {
+            $cpu = $1;
+        }
+        if ($cpu && $line =~ m/^([a-z_ ]+)\s*:\s*(.*)$/) {
+            my ($term, $value) = ($1, $2);
+            $term =~ s/\s+$//;
+            $term =~ s/\s+/_/;
+            $value =~ s/\s+$//;
+            $Global{cpuinfo}{$cpu}{$term} = $value;
+        }
+    }
+}
+
+#######################################################################
+
 sub report {
    print "Verilator Gantt report\n";

@@ -156,14 +178,15 @@ sub report {
    print "\nAnalysis:\n";
    printf "  Total threads             = %d\n", $nthreads;
    printf "  Total mtasks              = %d\n", scalar(keys %Mtasks);
-    printf "  Total cpus used           = %d\n", scalar(keys %{$Global{cpus}});
+    my $ncpus = scalar(keys %{$Global{cpus}});
+    printf "  Total cpus used           = %d\n", $ncpus;
    printf "  Total yields              = %d\n", $Global{stats}{yields};
    printf "  Total eval time           = %d rdtsc ticks\n", $Global{last_end};
    printf "  Longest mtask time        = %d rdtsc ticks\n", $long_mtask_time;
    printf "  All-thread mtask time     = %d rdtsc ticks\n", $mt_mtask_time;
-    my $long_efficiency = $long_mtask_time/($Global{last_end});
+    my $long_efficiency = $long_mtask_time/($Global{last_end} || 1);
    printf "  Longest-thread efficiency = %0.1f%%\n", $long_efficiency*100;
-    my $mt_efficiency = $mt_mtask_time/($Global{last_end}*$nthreads);
+    my $mt_efficiency = $mt_mtask_time/($Global{last_end}*$nthreads || 1);
    printf "  All-thread efficiency     = %0.1f%%\n", $mt_efficiency*100;
    printf "  All-thread speedup        = %0.1f\n", $mt_efficiency*$nthreads;
    if ($Global{rdtsc_cycle_time} > 0) {
@@ -197,17 +220,72 @@ sub report {
    }

    print "\nStatistics:\n";
-    print "  min log(p2e) = $min_p2e  from mtask $min_mtask (predict $Mtasks{$min_mtask}{predict}, elapsed $Mtasks{$min_mtask}{elapsed})\n";
-    print "  max log(p2e) = $max_p2e  from mtask $max_mtask (predict $Mtasks{$max_mtask}{predict}, elapsed $Mtasks{$max_mtask}{elapsed})\n";
+    printf "  min log(p2e) = %0.3f", $min_p2e;
+    print "  from mtask $min_mtask (predict $Mtasks{$min_mtask}{predict},";
+    print " elapsed $Mtasks{$min_mtask}{elapsed})\n";
+    printf "  max log(p2e) = %0.3f", $max_p2e;
+    print "  from mtask $max_mtask (predict $Mtasks{$max_mtask}{predict},";
+    print " elapsed $Mtasks{$max_mtask}{elapsed})\n";

    my $stddev = stddev(\@p2e_ratios);
    my $mean = mean(\@p2e_ratios);
-    print "  mean = " . ($mean) . "\n";
-    print "  stddev = " . ($stddev) . "\n";
-    print "  e ^ stddev = " . exp($stddev). "\n";
+    printf "  mean = %0.3f\n", $mean;
+    printf "  stddev = %0.3f\n", $stddev;
+    printf "  e ^ stddev = %0.3f\n", exp($stddev);
+
+    report_cpus();
+
+    if ($nthreads > $ncpus) {
+        print "\n";
+        print "%Warning: There were fewer CPUs ($ncpus) then threads ($nthreads).\n";
+        print "        : See docs on use of numactl.\n";
+    } else {
+        if ($Global{cpu_socket_cores_warning}) {
+            print "\n";
+            print "%Warning: Multiple threads scheduled on same hyperthreaded core.\n";
+            print "        : See docs on use of numactl.\n";
+        }
+        if ($Global{cpu_sockets_warning}) {
+            print "\n";
+            print "%Warning: Threads scheduled on multiple sockets.\n";
+            print "        : See docs on use of numactl.\n";
+        }
+    }
    print "\n";
 }

+sub report_cpus {
+    print "\nCPUs:\n";
+    # Test - show all cores
+    # for (my $i=0; $i<73; ++$i) { $Global{cpus}{$i} ||= {cpu_time => 0}; }
+
+    $Global{cpu_sockets} ||= {};
+    $Global{cpu_socket_cores} ||= {};
+
+    foreach my $cpu (sort {$a <=> $b} keys %{$Global{cpus}}) {
+        printf "  cpu %d: ", $cpu;
+        printf "cpu_time=%d", $Global{cpus}{$cpu}{cpu_time};
+
+        my $socket = $Global{cpuinfo}{$cpu}{physical_id};
+        $Global{cpu_sockets}{$socket}++ if defined $socket;
+        printf " socket=%d", $socket if defined $socket;
+
+        my $core = $Global{cpuinfo}{$cpu}{core_id};
+        $Global{cpu_socket_cores}{$socket."__".$core}++ if defined $socket && defined $core;
+        printf " core=%d", $core if defined $core;
+
+        my $model = $Global{cpuinfo}{$cpu}{model_name};
+        printf "  %s", $model if defined $model;
+        print "\n";
+    }
+
+    $Global{cpu_sockets_warning} = 1
+        if (scalar keys %{$Global{cpu_sockets}} > 1);
+    foreach my $scn (values %{$Global{cpu_socket_cores}}) {
+        $Global{cpu_socket_cores_warning} = 1 if $scn > 1;
+    }
+}
+
 sub report_graph {
    my $time_per = $Opt_Time_Per_Char;
    if ($time_per == 0) {
@@ -219,6 +297,7 @@ sub report_graph {
        }
        # One more step so we can fit more labels
        $time_per = int($time_per/2);
+        $time_per ||= 1;
    }

    my ($graph, $conflicts) = _make_graph($time_per);
@@ -538,7 +617,7 @@ verilator_gantt.vcd.

 The latest version is available from L<https://verilator.org>.

-Copyright 2018-2020 by Wilson Snyder. This program is free software; you
+Copyright 2018-2021 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.
@@ -1,7 +1,7 @@
 #!/usr/bin/env perl
 # DESCRIPTION: Print include statements for each ARGV
 #
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2021 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.
@@ -228,7 +228,7 @@ Displays this message and program version and exits.

 The latest version is available from L<https://verilator.org>.

-Copyright 2007-2020 by Wilson Snyder. This program is free software; you
+Copyright 2007-2021 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.
@@ -1,19 +0,0 @@
-#!/bin/bash
-# DESCRIPTION: Verilator: Build script for vcddiff
-#
-# Copyright 2019 by Todd Strader. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-set -e
-
-# NB: it would be better to add this via a PPA
-
-TMP_DIR=$(mktemp -d)
-
-git -C "${TMP_DIR}" clone https://github.com/veripool/vcddiff
-VCDDIFF_DIR=${TMP_DIR}/vcddiff
-git -C "${VCDDIFF_DIR}" checkout 5112f88b7ba8818dce9dfb72619e64a1fc19542c
-make -C "${VCDDIFF_DIR}"
-sudo cp "${VCDDIFF_DIR}/vcddiff" /usr/local/bin
@@ -1,65 +0,0 @@
-#!/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
-# 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
-# script, but other CI systems that depend on Verilator may also use
-# the script.
-# see: https://github.com/verilator/verilator_ext_tests/blob/master/.travis.yml
-# To use this script, either checkout Verilator as part of the CI build
-# process or add Verilator as a Git submodule.  Verilator tarballs can
-# not be used as the script relies on Git revisions for caching.
-set -e
-
-if [ -z "${VERILATOR_NUM_JOBS}" ]; then
-    VERILATOR_NUM_JOBS=$(nproc)
-fi
-
-# Caching would be simpler if we installed without VERILATOR_ROOT, but
-#   it's needed for driver.pl outside of the repo
-if [ -z "${VERILATOR_ROOT}" ]; then
-    echo "VERILATOR_ROOT not set"
-    exit -1
-fi
-
-if [ -z "${VERILATOR_CACHE}" ]; then
-    echo "VERILATOR_CACHE not set"
-    exit -1
-fi
-
-VERILATOR_REV=$(cd "${VERILATOR_ROOT}" && git rev-parse HEAD)
-echo "Found Verilator rev ${VERILATOR_REV}"
-
-CACHED_REV_FILE=${VERILATOR_CACHE}/.rev.txt
-
-if [[ ! -f "${CACHED_REV_FILE}" || \
-      $(< "${CACHED_REV_FILE}") != "${VERILATOR_REV}" ]]; then
-    echo "Building Verilator"
-
-    # Unsure why Travis monkies with the capitalization of the stage name, but it does
-    if [[ -n ${TRAVIS_BUILD_STAGE_NAME} && \
-         ${TRAVIS_BUILD_STAGE_NAME} != "Build verilator" ]]; then
-      echo "WARNING: Building Verilator in Travis build stage other than \"Build verilator\": ${TRAVIS_BUILD_STAGE_NAME}"
-    fi
-
-    cd "${VERILATOR_ROOT}"
-    autoconf && ./configure ${VERILATOR_CONFIG_FLAGS} && make -j ${VERILATOR_NUM_JOBS}
-    # Copy the Verilator build artifacts
-    mkdir -p "${VERILATOR_CACHE}"
-    rm -rf ${VERILATOR_CACHE}/*
-    cp bin/*bin* "${VERILATOR_CACHE}"
-    # Remember the Git revision
-    echo "${VERILATOR_REV}" > "${CACHED_REV_FILE}"
-else
-    echo "Using cached Verilator"
-    cd "${VERILATOR_ROOT}"
-    # Create include/verilated_config.h and maybe other things
-    autoconf && ./configure ${VERILATOR_CONFIG_FLAGS}
-    cp ${VERILATOR_CACHE}/* bin
-fi
@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# DESCRIPTION: Verilator: CI ccache maintenance
+#
+# Copyright 2020 by Geza Lore. This program is free software; you
+# can redistribute it and/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 is run in 'before_script', once ccache has been set up.
+################################################################################
+
+set -e
+set -x
+
+# Show version
+ccache --version
+
+# Flush ccache if requested in commit message
+COMMIT="${CI_PULL_REQUEST_SHA:-$CI_COMMIT}"
+if git log --format=%B -n 1 "$COMMIT" | grep -q -i '\[CI\s\+ccache\s\+clear\]'; then
+  echo "Flushing ccache due to commit message"
+  ccache -C
+fi
+
+# Dump stats, then zero stats
+ccache -s -z
@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# DESCRIPTION: Verilator: CI dependency install script
+#
+# Copyright 2020 by Geza Lore. This program is free software; you
+# can redistribute it and/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 runs in the 'install' phase of all jobs, in all stages. We try to
+# minimize the time spent in this by selectively installing only the components
+# required by the particular build stage.
+################################################################################
+
+set -e
+set -x
+
+cd $(dirname "$0")/..
+
+fatal() {
+  echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
+}
+
+if [ "$CI_OS_NAME" = "linux" ]; then
+  MAKE=make
+elif [ "$CI_OS_NAME" = "osx" ]; then
+  MAKE=make
+elif [ "$CI_OS_NAME" = "freebsd" ]; then
+  MAKE=gmake
+else
+  fatal "Unknown os: '$CI_OS_NAME'"
+fi
+
+install-vcddiff() {
+  TMP_DIR="$(mktemp -d)"
+  git clone https://github.com/veripool/vcddiff "$TMP_DIR"
+  git -C "${TMP_DIR}" checkout 5112f88b7ba8818dce9dfb72619e64a1fc19542c
+  "$MAKE" -C "${TMP_DIR}"
+  sudo cp "${TMP_DIR}/vcddiff" /usr/local/bin
+}
+
+if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
+  ##############################################################################
+  # Dependencies of jobs in the 'build' stage, i.e.: packages required to
+  # build Verilator
+
+  if [ "$CI_OS_NAME" = "linux" ]; then
+    sudo apt-get update
+    sudo apt-get install libfl-dev libgoogle-perftools-dev ccache
+    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ]; then
+      sudo apt-get install libsystemc libsystemc-dev
+    fi
+    if [ "$COVERAGE" = 1 ]; then
+      yes yes | sudo cpan -fi Parallel::Forker
+    fi
+    if [ "$M32" = 1 ]; then
+      sudo apt-get install gcc-multilib g++-multilib
+    fi
+  elif [ "$CI_OS_NAME" = "osx" ]; then
+    brew update
+    brew install ccache perl gperftools
+  elif [ "$CI_OS_NAME" = "freebsd" ]; then
+    sudo pkg install -y autoconf bison ccache gmake perl5
+  else
+    fatal "Unknown os: '$CI_OS_NAME'"
+  fi
+
+  if [ -n "$CCACHE_DIR" ]; then
+    mkdir -p "$CCACHE_DIR" && ./ci/ci-ccache-maint.bash
+  fi
+elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
+  ##############################################################################
+  # Dependencies of jobs in the 'test' stage, i.e.: packages required to
+  # run the tests
+
+  if [ "$CI_OS_NAME" = "linux" ]; then
+    sudo apt-get update
+    # libfl-dev needed for internal coverage's test runs
+    sudo apt-get install gdb gtkwave lcov libfl-dev ccache
+    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ]; then
+      sudo apt-get install libsystemc-dev
+    fi
+    if [ "$M32" = 1 ]; then
+      sudo apt-get install lib32z1-dev gcc-multilib g++-multilib
+    fi
+  elif [ "$CI_OS_NAME" = "osx" ]; then
+    brew update
+    # brew cask install gtkwave # fst2vcd hangs at launch, so don't bother
+    brew install ccache perl
+  elif [ "$CI_OS_NAME" = "freebsd" ]; then
+    # fst2vcd fails with "Could not open '<input file>', exiting."
+    sudo pkg install -y ccache gmake perl5 python3
+  else
+    fatal "Unknown os: '$CI_OS_NAME'"
+  fi
+  # Common installs
+  if [ "$CI_RUNS_ON" != "ubuntu-14.04" ]; then
+    CI_CPAN_REPO=https://cpan.org
+  fi
+  yes yes | sudo cpan -M $CI_CPAN_REPO -fi Parallel::Forker
+  install-vcddiff
+
+  autoconf
+  ./configure --enable-longtests --enable-ccwarn
+else
+  ##############################################################################
+  # Unknown build stage
+  fatal "Unknown build stage: '$CI_BUILD_STAGE_NAME'"
+fi
@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# DESCRIPTION: Verilator: CI main job script
+#
+# Copyright 2020 by Geza Lore. This program is free software; you
+# can redistribute it and/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 is the main script executed in the 'script' phase by all jobs. We use a
+# single script to keep the CI setting simple. We pass job parameters via
+# environment variables using 'env' keys.
+################################################################################
+
+set -e
+set -x
+
+fatal() {
+  echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
+}
+
+if [ "$CI_OS_NAME" = "linux" ]; then
+  export MAKE=make
+  NPROC=$(nproc)
+elif [ "$CI_OS_NAME" = "osx" ]; then
+  export MAKE=make
+  NPROC=$(sysctl -n hw.logicalcpu)
+elif [ "$CI_OS_NAME" = "freebsd" ]; then
+  export MAKE=gmake
+  NPROC=$(sysctl -n hw.ncpu)
+else
+  fatal "Unknown os: '$CI_OS_NAME'"
+fi
+
+if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
+  ##############################################################################
+  # Build verilator
+
+  if [ "$COVERAGE" != 1 ]; then
+    autoconf
+    ./configure --enable-longtests --enable-ccwarn
+    "$MAKE" -j "$NPROC" -k
+    if [ "$CI_OS_NAME" = "osx" ]; then
+      file bin/verilator_bin
+      file bin/verilator_bin_dbg
+      md5 bin/verilator_bin
+      md5 bin/verilator_bin_dbg
+      stat bin/verilator_bin
+      stat bin/verilator_bin_dbg
+    fi
+  else
+    nodist/code_coverage --stages 0-2
+  fi
+elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
+  ##############################################################################
+  # Run tests
+
+  export VERILATOR_TEST_NO_CONTRIBUTORS=1  # Separate workflow check
+
+  if [ "$CI_OS_NAME" = "osx" ]; then
+    export VERILATOR_TEST_NO_GDB=1  # Pain to get GDB to work on OS X
+    export VERILATOR_TEST_NO_GPROF=1  # Apple Clang has no -pg
+    # export PATH="/Applications/gtkwave.app/Contents/Resources/bin:$PATH" # fst2vcd
+    file bin/verilator_bin
+    file bin/verilator_bin_dbg
+    md5 bin/verilator_bin
+    md5 bin/verilator_bin_dbg
+    stat bin/verilator_bin
+    stat bin/verilator_bin_dbg
+    # For some reason, the dbg exe is corrupted by this point ('file' reports
+    # it as data rather than a Mach-O). Unclear if this is an OS X issue or
+    # CI's. Remove the file and re-link...
+    rm bin/verilator_bin_dbg
+    "$MAKE" -j "$NPROC" -k
+  elif [ "$CI_OS_NAME" = "freebsd" ]; then
+    export VERILATOR_TEST_NO_GDB=1 # Disable for now, ideally should run
+    export VERILATOR_TEST_NO_GPROF=1 # gprof is a bit different on FreeBSD, disable
+  fi
+
+  # Run sanitize on Ubuntu 20.04 only
+  [ "$CI_RUNS_ON" = 'ubuntu-20.04' ] && sanitize='--sanitize' || sanitize=''
+
+  # Run the specified test
+  case $TESTS in
+    dist-vlt-0)
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/2
+      ;;
+    dist-vlt-1)
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/2
+      ;;
+    vltmt-0)
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
+      ;;
+    vltmt-1)
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
+      ;;
+    coverage-all)
+      nodist/code_coverage --stages 1-
+      ;;
+    coverage-dist)
+      nodist/code_coverage --stages 1- --scenarios=--dist
+      ;;
+    coverage-vlt-0)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=0/4
+      ;;
+    coverage-vlt-1)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=1/4
+      ;;
+    coverage-vlt-2)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=2/4
+      ;;
+    coverage-vlt-3)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=3/4
+      ;;
+    coverage-vltmt-0)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=0/4
+      ;;
+    coverage-vltmt-1)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=1/4
+      ;;
+    coverage-vltmt-2)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=2/4
+      ;;
+    coverage-vltmt-3)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=3/4
+      ;;
+    *)
+      fatal "Unknown test: $TESTS"
+      ;;
+  esac
+  # Upload coverage data to codecov.io
+  if [[ $TESTS == coverage-* ]]; then
+    bash <(curl -s https://codecov.io/bash) -f nodist/obj_dir/coverage/app_total.info
+  fi
+else
+  ##############################################################################
+  # Unknown build stage
+  fatal "Unknown build stage: '$CI_BUILD_STAGE_NAME'"
+fi
@@ -6,45 +6,41 @@
 # Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

-FROM ubuntu:18.04
+FROM ubuntu:20.04

 RUN apt-get update \
    && DEBIAN_FRONTEND=noninteractive \
       apt-get install --no-install-recommends -y \
-                        autoconf=2.69-11 \
-                        bc=1.07.1-2 \
-                        bison=2:3.0.4.dfsg-1build1 \
-                        build-essential=12.4ubuntu1 \
-                        ca-certificates=20180409 \
-                        cmake=3.10.2-1ubuntu2.18.04.1 \
-                        flex=2.6.4-6 \
-                        gdb=8.1-0ubuntu3.2 \
-                        gcc-6=6.5.0-2ubuntu1~18.04 \
-                        gcc-5=5.5.0-12ubuntu1 \
-                        gcc-4.8=4.8.5-4ubuntu8 \
-                        git=1:2.17.1-1ubuntu0.5 \
-                        gtkwave=3.3.86-1 \
-                        g++-6=6.5.0-2ubuntu1~18.04 \
-                        g++-5=5.5.0-12ubuntu1 \
-                        g++-4.8=4.8.5-4ubuntu8 \
-                        libfl2=2.6.4-6 \
-                        libfl-dev=2.6.4-6 \
-                        numactl=2.0.11-2.1ubuntu0.1 \
-                        perl=5.26.1-6ubuntu0.3 \
-                        python3=3.6.7-1~18.04 \
-                        wget=1.19.4-1ubuntu2.2 \
-                        zlibc=0.9k-4.3 \
-                        zlib1g=1:1.2.11.dfsg-0ubuntu2 \
-                        zlib1g-dev=1:1.2.11.dfsg-0ubuntu2 \
+                        autoconf \
+                        bc \
+                        bison \
+                        build-essential \
+                        ca-certificates \
+                        ccache \
+                        clang \
+                        cmake \
+                        flex \
+                        gdb \
+                        git \
+                        gtkwave \
+                        libfl2 \
+                        libfl-dev \
+                        libgoogle-perftools-dev \
+                        libsystemc \
+                        libsystemc-dev \
+                        numactl \
+                        perl \
+                        python3 \
+                        wget \
+                        zlibc \
+                        zlib1g \
+                        zlib1g-dev \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

 WORKDIR /tmp

-COPY build-systemc.sh /tmp/
-RUN ./build-systemc.sh
-
-RUN cpan install -fi Unix::Processors Parallel::Forker Bit::Vector
+RUN cpan install -fi Parallel::Forker

 RUN git clone https://github.com/veripool/vcddiff.git && \
    make -C vcddiff && \
@@ -55,4 +51,6 @@ COPY build.sh /tmp/build.sh

 ENV VERILATOR_AUTHOR_SITE=1

+WORKDIR /work
+
 ENTRYPOINT [ "/tmp/build.sh" ]
@@ -5,7 +5,7 @@ build. It uses the following parameters:

 * Source repository (default: https://github.com/verilator/verilator)
 * Source revision (default: master)
-* GCC version (4.8.5, 5.5.0, 6.5.0, 7.4.0, default: 7.4.0)
+* Compiler (GCC 9.3.0, clang 10.0.0, default: 9.3.0)

 The container is published as `verilator/verilator-buildenv` on
 https://hub.docker.com/repository/docker/verilator/verilator-buildenv[docker hub].
@@ -20,13 +20,13 @@ To also run tests:

 To change the compiler:

-    docker run -ti -e CC=gcc-4.8 -e CXX=g++-4.8 verilator/verilator-buildenv test
+    docker run -ti -e CC=clang-10 -e CXX=clang++-10 verilator/verilator-buildenv test

 The tests that involve gdb are not working due to security restrictions.
 To run those too:

 ....
-docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` -e CC=gcc-4.8 -e CXX=g++-4.8 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
+docker run -ti -e CC=clang-10 -e CXX=clang++-10 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
 ....

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

-GCCVERSION=$(${CC} --version | grep gcc | awk '{print $4}')
-
-export SYSTEMC_INCLUDE="/usr/local/systemc-2.3.3-gcc${GCCVERSION}/include"
-export SYSTEMC_LIBDIR="/usr/local/systemc-2.3.3-gcc${GCCVERSION}/lib-linux64"
-export LD_LIBRARY_PATH=${SYSTEMC_LIBDIR}
-
 SRCS=$PWD/verilator

 git clone "$REPO" "$SRCS"
@@ -6,19 +6,20 @@
 # Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

-FROM ubuntu:18.04
+FROM ubuntu:20.04

 RUN apt-get update \
+    && DEBIAN_FRONTEND=noninteractive \
    && apt-get install --no-install-recommends -y \
-                        autoconf=2.69-11 \
-                        bc=1.07.1-2 \
-                        bison=2:3.0.4.dfsg-1build1 \
-                        build-essential=12.4ubuntu1 \
-                        ca-certificates=20180409 \
+                        autoconf \
+                        bc \
+                        bison \
+                        build-essential \
+                        ca-certificates \
                        ccache \
-                        flex=2.6.4-6 \
+                        flex \
                        git \
-                        libfl-dev=2.6.4-6 \
+                        libfl-dev \
                        libgoogle-perftools-dev \
                        perl \
                        python3 \
@@ -27,5 +27,5 @@ if [ -e ${obj_dir} ]; then
    cp -r /usr/local/share/verilator/bin ${obj_dir}/vlt
    cp -r /usr/local/share/verilator/include ${obj_dir}/vlt
    # Point Makefile to that folder
-    perl -i -pe 's/VERILATOR_ROOT = \/usr\/local\/share\/verilator/VERILATOR_ROOT = vlt/g' ${obj_dir}/*.mk
+    sed -i 's/VERILATOR_ROOT = \/usr\/local\/share\/verilator/VERILATOR_ROOT = vlt/g' ${obj_dir}/*.mk
 fi
@@ -1,34 +0,0 @@
-#!/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
-# 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'
-
-case $1 in
-    dist)
-        make -C test_regress SCENARIOS=--dist
-        ;;
-    vlt)
-        make -C test_regress SCENARIOS=--vlt
-        ;;
-    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
-    ;;
-esac
@@ -0,0 +1,38 @@
+# DESCRIPTION: codecov.io config
+#
+# Copyright 2020-2021 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
+####################
+# Validate:
+#  curl --data-binary @codecov.yml https://codecov.io/validate
+
+codecov:
+  require_ci_to_pass: no
+
+coverage:
+  precision: 2
+  round: down
+  range: "50...100"
+  ignore:
+    - "ci"
+    - "docs"
+    - "examples"
+    - "include/gtkwave"
+    - "include/vltstd"
+    - "test_regress"
+
+parsers:
+  gcov:
+    branch_detection:
+      conditional: yes
+      loop: yes
+      method: no
+      macro: no
+
+comment:
+  layout: "reach,diff,flags,tree"
+  behavior: default
+  require_changes: yes
@@ -1,22 +1,26 @@
 # DESCRIPTION: Process this file with autoconf to produce a configure script.
 #
-# Copyright 2003-2020 by Wilson Snyder. Verilator is free software; you
+# Copyright 2003-2021 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.034 2020-05-03],
+AC_INIT([Verilator],[4.110 2021-02-25],
        [https://verilator.org],
        [verilator],[https://verilator.org])
 # When releasing, also update header of Changes file
 # and commit using "devel release" or "Version bump" message
+# Then 'make maintainer-dist'

 AC_CONFIG_HEADER(src/config_build.h)
 AC_CONFIG_FILES(Makefile docs/Makefile src/Makefile src/Makefile_obj include/verilated.mk include/verilated_config.h verilator.pc verilator-config.cmake verilator-config-version.cmake)

+# Version
 AC_MSG_RESULT([configuring for $PACKAGE_STRING])
+PACKAGE_VERSION_NUMBER=`AS_ECHO("$PACKAGE_VERSION") | sed 's/ .*//g'`
+AC_SUBST(PACKAGE_VERSION_NUMBER)

 # Ignore automake flags passed by Ubuntu builds
 AC_ARG_ENABLE([dependency-tracking],
@@ -109,27 +113,11 @@ AC_ARG_ENABLE([longtests],
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)

-# CFG_WITH_PREC11
-AC_MSG_CHECKING(whether allow pre-C++11)
-AC_ARG_ENABLE([prec11],
-              [AS_HELP_STRING([--enable-prec11],
-                              [enable pre-C++11 compilers for Verilator binary
-                               and Verilated makefiles])],
-              [case "${enableval}" in
-                yes) CFG_WITH_PREC11=yes ;;
-                no)  CFG_WITH_PREC11=no ;;
-                *)   AC_MSG_ERROR([bad value ${enableval} for --enable-prec11]) ;;
-               esac],
-              [CFG_WITH_PREC11=no;]
-              )
-AC_SUBST(CFG_WITH_PREC11)
-AC_MSG_RESULT($CFG_WITH_PREC11)
-
-# Compiler flags
-CFLAGS+=" -I${includedir}"
-CPPFLAGS+=" -I${includedir}"
-CXXFLAGS+=" -I${includedir}"
-LDFLAGS+=" -L${libdir}"
+# Compiler flags (ensure they are not empty to avoid configure defaults)
+CFLAGS+=" "
+CPPFLAGS+=" "
+CXXFLAGS+=" "
+LDFLAGS+=" "

 # Checks for programs.
 AC_PROG_CC
@@ -150,14 +138,25 @@ AC_PATH_PROG(PERL,perl)
 if test "x$PERL" = "x" ; then
   AC_MSG_ERROR([Cannot find "perl" in your PATH, please install it])
 fi
+
+AC_PATH_PROG(PYTHON3,python3)
+if test "x$PYTHON3" = "x" ; then
+   AC_MSG_ERROR([Cannot find "python3" in your PATH, please install it])
+fi
+
 AC_PATH_PROG(LEX,flex)
 if test "x$LEX" = "x" ; then
   AC_MSG_ERROR([Cannot find "flex" in your PATH, please install it])
 fi
+flex_version=$($LEX --version | head -1)
+AC_MSG_RESULT([$LEX --version = $flex_version])
+
 AC_PATH_PROG(YACC,bison)
 if test "x$YACC" = "x" ; then
   AC_MSG_ERROR([Cannot find "bison" in your PATH, please install it])
 fi
+bison_version=$($YACC --version | head -1)
+AC_MSG_RESULT([$YACC --version = $bison_version])

 AC_CHECK_PROG(OBJCACHE,ccache,ccache)
 if test "x$OBJCACHE" != "x" ; then
@@ -400,12 +399,17 @@ _MY_LDLIBS_CHECK_IFELSE(
   fi])
 AC_SUBST(CFG_LIBS)

-# Set CFG_WITH_THREADED if can support threading
-AC_MSG_CHECKING(whether $CXX supports Verilated threads)
-ACO_SAVE_CXXFLAGS="$CXXFLAGS"
-CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_STD_NEWEST $CFG_CXXFLAGS_NO_UNUSED"
-AC_LINK_IFELSE(
-     [AC_LANG_PROGRAM([#include <thread>], [[ ]])],
+# Need C++11 at least
+#Alternative: AX_CXX_COMPILE_STDCXX([11])
+AC_DEFUN([_MY_CXX_CHECK_CXX_VER],
+   [# _MY_CXX_CHECK_CXX_VER(flag) -- Check if compiler runs C++11
+    # Set $_my_result
+    AC_LINK_IFELSE(
+     [AC_LANG_PROGRAM([#include <thread>
+#if (__cplusplus < 201103L)
+# error "Too old"
+#endif
+    ], [[ ]])],
     [_my_result=yes
      if test -s conftest.err; then
        if grep -e "$1" conftest.err >/dev/null; then
@@ -413,24 +417,24 @@ AC_LINK_IFELSE(
        fi
      fi],
     [_my_result=no])
-CFG_WITH_THREADED=$_my_result
-AC_SUBST(CFG_WITH_THREADED)
-AC_MSG_RESULT($CFG_WITH_THREADED)
+   ])

-# Check compiler flag
-if test "$CFG_WITH_THREADED" = "no" ; then
-   if test "$CFG_WITH_PREC11" = "no" ; then
-      AC_MSG_NOTICE([[]])
-      AC_MSG_ERROR([[the $CXX compiler appears to not support C++11.
+AC_MSG_CHECKING(whether $CXX supports C++11)
+_MY_CXX_CHECK_CXX_VER()
+AC_MSG_RESULT($_my_result)
+if test "$_my_result" = "no" ; then
+   CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_STD_NEWEST"
+   CFG_CXX_FLAGS_CMAKE="$CFG_CXX_FLAGS_CMAKE $CFG_CXXFLAGS_STD_NEWEST"
+   AC_MSG_CHECKING(whether $CXX supports C++11 with $CFG_CXXFLAGS_STD_NEWEST)
+   _MY_CXX_CHECK_CXX_VER()
+   AC_MSG_RESULT($_my_result)
+fi
+if test "$_my_result" = "no" ; then
+   AC_MSG_NOTICE([[]])
+   AC_MSG_ERROR([[the $CXX compiler appears to not support C++11.

-Verilator plans to require a C++11 or newer compiler in a future release,
-unless sufficient people report problems. Therefore, if you do not have a
-C++11 compiler, please post a message to
-https://www.veripool.org/boards/3/topics/2580-Verilator-Requiring-C-11-compiler
-indicating your OS and when you think C++11 might be ok, and then rerun
-configure with the --enable-prec11 argument. Thanks.]])
+Verilator requires a C++11 or newer compiler.]])

-   fi
 fi

 # Checks for library functions.
@@ -438,6 +442,24 @@ AC_CHECK_MEMBER([struct stat.st_mtim.tv_nsec],
    [AC_DEFINE([HAVE_STAT_NSEC],[1],[Defined if struct stat has st_mtim.tv_nsec])],
    [], [#include <sys/stat.h>])

+# HAVE_SYSTEMC
+# - If found the default search path has it, so support is always enabled.
+# - If not found or not system-wide, user can set SYSTEMC_INCLUDE.
+# AC_CHECK_HEADERS seems to not locate on Travis-CI but include does work.
+AC_MSG_CHECKING([whether SystemC is found (in system path)])
+ACO_SAVE_LIBS="$LIBS"
+LIBS="$LIBS -lsystemc"
+AC_LINK_IFELSE(
+    [AC_LANG_PROGRAM([[#include <systemc.h>
+                     extern "C" int sc_main(int argc, char* argv[]) {}
+                     ]],[[sc_version()]])],
+    [_my_result=yes
+     AC_DEFINE([HAVE_SYSTEMC],[1],[Defined if have SystemC library])],
+    [_my_result=no])
+AC_MSG_RESULT($_my_result)
+LIBS="$ACO_SAVE_LIBS"
+AC_SUBST(HAVE_SYSTEMC)
+
 # Checks for system services

 # Other install directories
@@ -27,8 +27,8 @@ contributions flow more efficiently.
 * You may attach a patch to the issue, or (preferred) may request a GitHub
  pull request.

-** Verilator uses Travis CI to provide continuous integration. You may
-   want to setup Travis CI on your GitHub branch to ensure your changes
+** Verilator uses GitHub Actions to provide continuous integration. You may
+   want to enable Actions on your GitHub branch to ensure your changes
   keep the tests passing.  See link:internals.adoc[docs/internals].

 * Your source-code contributions must be certified as open source, under
@@ -5,45 +5,87 @@ Please see the Verilator manual for 200+ additional contributors. Thanks to all.

 Ahmed El-Mahmoudy
 Alex Chadwick
+Àlex Torregrosa
+Andreas Kuster
 Chris Randall
+Conor McCullough
+Dan Petrisko
+David Horton
 David Stanford
 Driss Hafdi
+Edgar E. Iglesias
 Eric Rippey
+Fan Shupei
 Garrett Smith
 Geza Lore
 Gianfranco Costamagna
+Glen Gibb
+Harald Heckmann
 Howard Su
+Huang Rui
 Iztok Jeras
 James Hanlon
+James Hutchinson
+Jamey Hicks
+James Pallister
+Jan Van Winkel
+Jean Berniolles
 Jeremy Bennett
 John Coiner
 John Demme
+Josh Redford
 Julien Margetts
+Kaleb Barrett
 Kanad Kanhere
 Kevin Kiningham
+Krzysztof Bieganski
 Kuba Ober
+Ludwig Rogiers
 Lukasz Dalek
 Maarten De Braekeleer
 Maciej Sobkowski
 Marco Widmer
+Markus Krause
+Marlon James
+Marshal Qiao
 Matthew Ballance
+Michael Killough
 Mike Popoloski
+Morten Borup Petersen
+Nandu Raj
 Nathan Kohagen
 Nathan Myers
 Patrick Stewart
+Paul Wright
 Peter Horvath
 Peter Monsson
 Philipp Wagner
+Pierre-Henri Horrein
 Pieter Kapsenberg
+Piotr Binkowski
 Qingyao Sun
+Rafal Kapuscik
 Richard Myers
+Rupert Swarbrick
+Samuel Riedel
 Sean Cross
 Sebastien Van Cauwenberghe
+Sergi Granell
 Stefan Wallentowitz
+Stephen Henry
+Tim Snyder
 Tobias Rosenkranz
 Tobias Wölfel
 Todd Strader
+Tomasz Gorochowik
+Tymoteusz Blazejczyk
+Unai Martinez-Corral
+Victor Besyakov
+Vassilis Papaefstathiou
 Veripool API Bot
 Wilson Snyder
+Yossi Nivin
+Yuri Victorovich
 Yutetsu TAKATSUKASA
 Yves Mathieu
+HyungKi Jeong
@@ -7,7 +7,7 @@
 #
 #*****************************************************************************
 #
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2021 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.
@@ -1,6 +1,6 @@
 // DESCRIPTION: Verilator: List of To Do issues.
 //
-// Copyright 2004-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2004-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -84,7 +84,7 @@
   "if (a) { ... b=2; } else { ... b=2;}" -> "b=2; if ..."
   Careful though, as b could appear in the statement or multiple times in statement
   (Could just require exatly two 'b's in statement)
-** Simplify XOR/XNOR/AND/OR bit selection trees
+** Simplify XOR/AND/OR bit selection trees
   Foo = A[1] ^ A[2] ^ A[3] etc are better as ^ ( A & 32'b...1110 )
 ** Combine variables into wider elements
   Parallel statements on different bits should become single signal
@@ -96,8 +96,6 @@
   Don't merge if any combining would form circ logic (out goes back to in)
 ** Multiple assignments each bit can become single assign with concat
   Make sure a SEL of a CONCAT can get the single bit back.
-** Usually blocks/values
-   Enable only after certain time, so VL_TIME_I(32) > 0x1e gets eliminated out
 ** Better ordering of a<=b, b<=c, put all refs to 'b' next to each other to optimize caching
 ** I-cache packing improvements (what/how?)
 ** Data cache organization (order of vars in class)
@@ -39,7 +39,7 @@ brief:
 #sudo apt-get install libfl2  # Ubuntu only (ignore if gives error)
 #sudo apt-get install libfl-dev  # Ubuntu only (ignore if gives error)

-git clone https://git.veripool.org/git/verilator   # Only first time
+git clone https://github.com/verilator/verilator   # Only first time
 ## Note the URL above is not a page you can see with a browser, it's for git only

 # Every time you need to build:
@@ -69,19 +69,18 @@ Linux distribution, see instead <<Install From a Package Manager>>.

 === OS Requirements

-Verilator is developed and has primary testing on Ubuntu.  Versions have
-also built on Redhat Linux, Apple OS-X, HPUX and Solaris.  It should run
-with minor porting on any GNU/Linux-ish platform.  Verilator also works on
-Windows under Cygwin, and Windows under MinGW (gcc -mno-cygwin).  Verilated
-output (not Verilator itself) compiles under all the options above, plus
-MSVC++.
+Verilator is developed and has primary testing on Ubuntu, with additional
+testing on FreeBSD and Apple OS-X.  Versions have also built on Redhat
+Linux, HPUX and Solaris.  It should run with minor porting on any
+GNU/Linux-ish platform.  Verilator also works on Windows under Cygwin, and
+Windows under MinGW (gcc -mno-cygwin).  Verilated output (not Verilator
+itself) compiles under all the options above, plus MSVC++.

 === Install Prerequisites

 To build or run Verilator you need these standard packages:

-   sudo apt-get install perl python3
-   sudo apt-get install make
+   sudo apt-get install perl python3 make
   sudo apt-get install g++  # Alternatively, clang
   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)
@@ -90,21 +89,18 @@ To build or run the following are optional but should be installed for
 good performance:

   sudo apt-get install ccache  # If present at build, needed for run
-   sudo apt-get install libgoogle-perftools-dev numactl
+   sudo apt-get install libgoogle-perftools-dev numactl perl-doc

 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
+   sudo apt-get install git autoconf flex bison

 Those developing Verilator itself may also want these (see internals.adoc):

-   sudo apt-get install gdb asciidoctor graphviz cmake clang-format
+   sudo apt-get install gdb asciidoctor graphviz cmake clang clang-format gprof lcov
   cpan install Pod::Perldoc
-   cpan install Unix::Processors
   cpan install Parallel::Forker
-   cpan install Bit::Vector

 ==== Install SystemC

@@ -130,7 +126,7 @@ Downloads]; we presume you know how to use it, and is not described here.)

 Get the sources from the repository: (You need do this only once, ever.)

-   git clone https://git.veripool.org/git/verilator   # Only first time
+   git clone https://github.com/verilator/verilator   # Only first time
   ## Note the URL above is not a page you can see with a browser, it's for git only

 Enter the checkout and determine what version/branch to use:
@@ -266,10 +262,9 @@ set in your environment; it is built into the executable.

 == Announcements

-To get notified of new releases, login to
-https://www.veripool.org[Veripool], and click the "watch" button near the
-top right under https://www.veripool.org/projects/verilator/news[Verilator
-News].
+To get notified of new releases, go to
+https://github.com/verilator/verilator-announce[Verilator announcement
+repository] and follow the instructions there.

 == Directory Structure

@@ -302,7 +297,7 @@ or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].

 == License

-Copyright 2008-2020 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2021 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
@@ -387,10 +387,8 @@ changed; if clear, checking those signals for changes may be skipped.

 === Compiler Version and C++11

-Verilator supports GCC 4.4.7 and newer.  GCC 4.4.7 does not support C++11,
-therefore C++11 is generally not required.  Exceptions may be made to
-require C++11 for features that are only practical with C++11,
-e.g. threads.
+Verilator requires C++11. Verilator does not require any newer versions,
+but is maintained to build successfully with C++14/C++17/C++20.

 === Indentation and Naming Style

@@ -411,8 +409,9 @@ style indentation; the `c-set-style` undoes that.)

 * Comment every member variable.

-Indentation is automatically maintained with "make clang-format" (using
-clang-format version 10.0.0).  For those manually formatting:
+Indentation is automatically maintained with "make format" using
+clang-format version 10.0.0, and yapf for python, and is automatically
+corrected in the CI actions.  For those manually formatting C++ code:

 * Use 4 spaces per level, and no tabs.

@@ -588,7 +587,7 @@ dealing with. For example a visitor might not implement separate `visit`
 methods for `AstIf` and `AstGenIf`, but just a single method for the base
 class:

-   void visit (AstNodeIf* nodep)
+   void visit(AstNodeIf* nodep)

 However that method might want to specify additional code if it is called
 for `AstGenIf`. Verilator does this by providing a `VN_IS` method for each
@@ -630,8 +629,6 @@ 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,
@@ -674,7 +671,7 @@ Set to 1 to indicate that the compilation or execution is intended to fail.
 For example the following would specify that compilation requires two
 defines and is expected to fail.

-   compile (
+   compile(
      verilator_flags2 => ["-DSMALL_CLOCK -DGATED_COMMENT"],
      fails => 1,
      );
@@ -700,7 +697,7 @@ Verilator problem.
 When enabling the long tests, some additional PERL modules are needed,
 which you can install using cpan.

-   cpan install Unix::Processors
+   cpan install Parallel::Forker

 There are some traps to avoid when running regression tests

@@ -732,20 +729,17 @@ test, run the following command.

 === Continuous Integration

-Verilator has a https://travis-ci.com/verilator/verilator[Travis CI environment]
-which automatically tests the master branch for test failures on new commits. It
-also runs a daily cron job to validate all of the tests against different OS and
-compiler versions.
+Verilator uses GitHub Actions which automatically tests the master branch
+for test failures on new commits. It also runs a daily cron job to validate
+all of the tests against different OS and compiler versions.

-Developers can connect Travis CI to their GitHub account so that the CI
-environment can check their branches too by doing the following:
+Developers can enable Actions on their GitHub repository so that the CI
+environment can check their branches too by enabling the build workflow:

-* Go to https://github.com/marketplace/travis-ci and follow the prompts
-
-* Only the Open Source (FREE) version of Travis CI is required
-
-* Under a Travis CI project click More options > Settings in order to set up a
-cron job on a particular branch
+* On GitHub, navigate to the main page of the repository.
+* Under your repository name, click Actions.
+* In the left sidebar, click the workflow you want to enable ("build").
+* Click Enable workflow.

 === Fuzzing

@@ -760,6 +754,15 @@ may be required to setup the system for fuzzing.

 == Debugging

+=== Debug Levels
+
+The "UINFO" calls in the source indicate a debug level. Messages level 3
+and below are globally enabled with `--debug`. Higher levels may be
+controlled with `--debugi <level>`.  An individual source file levels may
+be controlled with `-debugi-<srcfile> <level>`.  For example `--debug
+--debugi 5 --debugi-V3Width 9` will use the debug binary at default debug
+level 5, with the V3Width.cpp file at level 9.
+
 === --debug

 When you run with `--debug` there are two primary output file types placed
@@ -777,19 +780,20 @@ output, for example:
 You can then print a.ps.  You may prefer gif format, which doesn't get
 scaled so can be more useful with large graphs.

-For dynamic graph viewing consider
+For interactive graph viewing consider
+https://github.com/jrfonseca/xdot.py[xdot] or
 http://zvtm.sourceforge.net/zgrviewer.html[ZGRViewer].  If you know of
-better viewers let us know; ZGRViewer isn't great for large graphs.
+better viewers (especially for large graphs) please let us know.

 === .tree Output

 Tree files are dumps of the AST Tree and are produced between every major
 algorithmic stage.  An example:

-     NETLIST 0x90fb00 <e1> {a0}
-    1: MODULE 0x912b20 <e8822> {a8}  top  L2 [P]
-   *1:2: VAR 0x91a780 <e74#> {a22} @dt=0xa2e640(w32)  out_wide [O] WIRE
-    1:2:1: BASICDTYPE 0xa2e640 <e2149> {e24} @dt=this(sw32)  integer kwd=integer range=[31:0]
+     NETLIST 0x90fb00 <e1> {a0ah}
+    1: MODULE 0x912b20 <e8822> {a8ah}  top  L2 [P]
+   *1:2: VAR 0x91a780 <e74#> {a22ah} @dt=0xa2e640(w32)  out_wide [O] WIRE
+    1:2:1: BASICDTYPE 0xa2e640 <e2149> {e24ah} @dt=this(sw32)  integer kwd=integer range=[31:0]

 The following summarizes the above example dump, with more detail on each
 field in the section below.
@@ -807,8 +811,9 @@ the `MODULE`, which in turn is the `op1p` pointer under the `NETLIST`
 | `<e74>` | means the 74th edit to the netlist was the last modification to
 this node.

-| `{a22}` | indicates this node is related to line 22 in the source filename
-"a", where "a" is the first file read, "z" the 26th, and "aa" the 27th.
+| `{a22ah}` | indicates this node is related to the source filename "a",
+where "a" is the first file read, "z" the 26th, and "aa" the 27th.  Then
+line 22 in that file, then column 8 (aa=0, az=25, ba=26, ...).

 | `@dt=0x...` | indicates the address of the data type this node contains.

@@ -849,7 +854,10 @@ correspond directly to Verilog entities (for example `MODULE` and
 Address of the node::

 A hexadecimal address of the node in memory. Useful for examining with the
-debugger.
+debugger. If the actual address values are not important, then using the
+`--dump-tree-addrids` option will convert address values to short identifiers
+of the form `([A-Z]*)`, which is hopefully easier for the reader to cross
+reference throughout the dump.

 Last edit number::

@@ -947,9 +955,9 @@ Then, when the watch fires, to break at every following change to that node:
 To print a node:

   pn nodep
-   # or: call nodep->dumpGdb()  # aliased to "pn" in src/.gdbinit
+   # or: call dumpGdb(nodep)  # aliased to "pn" in src/.gdbinit
   pnt nodep
-   # or: call nodep->dumpTreeGdb()  # aliased to "pnt" in src/.gdbinit
+   # or: call dumpTreeGdb(nodep)  # aliased to "pnt" in src/.gdbinit

 When GDB halts, it is useful to understand that the backtrace will commonly
 show the iterator functions between each invocation of `visit` in the
@@ -996,9 +1004,27 @@ function in `src/verilator.cpp`.
 To get your pass to build you'll need to add its binary filename to the
 list in `src/Makefile_obj.in` and reconfigure.

+=== "Never" features
+
+Verilator ideally would support all of IEEE, and has the goal to get close
+to full support. However the following IEEE sections and features are not
+anticipated to be ever implemented for the reasons indicated.
+
+[horizontal]
+IEEE 1800-2017 3.3 recursive modules:: Little/no tool support, and arguably not a good practice.
+IEEE 1800-2017 6.12 "shortreal":: Little/no tool support, and easily simply promoted to real.
+IEEE 1800-2017 11.11 Min, typ, max:: No SDF support so will always use typical.
+IEEE 1800-2017 11.12 "let":: Little/no tool support, makes difficult to implement parsers.
+IEEE 1800-2017 20.15 Probabilistic functions:: Little industry use.
+IEEE 1800-2017 20.16 Stochastic analysis:: Little industry use.
+IEEE 1800-2017 20.17 PLA modeling:: Little industry use and outdated technology.
+IEEE 1800-2017 31 Timing checks:: No longer relevant with static timing analysis tools.
+IEEE 1800-2017 32 SDF annotation:: No longer relevant with static timing analysis tools.
+IEEE 1800-2017 33 Config:: Little/no tool support or industry use.
+
 == Distribution

-Copyright 2008-2020 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2008-2021 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
@@ -66,7 +66,7 @@ elements in the `<module>` elements using the `dtype_id` attribute.

 == Distribution

-Copyright 2020-2020 by Wilson Snyder.  Verilator is free software; you can
+Copyright 2020-2021 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
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -6,11 +6,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -56,7 +54,7 @@ run:

 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j

 	@echo
 	@echo "-- RUN ---------------------"
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -6,11 +6,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -92,7 +90,7 @@ run:

 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j

 	@echo
 	@echo "-- RUN ---------------------"
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -6,11 +6,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -56,7 +54,7 @@ run:

 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j

 	@echo
 	@echo "-- RUN ---------------------"
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -6,11 +6,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -56,7 +54,7 @@ run:

 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j

 	@echo
 	@echo "-- RUN ---------------------"
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -6,11 +6,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -92,7 +90,7 @@ run:

 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j

 	@echo
 	@echo "-- RUN ---------------------"
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -19,7 +19,7 @@ int main(int argc, char** argv, char** env) {
    // e.g. examples/c_tracing.

    // Prevent unused variable warnings
-    if (0 && argc && argv && env) {}
+    if (false && argc && argv && env) {}

    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
    Vtop* top = new Vtop;
@@ -37,6 +37,6 @@ int main(int argc, char** argv, char** env) {
    // Destroy model
    delete top;

-    // Fin
-    exit(0);
+    // Return good completion status
+    return 0;
 }
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -23,30 +23,23 @@ int sc_main(int argc, char* argv[]) {
    // e.g. examples/c_tracing.

    // Prevent unused variable warnings
-    if (0 && argc && argv) {}
+    if (false && argc && argv) {}

    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
    Vtop* top = new Vtop("top");

    // Initialize SC model
-#if (SYSTEMC_VERSION >= 20070314)
    sc_start(1, SC_NS);
-#else
-    sc_start(1);
-#endif

    // Simulate until $finish
    while (!Verilated::gotFinish()) {
-#if (SYSTEMC_VERSION >= 20070314)
+        // Simulate 1ns
        sc_start(1, SC_NS);
-#else
-        sc_start(1);
-#endif
    }

    // Final model cleanup
    top->final();

-    // Fin
+    // Return good completion status
    return 0;
 }
@@ -5,11 +5,9 @@
 # This calls the object directory makefiles.  That allows the objects to
 # be placed in the "current directory" which simplifies the Makefile.
 #
-# 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
+# This file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -70,7 +68,7 @@ run:
 	@echo " library (libverilated_secret.a) generated from the previous"
 	@echo " step"
 	@echo "---------------------------------------------------------------"
-	$(VERILATOR) $(TOP_VERILATOR_FLAGS) --exe -LDFLAGS '-L../obj_dir_secret -lverilated_secret -static' top.v obj_dir_secret/verilated_secret.sv sim_main.cpp
+	$(VERILATOR) $(TOP_VERILATOR_FLAGS) --exe -LDFLAGS '../obj_dir_secret/libverilated_secret.a' top.v obj_dir_secret/verilated_secret.sv sim_main.cpp

 	@echo
 	@echo "-- COMPILE entire design --------------------------------------"
@@ -13,14 +13,14 @@
 #include "Vtop.h"

 #if VM_TRACE
-# include <verilated_vcd_c.h>
+#include <verilated_vcd_c.h>
 #endif

 vluint64_t main_time = 0;
 double sc_time_stamp() { return main_time; }

 int main(int argc, char** argv, char** env) {
-    if (0 && argc && argv && env) {}
+    if (false && argc && argv && env) {}

    Verilated::debug(0);
    Verilated::randReset(2);
@@ -31,7 +31,7 @@ int main(int argc, char** argv, char** env) {

 #if VM_TRACE
    // When tracing, the contents of the secret module will not be seen
-    VerilatedVcdC* tfp = NULL;
+    VerilatedVcdC* tfp = nullptr;
    const char* flag = Verilated::commandArgsPlusMatch("trace");
    if (flag && 0 == strcmp(flag, "+trace")) {
        Verilated::traceEverOn(true);
@@ -62,14 +62,15 @@ int main(int argc, char** argv, char** env) {
 #if VM_TRACE
    if (tfp) {
        tfp->close();
-        tfp = NULL;
+        tfp = nullptr;
    }
 #endif

    // Destroy model
    delete top;
-    top = NULL;
+    top = nullptr;

-    // Fin
-    exit(0);
+    // Return good completion status
+    // Don't use exit() or destructor won't get called
+    return 0;
 }
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -5,11 +5,9 @@
 #
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 #######################################################################

@@ -5,6 +5,9 @@
 // SPDX-License-Identifier: CC0-1.0
 //======================================================================

+// For std::unique_ptr
+#include <memory>
+
 // Include common routines
 #include <verilated.h>

@@ -22,7 +25,7 @@ int main(int argc, char** argv, char** env) {
    // This is a more complicated example, please also see the simpler examples/make_hello_c.

    // Prevent unused variable warnings
-    if (0 && argc && argv && env) {}
+    if (false && argc && argv && env) {}

    // Set debug level, 0 is off, 9 is highest presently used
    // May be overridden by commandArgs
@@ -43,7 +46,8 @@ int main(int argc, char** argv, char** env) {
    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
+    // Using unique_ptr is similar to "Vtop* top = new Vtop" then deleting at end
+    const std::unique_ptr<Vtop> top{new Vtop};

    // Set some inputs
    top->reset_l = !0;
@@ -97,10 +101,7 @@ int main(int argc, char** argv, char** env) {
    VerilatedCov::write("logs/coverage.dat");
 #endif

-    // Destroy model
-    delete top;
-    top = NULL;
-
-    // Fin
-    exit(0);
+    // Return good completion status
+    // Don't use exit() or destructor won't get called
+    return 0;
 }
@@ -5,11 +5,9 @@
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################
 # Check for sanity to avoid later confusion
@@ -5,11 +5,9 @@
 #
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 #######################################################################

@@ -39,8 +37,8 @@ endif
 # If you build your own rules from scratch, note you need to include
 # SystemC as follows (Vtop.mk file includes verilated.mk with these
 # already).
-# CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
-# LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
+# CPPFLAGS += $(SYSTEMC_CXX_FLAGS) $(addprefix -I, $(SYSTEMC_INCLUDE))
+# LDFLAGS  += $(SYSTEMC_CXX_FLAGS) $(addprefix -L, $(SYSTEMC_LIBDIR))

 # See the benchmarking section of bin/verilator.
 # Support class optimizations.  This includes the tracing and symbol table.
@@ -6,6 +6,9 @@
 // SPDX-License-Identifier: CC0-1.0
 //======================================================================

+// For std::unique_ptr
+#include <memory>
+
 // SystemC global header
 #include <systemc.h>

@@ -24,7 +27,7 @@ int sc_main(int argc, char* argv[]) {
    // This is a more complicated example, please also see the simpler examples/make_hello_c.

    // Prevent unused variable warnings
-    if (0 && argc && argv) {}
+    if (false && argc && argv) {}

    // Set debug level, 0 is off, 9 is highest presently used
    // May be overridden by commandArgs
@@ -44,33 +47,23 @@ int sc_main(int argc, char* argv[]) {
    // General logfile
    ios::sync_with_stdio();

-    // Defaults time
-#if (SYSTEMC_VERSION > 20011000)
-#else
-    sc_time dut(1.0, sc_ns);
-    sc_set_default_time_unit(dut);
-#endif
-
    // Define clocks
-#if (SYSTEMC_VERSION >= 20070314)
-    sc_clock clk("clk", 10, SC_NS, 0.5, 3, SC_NS, true);
-    sc_clock fastclk("fastclk", 2, SC_NS, 0.5, 2, SC_NS, true);
-#else
-    sc_clock clk("clk", 10, 0.5, 3, true);
-    sc_clock fastclk("fastclk", 2, 0.5, 2, true);
-#endif
+    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};

    // Define interconnect
    sc_signal<bool> reset_l;
    sc_signal<vluint32_t> in_small;
    sc_signal<vluint64_t> in_quad;
-    sc_signal<sc_bv<70> > in_wide;
+    sc_signal<sc_bv<70>> in_wide;
    sc_signal<vluint32_t> out_small;
    sc_signal<vluint64_t> out_quad;
-    sc_signal<sc_bv<70> > out_wide;
+    sc_signal<sc_bv<70>> out_wide;

    // Construct the Verilated model, from inside Vtop.h
-    Vtop* top = new Vtop("top");
+    // Using unique_ptr is similar to "Vtop* top = new Vtop" then deleting at end
+    const std::unique_ptr<Vtop> top{new Vtop{"top"}};
+
    // Attach signals to the model
    top->clk(clk);
    top->fastclk(fastclk);
@@ -89,16 +82,12 @@ 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);
-#else
-    sc_start(1);
-#endif

 #if VM_TRACE
    // If verilator was invoked with --trace argument,
    // and if at run time passed the +trace argument, turn on tracing
-    VerilatedVcdSc* tfp = NULL;
+    VerilatedVcdSc* tfp = nullptr;
    const char* flag = Verilated::commandArgsPlusMatch("trace");
    if (flag && 0 == strcmp(flag, "+trace")) {
        cout << "Enabling waves into logs/vlt_dump.vcd...\n";
@@ -125,11 +114,7 @@ int sc_main(int argc, char* argv[]) {
        }

        // Simulate 1ns
-#if (SYSTEMC_VERSION >= 20070314)
        sc_start(1, SC_NS);
-#else
-        sc_start(1);
-#endif
    }

    // Final model cleanup
@@ -139,7 +124,7 @@ int sc_main(int argc, char* argv[]) {
 #if VM_TRACE
    if (tfp) {
        tfp->close();
-        tfp = NULL;
+        tfp = nullptr;
    }
 #endif

@@ -149,10 +134,6 @@ int sc_main(int argc, char* argv[]) {
    VerilatedCov::write("logs/coverage.dat");
 #endif

-    // Destroy model
-    delete top;
-    top = NULL;
-
-    // Fin
+    // Return good completion status
    return 0;
 }
@@ -2,11 +2,9 @@
 #
 # 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
-# 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 file ONLY is placed under the Creative Commons Public Domain, for
+# any use, without warranty, 2020 by Wilson Snyder.
+# SPDX-License-Identifier: CC0-1.0
 #
 ######################################################################

@@ -24,9 +22,9 @@ VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif

 DOT = dot
-PYTHON = python3
+PYTHON3 = python3

-PYTHON_VERSION := $(shell ${PYTHON} --version 2>&1)
+PYTHON_VERSION := $(shell ${PYTHON3} --version 2>&1)
 PYTHON_VERSION_FULL := $(wordlist 2,4,$(subst ., ,${PYTHON_VERSION}))
 PYTHON_VERSION_MAJOR := $(word 1,${PYTHON_VERSION_FULL})
 PYTHON_VERSION_MINOR := $(word 2,${PYTHON_VERSION_FULL})
@@ -47,13 +45,13 @@ test: \

 test-vl_file_copy:
 	@echo "-- vl_file_copy example"
-	$(PYTHON) vl_file_copy -odir copied top.v
+	$(PYTHON3) vl_file_copy -odir copied top.v
 	@cmp copied/top.v top.v
 	@cmp copied/sub.v sub.v

 test-vl_hier_graph:
 	@echo "-- vl_hier_graph example"
-	$(PYTHON) vl_hier_graph -o graph.dot top.v
+	$(PYTHON3) vl_hier_graph -o graph.dot top.v
 	@echo "Manually run: " $(DOT) -Tpdf -o graph.pdf graph.dot

 ######################################################################
@@ -10,24 +10,29 @@ import sys
 import tempfile
 import xml.etree.ElementTree as ET
 from shutil import copy2
-from pprint import pprint,pformat
+from pprint import pprint, pformat

 #######################################################################

+
 class VlFileCopy:
-    def __init__(self,
-                 verilator_args,  # presently all verilator options are passed-thru
-                 # ideally this script would check against options mentioned in help
-                 debug=0,
-                 output_dir='copied'):  # directory name we output file uses
+    def __init__(
+        self,
+        verilator_args,  # presently all verilator options are passed-thru
+        # ideally this script would check against options mentioned in help
+        debug=0,
+        output_dir='copied'):  # directory name we output file uses
        self.debug = debug

        xml_temp = tempfile.NamedTemporaryFile()

-        args = ['--xml-output', xml_temp.name,
-                '--bbox-sys',  # Parse some stuff can't translate
-                '--bbox-unsup',
-                '--prefix vlxml']  # So we know name of .xml output
+        args = [
+            '--xml-output',
+            xml_temp.name,
+            '--bbox-sys',  # Parse some stuff can't translate
+            '--bbox-unsup',
+            '--prefix vlxml'
+        ]  # So we know name of .xml output
        args += verilator_args
        self.run_verilator(args)
        self.tree = ET.parse(xml_temp.name)
@@ -55,16 +60,18 @@ class VlFileCopy:
            print("\t%s " % command)
        status = subprocess.call(command, shell=True)
        if status != 0:
-            raise Exception("Command failed running Verilator with '"+command+"', stopped")
+            raise Exception("Command failed running Verilator with '" +
+                            command + "', stopped")
+

 #######################################################################

-if __name__=='__main__':
+if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        allow_abbrev=False,
        formatter_class=argparse.RawTextHelpFormatter,
        description=
-"""Example of using Verilator XML output to copy a list of files to an
+        """Example of using Verilator XML output to copy a list of files to an
 output directory (-odir, defaults to 'copied'), e.g. to easily create a
 tarball of the design to pass to others.

@@ -72,8 +79,7 @@ Example usage:
     vl_file_copy -f input.vc top.v -odir mycopy
     # This will make at least mycopy/top.v
 """,
-        epilog=
-"""All other arguments are pass-thru to Verilator: e.g.:
+        epilog="""All other arguments are pass-thru to Verilator: e.g.:

  +define+<var>=<value>      Set preprocessor define
  -F <file>                  Parse options from a file, relatively
@@ -87,26 +93,30 @@ Example usage:
 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,
+""")
+    parser.add_argument('-debug',
+                        '--debug',
+                        action='store_const',
+                        const=9,
                        help='enable debug')
-    parser.add_argument('-odir', '--odir',
-                        action='store', metavar='directory', required=True,
+    parser.add_argument('-odir',
+                        '--odir',
+                        action='store',
+                        metavar='directory',
+                        required=True,
                        help='target output directory')
    (args, rem) = parser.parse_known_args()

-    print("NOTE: vl_file_copy is only an example starting point for writing your own tool.")
+    print(
+        "NOTE: vl_file_copy is only an example starting point for writing your own tool."
+    )
    # That is:
    # 1. We will accept basic patches
    # 2. We are not expecting to make this globally useful. (e.g. we don't cleanup obj_dir)
    # 3. "make install" will not install this.
    # 4. This has not had production-worthy validation.

-    fc = VlFileCopy(output_dir = args.odir,
-                    debug = args.debug,
-                    verilator_args = rem)
+    fc = VlFileCopy(output_dir=args.odir, debug=args.debug, verilator_args=rem)

 ######################################################################
 ### Local Variables:
@@ -10,26 +10,31 @@ import sys
 import tempfile
 import xml.etree.ElementTree as ET
 from shutil import copy2
-from pprint import pprint,pformat
+from pprint import pprint, pformat

 #######################################################################

+
 class VlHierGraph:
-    def __init__(self,
-                 verilator_args,  # presently all verilator options are passed-thru
-                 # ideally this script would check against options mentioned in help
-                 debug=0,
-                 output_filename='graph.dot'):  # output filename
+    def __init__(
+        self,
+        verilator_args,  # presently all verilator options are passed-thru
+        # ideally this script would check against options mentioned in help
+        debug=0,
+        output_filename='graph.dot'):  # output filename
        self.debug = debug
        self.next_vertex_number = 0
        self.name_to_number = {}

        xml_temp = tempfile.NamedTemporaryFile()

-        args = ['--xml-output', xml_temp.name,
-                '--bbox-sys',  # Parse some stuff can't translate
-                '--bbox-unsup',
-                '--prefix vlxml']  # So we know name of .xml output
+        args = [
+            '--xml-output',
+            xml_temp.name,
+            '--bbox-sys',  # Parse some stuff can't translate
+            '--bbox-unsup',
+            '--prefix vlxml'
+        ]  # So we know name of .xml output
        args += verilator_args
        self.run_verilator(args)
        self.tree = ET.parse(xml_temp.name)
@@ -39,7 +44,9 @@ class VlHierGraph:
            fh.write("digraph {\n")
            fh.write("  dpi=300;\n")
            fh.write("  order=LR;\n")
-            fh.write("  node [fontsize=8 shape=\"box\" margin=0.01 width=0 height=0]")
+            fh.write(
+                "  node [fontsize=8 shape=\"box\" margin=0.01 width=0 height=0]"
+            )
            fh.write("  edge [fontsize=6]")
            # Find cells
            root = self.tree.getroot()
@@ -48,8 +55,7 @@ class VlHierGraph:
                # origNames are before parameterization, name if after
                mod_name = module.get('name')
                mod_number = self.name_to_vertex_number(mod_name)
-                fh.write("  n%d [label=\"%s\""
-                         % (mod_number, mod_name))
+                fh.write("  n%d [label=\"%s\"" % (mod_number, mod_name))
                if module.get('topModule'):
                    fh.write(" color=\"red\" rank=1")
                fh.write("];\n")
@@ -58,8 +64,8 @@ class VlHierGraph:
                    inst_name = instance.get('name')
                    def_name = instance.get('defName')
                    def_number = self.name_to_vertex_number(def_name)
-                    fh.write("  n%d->n%d [label=\"%s\"];\n"
-                             % (mod_number, def_number, inst_name));
+                    fh.write("  n%d->n%d [label=\"%s\"];\n" %
+                             (mod_number, def_number, inst_name))

            fh.write("}\n")

@@ -80,24 +86,25 @@ class VlHierGraph:
            print("\t%s " % command)
        status = subprocess.call(command, shell=True)
        if status != 0:
-            raise Exception("Command failed running Verilator with '"+command+"', stopped")
+            raise Exception("Command failed running Verilator with '" +
+                            command + "', stopped")
+

 #######################################################################

-if __name__=='__main__':
+if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        allow_abbrev=False,
        formatter_class=argparse.RawTextHelpFormatter,
        description=
-"""Example of using Verilator XML output to create a .dot file showing the
+        """Example of using Verilator XML output to create a .dot file showing the
 design module hierarchy.

 Example usage:
     vl_hier_graph -f input.vc top.v -o graph.dot
     dot -Tpdf -o graph.pdf graph.dot
 """,
-        epilog=
-"""All other arguments are pass-thru to Verilator: e.g.:
+        epilog="""All other arguments are pass-thru to Verilator: e.g.:

  +define+<var>=<value>      Set preprocessor define
  -F <file>                  Parse options from a file, relatively
@@ -111,26 +118,32 @@ Example usage:
 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,
+""")
+    parser.add_argument('-debug',
+                        '--debug',
+                        action='store_const',
+                        const=9,
                        help='enable debug')
-    parser.add_argument('-o', '--o',
-                        action='store', metavar='filename', required=True,
+    parser.add_argument('-o',
+                        '--o',
+                        action='store',
+                        metavar='filename',
+                        required=True,
                        help='output filename')
    (args, rem) = parser.parse_known_args()

-    print("NOTE: vl_hier_graph is only an example starting point for writing your own tool.")
+    print(
+        "NOTE: vl_hier_graph is only an example starting point for writing your own tool."
+    )
    # That is:
    # 1. We will accept basic patches
    # 2. We are not expecting to make this globally useful. (e.g. we don't cleanup obj_dir)
    # 3. "make install" will not install this.
    # 4. This has not had production-worthy validation.

-    fc = VlHierGraph(output_filename = args.o,
-                     debug = args.debug,
-                     verilator_args = rem)
+    fc = VlHierGraph(output_filename=args.o,
+                     debug=args.debug,
+                     verilator_args=rem)

 ######################################################################
 ### Local Variables:
@@ -3,7 +3,7 @@
 /* config.h.in.  Generated from configure.ac by autoheader.  */

 /* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix). */
-#if !defined(__MINGW32__)
+#if !defined(__MINGW32__) && !defined(__FreeBSD__)
 # define HAVE_ALLOCA_H 1
 #endif

@@ -794,6 +794,7 @@ pthread_t thread;
 pthread_attr_t thread_attr;
 struct fstWriterContext *xc_parent;
 #endif
+unsigned in_pthread : 1;

 size_t fst_orig_break_size;
 size_t fst_orig_break_add_size;
@@ -1805,19 +1806,23 @@ xc->already_in_flush = 0;
 static void *fstWriterFlushContextPrivate1(void *ctx)
 {
 struct fstWriterContext *xc = (struct fstWriterContext *)ctx;
+struct fstWriterContext *xc_parent;

+pthread_mutex_lock(&(xc->xc_parent->mutex));
 fstWriterFlushContextPrivate2(xc);

-pthread_mutex_unlock(&(xc->xc_parent->mutex));
-
 #ifdef FST_REMOVE_DUPLICATE_VC
 free(xc->curval_mem);
 #endif
 free(xc->valpos_mem);
 free(xc->vchg_mem);
 tmpfile_close(&xc->tchn_handle, &xc->tchn_handle_nam);
+xc_parent = xc->xc_parent;
 free(xc);

+xc_parent->in_pthread = 0;
+pthread_mutex_unlock(&(xc_parent->mutex));
+
 return(NULL);
 }

@@ -1865,7 +1870,15 @@ if(xc->parallel_enabled)
        xc->section_header_only = 0;
        xc->secnum++;

+	while (xc->in_pthread) 
+		{ 
+		pthread_mutex_lock(&xc->mutex); 
+		pthread_mutex_unlock(&xc->mutex); 
+		};
+
        pthread_mutex_lock(&xc->mutex);
+	xc->in_pthread = 1;
+        pthread_mutex_unlock(&xc->mutex);

        pthread_create(&xc->thread, &xc->thread_attr, fstWriterFlushContextPrivate1, xc2);
        }
@@ -1947,6 +1960,12 @@ if(xc && !xc->already_in_close && !xc->already_in_flush)
 #ifdef FST_WRITER_PARALLEL
                        pthread_mutex_lock(&xc->mutex);
                        pthread_mutex_unlock(&xc->mutex);
+
+			while (xc->in_pthread) 
+				{ 
+				pthread_mutex_lock(&xc->mutex); 
+				pthread_mutex_unlock(&xc->mutex); 
+				};
 #endif
                        }
                }
@@ -2,7 +2,7 @@
 ######################################################################
 # DESCRIPTION: Makefile commands for all verilated target files
 #
-# Copyright 2003-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2003-2021 by Wilson Snyder. This program is free software; you
 # can redistribute it and/or modify it under the terms of either the GNU
 # Lesser General Public License Version 3 or the Perl Artistic License
 # Version 2.0.
@@ -54,6 +54,7 @@ VK_CPPFLAGS_ALWAYS += \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
 		-DVM_SC=$(VM_SC) \
 		-DVM_TRACE=$(VM_TRACE) \
+		-DVM_TRACE_FST=$(VM_TRACE_FST) \
 		$(CFG_CXXFLAGS_NO_UNUSED) \

 ifeq ($(CFG_WITH_CCWARN),yes)	# Local... Else don't burden users
@@ -84,27 +85,29 @@ CPPFLAGS += $(VM_USER_CFLAGS)
 LDFLAGS  += $(VM_USER_LDFLAGS)
 LDLIBS   += $(VM_USER_LDLIBS)

-# See the benchmarking section of bin/verilator.
-# Support class optimizations.  This includes the tracing and symbol table.
-# 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 = -Os -fstrict-aliasing
-#OPT_FAST = -O
-#OPT_FAST =
+######################################################################
+# Optimization control.

-#######################################################################
-##### Aggregates
+# See also the BENCHMARKING & OPTIMIZATION section of the manual.

-VM_CLASSES += $(VM_CLASSES_FAST) $(VM_CLASSES_SLOW)
-VM_SUPPORT += $(VM_SUPPORT_FAST) $(VM_SUPPORT_SLOW)
+# Optimization flags for non performance-critical/rarely executed code.
+# No optimization by default, which improves compilation speed.
+OPT_SLOW =
+# Optimization for performance critical/hot code. Most time is spent in these
+# routines. Optimizing by default for improved execution speed.
+OPT_FAST = -Os
+# Optimization applied to the common run-time library used by verilated models.
+# For compatibility this is called OPT_GLOBAL even though it only applies to
+# files in the run-time library. Normally there should be no need for the user
+# to change this as the library is small, but can have significant speed impact.
+OPT_GLOBAL = -Os

 #######################################################################
 ##### SystemC builds

 ifeq ($(VM_SC),1)
-  CPPFLAGS += $(SYSTEMC_CXX_FLAGS) -I$(SYSTEMC_INCLUDE)
-  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) -L$(SYSTEMC_LIBDIR)
+  CPPFLAGS += $(SYSTEMC_CXX_FLAGS) $(addprefix -I, $(SYSTEMC_INCLUDE))
+  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) $(addprefix -L, $(SYSTEMC_LIBDIR))
  SC_LIBS   = -lsystemc
 ifneq ($(wildcard $(SYSTEMC_LIBDIR)/*numeric_bit*),)
  # Systemc 1.2.1beta
@@ -163,58 +166,79 @@ ifneq ($(VK_LIBS_THREADED),0)
 endif

 #######################################################################
-##### Stub
+### Aggregates

-preproc:
+VM_FAST += $(VM_CLASSES_FAST) $(VM_SUPPORT_FAST)
+VM_SLOW += $(VM_CLASSES_SLOW) $(VM_SUPPORT_SLOW)

 #######################################################################
-# Overall Objects Linking
+### Overall Objects Linking

-VK_CLASSES_FAST_CPP = $(addsuffix .cpp, $(VM_CLASSES_FAST))
-VK_CLASSES_SLOW_CPP = $(addsuffix .cpp, $(VM_CLASSES_SLOW))
-
-VK_SUPPORT_FAST_CPP = $(addsuffix .cpp, $(VM_SUPPORT_FAST))
-VK_SUPPORT_SLOW_CPP = $(addsuffix .cpp, $(VM_SUPPORT_SLOW))
+VK_FAST_OBJS = $(addsuffix .o, $(VM_FAST))
+VK_SLOW_OBJS = $(addsuffix .o, $(VM_SLOW))

 VK_USER_OBJS   = $(addsuffix .o, $(VM_USER_CLASSES))

+# Note VM_GLOBAL_FAST and VM_GLOBAL_SLOW holds the files required from the
+# run-time library. In practice everything is actually in VM_GLOBAL_FAST,
+# but keeping the distinction for compatibility for now.
 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)__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)__ALLslow.cpp: $(VK_CLASSES_SLOW_CPP) $(VK_SUPPORT_SLOW_CPP)
+  # Fast build for small designs: All .cpp files in one fell swoop. This
+  # saves total compute, but can be slower if only a little changes. It is
+  # also a lot slower for medium to large designs when the speed of the C
+  # compiler dominates, which in this mode is not parallelizable.
+
+  VK_OBJS += $(VM_PREFIX)__ALL.o
+  $(VM_PREFIX)__ALL.cpp: $(addsuffix .cpp, $(VM_FAST) $(VM_SLOW))
 	$(VERILATOR_INCLUDER) -DVL_INCLUDE_OPT=include $^ > $@
+  all_cpp: $(VM_PREFIX)__ALL.cpp
 else
-  #Slow way of building... Each .cpp file by itself
-  VK_OBJS += $(addsuffix .o, $(VM_CLASSES) $(VM_SUPPORT))
+  # Parallel build: Each .cpp file by itself. This can be somewhat slower for
+  # very small designs and examples, but is a lot faster for large designs.
+
+  VK_OBJS += $(VK_FAST_OBJS) $(VK_SLOW_OBJS)
 endif

-$(VM_PREFIX)__ALL.a: $(VK_OBJS)
-	$(AR) -cr $@ $^
-	$(RANLIB) $@
+# When archiving just objects (.o), single $(AR) run is enough.
+# When merging objects (.o) and archives (.a), the following steps are taken.
+#   1. Extract object files from .a
+#   2. Create a new archive from extracted .o and given .o
+%.a:
+	@echo "Archive $(AR) -cr $@ $^"
+	@if test $(words $(filter %.a,$^)) -eq 0; then \
+		$(AR) -cr $@ $^; \
+		$(RANLIB) $@; \
+	else \
+		$(RM) -rf $*__tmpdir; \
+		for archive in $(filter %.a,$^); do \
+			mkdir -p $*__tmpdir/$$(basename $${archive}); \
+			cd $*__tmpdir/$$(basename $${archive}); \
+			$(AR) -x ../../$${archive}; \
+			cd ../..; \
+		done; \
+		$(AR) -cr $@ $(filter %.o,$^) $*__tmpdir/*/*.o; \
+		$(RM) -rf $*__tmpdir; \
+	fi
+
+$(VM_PREFIX)__ALL.a: $(VK_OBJS) $(VM_HIER_LIBS)
+

 ######################################################################
 ### Compile rules

 ifneq ($(VM_DEFAULT_RULES),0)
-$(VM_PREFIX)__ALLfast.o: $(VM_PREFIX)__ALLfast.cpp
-	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<
-
-$(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
+# Anything not in $(VK_SLOW_OBJS) or $(VK_GLOBAL_OBJS), including verilated.o
+# and user files passed on the Verilator command line use this rule.
 %.o: %.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_FAST) -c -o $@ $<

-%__Slow.o: %__Slow.cpp
+$(VK_SLOW_OBJS): %.o: %.cpp
 	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_SLOW) -c -o $@ $<

+$(VK_GLOBAL_OBJS): %.o: %.cpp
+	$(OBJCACHE) $(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPT_GLOBAL) -c -o $@ $<
 endif

 #Default rule embedded in make:
@@ -4,7 +4,7 @@
 //
 //*************************************************************************
 //
-// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2021 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.
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2021 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.
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -29,7 +29,7 @@
 // VerilatedCovImpBase
 /// Implementation base class for constants

-struct VerilatedCovImpBase {
+struct VerilatedCovImpBase VL_NOT_FINAL {
    // TYPES
    enum { MAX_KEYS = 33 };  /// Maximum user arguments + filename+lineno
    enum { KEY_UNDEF = 0 };  /// Magic key # for unspecified values
@@ -39,7 +39,7 @@ struct VerilatedCovImpBase {
 // VerilatedCovImpItem
 /// Implementation class for a VerilatedCov item

-class VerilatedCovImpItem : VerilatedCovImpBase {
+class VerilatedCovImpItem VL_NOT_FINAL : VerilatedCovImpBase {
 public:  // But only local to this file
    // MEMBERS
    int m_keys[MAX_KEYS];  ///< Key
@@ -52,7 +52,7 @@ public:  // But only local to this file
            m_vals[i] = 0;
        }
    }
-    virtual ~VerilatedCovImpItem() {}
+    virtual ~VerilatedCovImpItem() = default;
    virtual vluint64_t count() const = 0;
    virtual void zero() const = 0;
 };
@@ -63,22 +63,22 @@ public:  // But only local to this file
 /// This isn't in the header file for auto-magic conversion because it
 /// inlines to too much code and makes compilation too slow.

-template <class T> class VerilatedCoverItemSpec : public VerilatedCovImpItem {
+template <class T> class VerilatedCoverItemSpec final : public VerilatedCovImpItem {
 private:
    // MEMBERS
    T* m_countp;  ///< Count value
 public:
    // METHODS
    // cppcheck-suppress truncLongCastReturn
-    virtual vluint64_t count() const VL_OVERRIDE { return *m_countp; }
-    virtual void zero() const VL_OVERRIDE { *m_countp = 0; }
+    virtual vluint64_t count() const override { return *m_countp; }
+    virtual void zero() const override { *m_countp = 0; }
    // CONSTRUCTORS
    // cppcheck-suppress noExplicitConstructor
    explicit VerilatedCoverItemSpec(T* countp)
-        : m_countp(countp) {
+        : m_countp{countp} {
        *m_countp = 0;
    }
-    virtual ~VerilatedCoverItemSpec() VL_OVERRIDE {}
+    virtual ~VerilatedCoverItemSpec() override = default;
 };

 //=============================================================================
@@ -87,30 +87,26 @@ public:
 /// All value and keys are indexed into a unique number.  Thus we can greatly reduce
 /// the storage requirements for otherwise identical keys.

-class VerilatedCovImp : VerilatedCovImpBase {
+class VerilatedCovImp final : VerilatedCovImpBase {
 private:
    // TYPES
-    typedef std::map<std::string, int> ValueIndexMap;
+    typedef std::map<const std::string, int> ValueIndexMap;
    typedef std::map<int, std::string> IndexValueMap;
    typedef std::deque<VerilatedCovImpItem*> ItemList;

-private:
    // MEMBERS
    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
+    int m_nextIndex VL_GUARDED_BY(m_mutex) = (KEY_UNDEF + 1);  ///< Next insert value

-    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
+    VerilatedCovImpItem* m_insertp VL_GUARDED_BY(m_mutex) = nullptr;  ///< Item about to insert
+    const char* m_insertFilenamep VL_GUARDED_BY(m_mutex) = nullptr;  ///< Filename about to insert
+    int m_insertLineno VL_GUARDED_BY(m_mutex) = 0;  ///< Line number about to insert

    // CONSTRUCTORS
-    VerilatedCovImp() {
-        m_insertp = NULL;
-        m_insertFilenamep = NULL;
-        m_insertLineno = 0;
-    }
+    VerilatedCovImp() = default;
    VL_UNCOPYABLE(VerilatedCovImp);

 public:
@@ -123,14 +119,13 @@ public:
 private:
    // PRIVATE METHODS
    int valueIndex(const std::string& value) VL_REQUIRES(m_mutex) {
-        static int nextIndex = KEY_UNDEF + 1;
-        ValueIndexMap::iterator iter = m_valueIndexes.find(value);
+        const auto iter = m_valueIndexes.find(value);
        if (iter != m_valueIndexes.end()) return iter->second;
-        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;
+        m_nextIndex++;
+        assert(m_nextIndex > 0);  // Didn't rollover
+        m_valueIndexes.emplace(value, m_nextIndex);
+        m_indexValues.emplace(m_nextIndex, value);
+        return m_nextIndex;
    }
    static std::string dequote(const std::string& text) VL_PURE {
        // Quote any special characters
@@ -221,45 +216,41 @@ private:
    }
    static void selftest() VL_MT_SAFE {
        // Little selftest
-#define VL_CST_CHECK(got, exp) \
+#define SELF_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
+        SELF_CHECK(combineHier("a.b.c", "a.b.c"), "a.b.c");
+        SELF_CHECK(combineHier("a.b.c", "a.b"), "a.b*");
+        SELF_CHECK(combineHier("a.x.c", "a.y.c"), "a.*.c");
+        SELF_CHECK(combineHier("a.z.z.z.c", "a.b.c"), "a.*.c");
+        SELF_CHECK(combineHier("z", "a"), "*");
+        SELF_CHECK(combineHier("q.a", "q.b"), "q.*");
+        SELF_CHECK(combineHier("q.za", "q.zb"), "q.z*");
+        SELF_CHECK(combineHier("1.2.3.a", "9.8.7.a"), "*.a");
+#undef SELF_CHECK
    }
    void clearGuts() VL_REQUIRES(m_mutex) {
-        for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
-            VerilatedCovImpItem* itemp = *(it);
-            VL_DO_DANGLING(delete itemp, itemp);
-        }
+        for (const auto& itemp : m_items) VL_DO_DANGLING(delete itemp, itemp);
        m_items.clear();
        m_indexValues.clear();
        m_valueIndexes.clear();
+        m_nextIndex = KEY_UNDEF + 1;
    }

 public:
    // PUBLIC METHODS
    void clear() VL_EXCLUDES(m_mutex) {
        Verilated::quiesce();
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        clearGuts();
    }
    void clearNonMatch(const char* matchp) VL_EXCLUDES(m_mutex) {
        Verilated::quiesce();
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        if (matchp && matchp[0]) {
            ItemList newlist;
-            for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
-                VerilatedCovImpItem* itemp = *(it);
+            for (const auto& itemp : m_items) {
                if (!itemMatchesString(itemp, matchp)) {
                    VL_DO_DANGLING(delete itemp, itemp);
                } else {
@@ -271,25 +262,23 @@ 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) {
-            (*it)->zero();
-        }
+        const VerilatedLockGuard lock(m_mutex);
+        for (const auto& itemp : m_items) itemp->zero();
    }

    // We assume there's always call to i/f/p in that order
    void inserti(VerilatedCovImpItem* itemp) VL_EXCLUDES(m_mutex) {
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        assert(!m_insertp);
        m_insertp = itemp;
    }
    void insertf(const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        m_insertFilenamep = filenamep;
        m_insertLineno = lineno;
    }
    void insertp(const char* ckeyps[MAX_KEYS], const char* valps[MAX_KEYS]) VL_EXCLUDES(m_mutex) {
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        assert(m_insertp);
        // First two key/vals are filename
        ckeyps[0] = "filename";
@@ -309,7 +298,7 @@ public:
        // 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]; }
+            if (ckeyps[i] && ckeyps[i][0]) keys[i] = ckeyps[i];
        }
        // Ignore empty keys
        for (int i = 0; i < MAX_KEYS; ++i) {
@@ -332,22 +321,22 @@ public:
                m_insertp->m_keys[addKeynum] = valueIndex(key);
                m_insertp->m_vals[addKeynum] = valueIndex(val);
                addKeynum++;
-                if (!legalKey(key)) {
+                if (VL_UNCOVERABLE(!legalKey(key))) {
                    std::string msg
                        = ("%Error: Coverage keys of one character, or letter+digit are illegal: "
-                           + key);
+                           + key);  // LCOV_EXCL_LINE
                    VL_FATAL_MT("", 0, "", msg.c_str());
                }
            }
        }
        m_items.push_back(m_insertp);
        // Prepare for next
-        m_insertp = NULL;
+        m_insertp = nullptr;
    }

    void write(const char* filename) VL_EXCLUDES(m_mutex) {
        Verilated::quiesce();
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
 #ifndef VM_COVERAGE
        VL_FATAL_MT("", 0, "", "%Error: Called VerilatedCov::write when VM_COVERAGE disabled\n");
 #endif
@@ -362,10 +351,9 @@ public:
        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<const std::string, std::pair<std::string, vluint64_t>> EventMap;
        EventMap eventCounts;
-        for (ItemList::iterator it = m_items.begin(); it != m_items.end(); ++it) {
-            VerilatedCovImpItem* itemp = *(it);
+        for (const auto& itemp : m_items) {
            std::string name;
            std::string hier;
            bool per_instance = false;
@@ -396,23 +384,23 @@ public:
            // inefficient)

            // Find or insert the named event
-            EventMap::iterator cit = eventCounts.find(name);
+            const auto cit = eventCounts.find(name);
            if (cit != eventCounts.end()) {
                const std::string& oldhier = cit->second.first;
                cit->second.second += itemp->count();
                cit->second.first = combineHier(oldhier, hier);
            } else {
-                eventCounts.insert(std::make_pair(name, make_pair(hier, itemp->count())));
+                eventCounts.emplace(name, make_pair(hier, itemp->count()));
            }
        }

        // Output body
-        for (EventMap::const_iterator it = eventCounts.begin(); it != eventCounts.end(); ++it) {
+        for (const auto& i : eventCounts) {
            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;
+            os << i.first;
+            if (!i.second.first.empty()) os << keyValueFormatter(VL_CIK_HIER, i.second.first);
+            os << "' " << i.second.second;
+            os << '\n';
        }
    }
 };
@@ -447,15 +435,15 @@ void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8)
                            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};
+        = {nullptr, nullptr, nullptr,  // 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};
+        = {nullptr, nullptr, nullptr,  // 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);
 }

@@ -475,11 +463,11 @@ void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8)
 }
 // 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 {
+                            const std::string& val4, A(5), A(6), A(7)) 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),
+             C(6), C(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
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 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.
@@ -88,7 +88,7 @@ template <class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
 /// Global class with methods affecting all coverage data.
 /// All public methods in this class are thread safe.

-class VerilatedCov {
+class VerilatedCov final {
    VL_UNCOPYABLE(VerilatedCov);

 public:
@@ -112,7 +112,7 @@ public:
    // 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
+#define D(n) const char *key##n = nullptr, const char *valp##n = nullptr  // 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));
@@ -121,7 +121,7 @@ public:
                         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));
+                         A(5), A(6), A(7));

 #undef K
 #undef A
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -29,67 +29,27 @@
 #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, ")
-VLCOVGEN_ITEM("name=>'col3_name',   short=>'C3', group=>1, default=>undef, ")
-VLCOVGEN_ITEM("name=>'column',      short=>'n',  group=>1, default=>0,     descr=>'Column number for the item.  Used to disambiguate multiple coverage points on the same line number'")
-VLCOVGEN_ITEM("name=>'filename',    short=>'f',  group=>1, default=>undef, descr=>'Filename of the item'")
-VLCOVGEN_ITEM("name=>'groupdesc',   short=>'d',  group=>1, default=>'',    descr=>'Description of the covergroup this item belongs to'")
-VLCOVGEN_ITEM("name=>'groupname',   short=>'g',  group=>1, default=>'',    descr=>'Group name of the covergroup this item belongs to'")
-VLCOVGEN_ITEM("name=>'groupcmt',    short=>'O',  group=>1, default=>'',    ")
-VLCOVGEN_ITEM("name=>'per_instance',short=>'P',  group=>1, default=>0,     descr=>'True if every hierarchy is independently counted; otherwise all hierarchies will be combined into a single count'")
-VLCOVGEN_ITEM("name=>'row0_name',   short=>'R0', group=>1, default=>undef, descr=>'The row title for the header line of this row'")
-VLCOVGEN_ITEM("name=>'row1_name',   short=>'R1', group=>1, default=>undef, ")
-VLCOVGEN_ITEM("name=>'row2_name',   short=>'R2', group=>1, default=>undef, ")
-VLCOVGEN_ITEM("name=>'row3_name',   short=>'R3', group=>1, default=>undef, ")
-VLCOVGEN_ITEM("name=>'table',       short=>'T',  group=>1, default=>undef, descr=>'The name of the table for automatically generated tables'")
-VLCOVGEN_ITEM("name=>'thresh',      short=>'s',  group=>1, default=>undef, ")
-VLCOVGEN_ITEM("name=>'type',        short=>'t',  group=>1, default=>'',    descr=>'Type of coverage (block, line, fsm, etc)'")
+VLCOVGEN_ITEM("'name':'column',      'short':'n',  'group':1, 'default':0,    'descr':'Column number for the item.  Used to disambiguate multiple coverage points on the same line number'")
+VLCOVGEN_ITEM("'name':'filename',    'short':'f',  'group':1, 'default':None, 'descr':'Filename of the item'")
+VLCOVGEN_ITEM("'name':'linescov',    'short':'S',  'group':1, 'default':'',   'descr':'List of comma-separated lines covered'")
+VLCOVGEN_ITEM("'name':'per_instance','short':'P',  'group':1, 'default':0,    'descr':'True if every hierarchy is independently counted; otherwise all hierarchies will be combined into a single count'")
+VLCOVGEN_ITEM("'name':'thresh',      'short':'s',  'group':1, 'default':None, 'descr':'Number of hits to consider covered (aka at_least)'")
+VLCOVGEN_ITEM("'name':'type',        'short':'t',  'group':1, 'default':'',   'descr':'Type of coverage (block, line, fsm, etc)'")
 // Bin attributes
-VLCOVGEN_ITEM("name=>'col0',        short=>'c0', group=>0, default=>undef, descr=>'The (enumeration) value name for this column in a table cross' ")
-VLCOVGEN_ITEM("name=>'col1',        short=>'c1', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'col2',        short=>'c2', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'col3',        short=>'c3', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'comment',     short=>'o',  group=>0, default=>'',    descr=>'Textual description for the item'")
-VLCOVGEN_ITEM("name=>'hier',        short=>'h',  group=>0, default=>'',    descr=>'Hierarchy path name for the item'")
-VLCOVGEN_ITEM("name=>'limit',       short=>'L',  group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'lineno',      short=>'l',  group=>0, default=>0,     descr=>'Line number for the item'")
-VLCOVGEN_ITEM("name=>'row0',        short=>'r0', group=>0, default=>undef, descr=>'The (enumeration) value name for this row in a table cross'")
-VLCOVGEN_ITEM("name=>'row1',        short=>'r1', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'row2',        short=>'r2', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'row3',        short=>'r3', group=>0, default=>undef, ")
-VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr=>'For totaling items, weight of this item'")
+VLCOVGEN_ITEM("'name':'comment',     'short':'o',  'group':0, 'default':'',   'descr':'Textual description for the item'")
+VLCOVGEN_ITEM("'name':'hier',        'short':'h',  'group':0, 'default':'',   'descr':'Hierarchy path name for the item'")
+VLCOVGEN_ITEM("'name':'lineno',      'short':'l',  'group':0, 'default':0,    'descr':'Line number for the item'")
+VLCOVGEN_ITEM("'name':'weight',      'short':'w',  'group':0, 'default':None, 'descr':'For totaling items, weight of this item'")
 // clang-format on

 // VLCOVGEN_CIK_AUTO_EDIT_BEGIN
-#define VL_CIK_COL0 "c0"
-#define VL_CIK_COL0_NAME "C0"
-#define VL_CIK_COL1 "c1"
-#define VL_CIK_COL1_NAME "C1"
-#define VL_CIK_COL2 "c2"
-#define VL_CIK_COL2_NAME "C2"
-#define VL_CIK_COL3 "c3"
-#define VL_CIK_COL3_NAME "C3"
 #define VL_CIK_COLUMN "n"
 #define VL_CIK_COMMENT "o"
 #define VL_CIK_FILENAME "f"
-#define VL_CIK_GROUPCMT "O"
-#define VL_CIK_GROUPDESC "d"
-#define VL_CIK_GROUPNAME "g"
 #define VL_CIK_HIER "h"
-#define VL_CIK_LIMIT "L"
 #define VL_CIK_LINENO "l"
+#define VL_CIK_LINESCOV "S"
 #define VL_CIK_PER_INSTANCE "P"
-#define VL_CIK_ROW0 "r0"
-#define VL_CIK_ROW0_NAME "R0"
-#define VL_CIK_ROW1 "r1"
-#define VL_CIK_ROW1_NAME "R1"
-#define VL_CIK_ROW2 "r2"
-#define VL_CIK_ROW2_NAME "R2"
-#define VL_CIK_ROW3 "r3"
-#define VL_CIK_ROW3_NAME "R3"
-#define VL_CIK_TABLE "T"
 #define VL_CIK_THRESH "s"
 #define VL_CIK_TYPE "t"
 #define VL_CIK_WEIGHT "w"
@@ -100,37 +60,17 @@ VLCOVGEN_ITEM("name=>'weight',      short=>'w',  group=>0, default=>undef, descr
 /// Verilator coverage global class.
 /// This class is thread safe.

-class VerilatedCovKey {
+class VerilatedCovKey final {
 public:
    static std::string shortKey(const std::string& key) VL_PURE {
        // VLCOVGEN_SHORT_AUTO_EDIT_BEGIN
-        if (key == "col0") return VL_CIK_COL0;
-        if (key == "col0_name") return VL_CIK_COL0_NAME;
-        if (key == "col1") return VL_CIK_COL1;
-        if (key == "col1_name") return VL_CIK_COL1_NAME;
-        if (key == "col2") return VL_CIK_COL2;
-        if (key == "col2_name") return VL_CIK_COL2_NAME;
-        if (key == "col3") return VL_CIK_COL3;
-        if (key == "col3_name") return VL_CIK_COL3_NAME;
        if (key == "column") return VL_CIK_COLUMN;
        if (key == "comment") return VL_CIK_COMMENT;
        if (key == "filename") return VL_CIK_FILENAME;
-        if (key == "groupcmt") return VL_CIK_GROUPCMT;
-        if (key == "groupdesc") return VL_CIK_GROUPDESC;
-        if (key == "groupname") return VL_CIK_GROUPNAME;
        if (key == "hier") return VL_CIK_HIER;
-        if (key == "limit") return VL_CIK_LIMIT;
        if (key == "lineno") return VL_CIK_LINENO;
+        if (key == "linescov") return VL_CIK_LINESCOV;
        if (key == "per_instance") return VL_CIK_PER_INSTANCE;
-        if (key == "row0") return VL_CIK_ROW0;
-        if (key == "row0_name") return VL_CIK_ROW0_NAME;
-        if (key == "row1") return VL_CIK_ROW1;
-        if (key == "row1_name") return VL_CIK_ROW1_NAME;
-        if (key == "row2") return VL_CIK_ROW2;
-        if (key == "row2_name") return VL_CIK_ROW2_NAME;
-        if (key == "row3") return VL_CIK_ROW3;
-        if (key == "row3_name") return VL_CIK_ROW3_NAME;
-        if (key == "table") return VL_CIK_TABLE;
        if (key == "thresh") return VL_CIK_THRESH;
        if (key == "type") return VL_CIK_TYPE;
        if (key == "weight") return VL_CIK_WEIGHT;
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -37,17 +37,12 @@
 //======================================================================
 // Internal macros

-// Not supported yet
-#define _VL_SVDPI_UNIMP() \
-    VL_FATAL_MT(__FILE__, __LINE__, "", \
-                (std::string("%%Error: Unsupported DPI function: ") + VL_FUNC).c_str())
-
 #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");
+                   "'context' keyword.\n")

 //======================================================================
 //======================================================================
@@ -181,7 +176,7 @@ void svPutPartselLogic(svLogicVecVal* dp, const svLogicVecVal s, int lbit, int w
 static inline const VerilatedDpiOpenVar* _vl_openhandle_varp(const svOpenArrayHandle h) {
    if (VL_UNLIKELY(!h)) {
        VL_FATAL_MT(__FILE__, __LINE__, "",
-                    "%%Error: DPI svOpenArrayHandle function called with NULL handle");
+                    "%%Error: DPI svOpenArrayHandle function called with nullptr handle");
    }
    const VerilatedDpiOpenVar* varp = reinterpret_cast<const VerilatedDpiOpenVar*>(h);
    if (VL_UNLIKELY(!varp->magicOk())) {
@@ -202,10 +197,10 @@ int svIncrement(const svOpenArrayHandle h, int d) { return _vl_openhandle_varp(h
 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
+/// Return pointer to open array data, or nullptr if not in IEEE standard C layout
 void* svGetArrayPtr(const svOpenArrayHandle h) {
    const VerilatedDpiOpenVar* varp = _vl_openhandle_varp(h);
-    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return NULL;
+    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr;
    return varp->datap();
 }
 /// Return size of open array, or 0 if not in IEEE standard C layout
@@ -226,7 +221,7 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, i
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function called on"
                       " %d dimensional array using %d dimensional function.\n",
                       varp->udims(), nargs);
-        return NULL;
+        return nullptr;
    }
    if (nargs >= 1) {
        datap = varp->datapAdjustIndex(datap, 1, indx1);
@@ -234,7 +229,7 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, i
            _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;
+            return nullptr;
        }
    }
    if (nargs >= 2) {
@@ -243,7 +238,7 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, i
            _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;
+            return nullptr;
        }
    }
    if (nargs >= 3) {
@@ -252,27 +247,17 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, i
            _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;
+            return nullptr;
        }
    }
    return datap;
 }

-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",
-                       indx, varp->left(0), varp->right(0));
-        return 0;
-    }
-    return indx - varp->low(0);
-}
-
-/// Return pointer to simulator open array element, or NULL if outside range
+/// Return pointer to simulator open array element, or nullptr if outside range
 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;
+    if (VL_UNLIKELY(!varp->isDpiStdLayout())) return nullptr;
    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
    return datap;
 }
@@ -283,7 +268,7 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
    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()) {
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
    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;
@@ -299,10 +284,10 @@ static void _vl_svGetBitArrElemVecVal(svBitVecVal* d, const svOpenArrayHandle s,
        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) d[i] = wdatap[i];
        return;
    }
-    default:
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return;
+        return;  // LCOV_EXCL_STOP
    }
 }
 /// Copy to user logic array from simulator open array
@@ -311,7 +296,7 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
    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()) {
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
    case VLVT_UINT8:
        d[0].aval = *(reinterpret_cast<CData*>(datap));
        d[0].bval = 0;
@@ -330,7 +315,7 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
        d[0].aval = lwp[0];
        d[0].bval = 0;
        d[1].aval = lwp[1];
-        d[0].bval = 0;
+        d[1].bval = 0;
        break;
    }
    case VLVT_WDATA: {
@@ -341,10 +326,10 @@ static void _vl_svGetLogicArrElemVecVal(svLogicVecVal* d, const svOpenArrayHandl
        }
        return;
    }
-    default:
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return;
+        return;  // LCOV_EXCL_STOP
    }
 }

@@ -354,7 +339,7 @@ static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecV
    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()) {
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
    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;
@@ -364,10 +349,10 @@ static void _vl_svPutBitArrElemVecVal(const svOpenArrayHandle d, const svBitVecV
        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i];
        return;
    }
-    default:
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return;
+        return;  // LCOV_EXCL_STOP
    }
 }
 /// Copy to simulator open array from from user logic array
@@ -376,7 +361,7 @@ static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogic
    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()) {
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
    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;
@@ -388,10 +373,10 @@ static void _vl_svPutLogicArrElemVecVal(const svOpenArrayHandle d, const svLogic
        for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i].aval;
        return;
    }
-    default:
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return;
+        return;  // LCOV_EXCL_STOP
    }
 }

@@ -400,31 +385,14 @@ static svBit _vl_svGetBitArrElem(const svOpenArrayHandle s, int nargs, int indx1
                                 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));
-    } else {
-        datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
-        lsb = 0;
-    }
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
    if (VL_UNLIKELY(!datap)) return 0;
-    switch (varp->vltype()) {
-    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_WDATA: {
-        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        return VL_BITRSHIFT_W(wdatap, lsb) & 1;
-    }
-    default:
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
+    case VLVT_UINT8: return (*(reinterpret_cast<CData*>(datap))) & 1;
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return 0;
+        return 0;  // LCOV_EXCL_STOP
    }
 }
 /// Update simulator open array from bit
@@ -433,27 +401,14 @@ static void _vl_svPutBitArrElem(const svOpenArrayHandle d, svBit value, int narg
    // 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));
-    } else {
-        datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
-        lsb = 0;
-    }
+    void* datap = _vl_sv_adjusted_datap(varp, nargs, indx1, indx2, indx3);
    if (VL_UNLIKELY(!datap)) return;
-    switch (varp->vltype()) {
-    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;
-    default:
+    switch (varp->vltype()) {  // LCOV_EXCL_BR_LINE
+    case VLVT_UINT8: *(reinterpret_cast<CData*>(datap)) = value; return;
+    default:  // LCOV_EXCL_START  // Errored earlier
        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
                       varp->vltype());
-        return;
+        return;  // LCOV_EXCL_STOP
    }
 }

@@ -643,13 +598,6 @@ svBit svGetBitArrElem(const svOpenArrayHandle s, int indx1, ...) {
        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);
@@ -683,13 +631,6 @@ svLogic svGetLogicArrElem(const svOpenArrayHandle s, int indx1, ...) {
        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);
@@ -725,13 +666,6 @@ void svPutBitArrElem(const svOpenArrayHandle d, svBit value, int indx1, ...) {
        _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);
@@ -763,13 +697,6 @@ void svPutLogicArrElem(const svOpenArrayHandle d, svLogic value, int indx1, ...)
        _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);
@@ -794,7 +721,7 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int
 svScope svGetScope() {
    if (VL_UNLIKELY(!Verilated::dpiInContext())) {
        _VL_SVDPI_CONTEXT_WARN();
-        return NULL;
+        return nullptr;
    }
    // NOLINTNEXTLINE(google-readability-casting)
    return (svScope)(Verilated::dpiScope());
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2021 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.
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -36,17 +36,12 @@
 #include "gtkwave/lz4.c"

 #include <algorithm>
-#include <cerrno>
-#include <ctime>
-#include <fcntl.h>
 #include <iterator>
 #include <sstream>
-#include <sys/stat.h>

 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
 #else
-# include <stdint.h>
 # include <unistd.h>
 #endif

@@ -63,14 +58,12 @@
 // VerilatedFst

 VerilatedFst::VerilatedFst(void* fst)
-    : m_fst(fst)
-    , m_symbolp(NULL)
-    , m_strbuf(NULL) {}
+    : m_fst{fst} {}

 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);
+    if (m_symbolp) VL_DO_CLEAR(delete[] m_symbolp, m_symbolp = nullptr);
+    if (m_strbuf) VL_DO_CLEAR(delete[] m_strbuf, m_strbuf = nullptr);
 }

 void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
@@ -87,7 +80,7 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
    VerilatedTrace<VerilatedFst>::traceInit();

    // Clear the scope stack
-    std::list<std::string>::iterator it = m_curScope.begin();
+    auto it = m_curScope.begin();
    while (it != m_curScope.end()) {
        fstWriterSetUpscope(m_fst);
        it = m_curScope.erase(it);
@@ -96,22 +89,19 @@ void VerilatedFst::open(const char* filename) VL_MT_UNSAFE {
    // 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;
-        }
+        for (const auto& i : m_code2symbol) m_symbolp[i.first] = i.second;
    }
    m_code2symbol.clear();

    // Allocate string buffer for arrays
-    if (!m_strbuf) { m_strbuf = new char[maxBits() + 32]; }
+    if (!m_strbuf) m_strbuf = new char[maxBits() + 32];
 }

 void VerilatedFst::close() {
    m_assertOne.check();
    VerilatedTrace<VerilatedFst>::close();
    fstWriterClose(m_fst);
-    m_fst = NULL;
+    m_fst = nullptr;
 }

 void VerilatedFst::flush() {
@@ -132,23 +122,23 @@ void VerilatedFst::declDTypeEnum(int dtypenum, const char* name, vluint32_t elem
    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,
-                              vluint32_t bits) {
+void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                           fstVarType vartype, bool array, int arraynum, int msb, int lsb) {
+    const int bits = ((msb > lsb) ? (msb - lsb) : (lsb - msb)) + 1;
+
    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);
-    std::istream_iterator<std::string> beg(nameiss), end;
+    std::istream_iterator<std::string> beg(nameiss);
+    std::istream_iterator<std::string> end;
    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(), 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();
+    auto cur_it = m_curScope.begin();
+    auto new_it = tokens.begin();
    while (cur_it != m_curScope.end() && new_it != tokens.end()) {
        if (*cur_it != *new_it) break;
        ++cur_it;
@@ -163,7 +153,7 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name, int dtypenum, f

    // Follow the hierarchy of the new variable from the common scope point
    while (new_it != tokens.end()) {
-        fstWriterSetScope(m_fst, FST_ST_VCD_SCOPE, new_it->c_str(), NULL);
+        fstWriterSetScope(m_fst, FST_ST_VCD_SCOPE, new_it->c_str(), nullptr);
        m_curScope.push_back(*new_it);
        new_it = tokens.erase(new_it);
    }
@@ -177,40 +167,35 @@ void VerilatedFst::declSymbol(vluint32_t code, const char* name, int dtypenum, f
        fstEnumHandle enumNum = m_local2fstdtype[dtypenum];
        fstWriterEmitEnumTableRef(m_fst, enumNum);
    }
-    if (p.second) {  // New
-        p.first->second = fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), 0);
-        assert(p.first->second);
+
+    const auto it = vlstd::as_const(m_code2symbol).find(code);
+    if (it == m_code2symbol.end()) {  // New
+        m_code2symbol[code]
+            = fstWriterCreateVar(m_fst, vartype, vardir, bits, name_str.c_str(), 0);
    } else {  // Alias
-        fstWriterCreateVar(m_fst, vartype, vardir, len, name_str.c_str(), p.first->second);
+        fstWriterCreateVar(m_fst, vartype, vardir, bits, name_str.c_str(), it->second);
    }
 }

 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);
+    declare(code, name, dtypenum, vardir, vartype, array, arraynum, 0, 0);
 }
 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);
+    declare(code, name, dtypenum, vardir, vartype, array, arraynum, msb, lsb);
 }
 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);
+    declare(code, name, dtypenum, vardir, vartype, array, arraynum, msb, lsb);
 }
 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);
+    declare(code, name, dtypenum, vardir, vartype, array, arraynum, msb, lsb);
 }
 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);
+    declare(code, name, dtypenum, vardir, vartype, array, arraynum, 63, 0);
 }

 // Note: emit* are only ever called from one place (full* in
@@ -266,11 +251,6 @@ void VerilatedFst::emitWData(vluint32_t code, const WData* newvalp, int bits) {
    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);
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -35,7 +35,7 @@
 /// Base class to create a Verilator FST dump
 /// This is an internally used class - see VerilatedFstC for what to call from applications

-class VerilatedFst : public VerilatedTrace<VerilatedFst> {
+class VerilatedFst final : public VerilatedTrace<VerilatedFst> {
 private:
    // Give the superclass access to private bits (to avoid virtual functions)
    friend class VerilatedTrace<VerilatedFst>;
@@ -50,24 +50,24 @@ private:
    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
+    fstHandle* m_symbolp = nullptr;  ///< same as m_code2symbol, but as an array
+    char* m_strbuf = nullptr;  ///< 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, vluint32_t bits);
+    void declare(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
+                 fstVarType vartype, bool array, int arraynum, int msb, int lsb);

 protected:
    //=========================================================================
    // Implementation of VerilatedTrace interface

    // Implementations of protected virtual methods for VerilatedTrace
-    void emitTimeChange(vluint64_t timeui) VL_OVERRIDE;
+    virtual void emitTimeChange(vluint64_t timeui) override;

    // Hooks called from VerilatedTrace
-    bool preFullDump() VL_OVERRIDE { return isOpen(); }
-    bool preChangeDump() VL_OVERRIDE { return isOpen(); }
+    virtual bool preFullDump() override { return isOpen(); }
+    virtual bool preChangeDump() override { return isOpen(); }

    // Implementations of duck-typed methods for VerilatedTrace. These are
    // called from only one place (namely full*) so always inline them.
@@ -77,14 +77,13 @@ protected:
    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:
    //=========================================================================
    // External interface to client code

-    explicit VerilatedFst(void* fst = NULL);
+    explicit VerilatedFst(void* fst = nullptr);
    ~VerilatedFst();

    /// Open the file; call isOpen() to see if errors
@@ -94,7 +93,7 @@ public:
    /// Flush any remaining data to this file
    void flush() VL_MT_UNSAFE;
    /// Is file open?
-    bool isOpen() const { return m_fst != NULL; }
+    bool isOpen() const { return m_fst != nullptr; }

    //=========================================================================
    // Internal interface to Verilator generated code
@@ -112,8 +111,6 @@ public:
                  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);
 };
@@ -131,15 +128,15 @@ template <> void VerilatedTrace<VerilatedFst>::set_time_resolution(const std::st
 /// Also derived for use in SystemC simulations.
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE

-class VerilatedFstC {
+class VerilatedFstC final {
    VerilatedFst m_sptrace;  ///< Trace file being created

    // CONSTRUCTORS
    VL_UNCOPYABLE(VerilatedFstC);

 public:
-    explicit VerilatedFstC(void* filep = NULL)
-        : m_sptrace(filep) {}
+    explicit VerilatedFstC(void* filep = nullptr)
+        : m_sptrace{filep} {}
    ~VerilatedFstC() { close(); }
    /// Routines can only be called from one thread; allow next call from different thread
    void changeThread() { spTrace()->changeThread(); }
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2010-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2010-2021 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.
@@ -26,10 +26,13 @@

 #include "verilated.h"

+#include <algorithm>
 #include <deque>
 #include <map>
 #include <memory>
+#include <set>
 #include <string>
+#include <unordered_set>

 //===================================================================
 // String formatters (required by below containers)
@@ -41,10 +44,21 @@ 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);

+//===================================================================
+// Shuffle RNG
+
+class VlURNG final {
+public:
+    typedef size_t result_type;
+    static constexpr size_t min() { return 0; }
+    static constexpr size_t max() { return 1ULL << 31; }
+    size_t operator()() { return VL_MASK_I(31) & VL_RANDOM_I(32); }
+};
+
 //===================================================================
 // Readmem/Writemem operation classes

-class VlReadMem {
+class VlReadMem final {
    bool m_hex;  // Hex format
    int m_bits;  // Bit width of values
    const std::string& m_filename;  // Filename
@@ -55,41 +69,52 @@ class VlReadMem {
 public:
    VlReadMem(bool hex, int bits, const std::string& filename, QData start, QData end);
    ~VlReadMem();
-    bool isOpen() const { return m_fp != NULL; }
+    bool isOpen() const { return m_fp != nullptr; }
    int linenum() const { return m_linenum; }
    bool get(QData& addrr, std::string& valuer);
    void setData(void* valuep, const std::string& rhs);
 };

-class VlWriteMem {
+class VlWriteMem final {
+    bool m_hex;  // Hex format
    int m_bits;  // Bit width of values
    FILE* m_fp;  // File handle for filename
    QData m_addr;  // Next address to write
 public:
    VlWriteMem(bool hex, int bits, const std::string& filename, QData start, QData end);
    ~VlWriteMem();
-    bool isOpen() const { return m_fp != NULL; }
+    bool isOpen() const { return m_fp != nullptr; }
    void print(QData addr, bool addrstamp, const void* valuep);
 };

 //===================================================================
-// Verilog array container
-// Similar to std::array<WData, N>, but:
-//   1. Doesn't require C++11
-//   2. Lighter weight, only methods needed by Verilator, to help compile time.
+// Verilog wide-number-in-array container
+// Similar to std::array<WData, N>, but lighter weight, only methods needed
+// by Verilator, to help compile time.
 //
 // This is only used when we need an upper-level container and so can't
 // simply use a C style array (which is just a pointer).

-template <std::size_t T_Words> class VlWide {
-    WData m_storage[T_Words];
+template <std::size_t T_Words> class VlWide final {
+    EData m_storage[T_Words];

 public:
    // cppcheck-suppress uninitVar
-    VlWide() {}
-    ~VlWide() {}
-    const WData& at(size_t index) const { return m_storage[index]; }
-    WData& at(size_t index) { return m_storage[index]; }
+    VlWide() = default;
+    ~VlWide() = default;
+    VlWide(const VlWide&) = default;
+    VlWide(VlWide&&) = default;
+
+    // OPERATOR METHODS
+    VlWide& operator=(const VlWide&) = default;
+    VlWide& operator=(VlWide&&) = default;
+    const EData& operator[](size_t index) const { return m_storage[index]; };
+    EData& operator[](size_t index) { return m_storage[index]; };
+    operator WDataOutP() { return &m_storage[0]; }
+
+    // METHODS
+    const EData& at(size_t index) const { return m_storage[index]; }
+    EData& at(size_t index) { return m_storage[index]; }
    WData* data() { return &m_storage[0]; }
    const WData* data() const { return &m_storage[0]; }
    bool operator<(const VlWide<T_Words>& rhs) const {
@@ -107,145 +132,6 @@ template <std::size_t T_Words> std::string VL_TO_STRING(const VlWide<T_Words>& o
    return VL_TO_STRING_W(T_Words, obj.data());
 }

-//===================================================================
-// Verilog associative array container
-// There are no multithreaded locks on this; the base variable must
-// be protected by other means
-//
-template <class T_Key, class T_Value> class VlAssocArray {
-private:
-    // TYPES
-    typedef std::map<T_Key, T_Value> Map;
-
-public:
-    typedef typename Map::const_iterator const_iterator;
-
-private:
-    // MEMBERS
-    Map m_map;  // State of the assoc array
-    T_Value m_defaultValue;  // Default value
-
-public:
-    // CONSTRUCTORS
-    VlAssocArray() {
-        // m_defaultValue isn't defaulted. Caller's constructor must do it.
-    }
-    ~VlAssocArray() {}
-    // Standard copy constructor works. Verilog: assoca = assocb
-
-    // METHODS
-    T_Value& atDefault() { return m_defaultValue; }
-
-    // Size of array. Verilog: function int size(), or int num()
-    int size() const { return m_map.size(); }
-    // Clear array. Verilog: function void delete([input index])
-    void clear() { m_map.clear(); }
-    void erase(const T_Key& index) { m_map.erase(index); }
-    // Return 0/1 if element exists. Verilog: function int exists(input index)
-    int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); }
-    // Return first element.  Verilog: function int first(ref index);
-    int first(T_Key& indexr) const {
-        typename Map::const_iterator it = m_map.begin();
-        if (it == m_map.end()) return 0;
-        indexr = it->first;
-        return 1;
-    }
-    // Return last element.  Verilog: function int last(ref index)
-    int last(T_Key& indexr) const {
-        typename Map::const_reverse_iterator it = m_map.rbegin();
-        if (it == m_map.rend()) return 0;
-        indexr = it->first;
-        return 1;
-    }
-    // Return next element. Verilog: function int next(ref index)
-    int next(T_Key& indexr) const {
-        typename Map::const_iterator it = m_map.find(indexr);
-        if (VL_UNLIKELY(it == m_map.end())) return 0;
-        ++it;
-        if (VL_UNLIKELY(it == m_map.end())) return 0;
-        indexr = it->first;
-        return 1;
-    }
-    // Return prev element. Verilog: function int prev(ref index)
-    int prev(T_Key& indexr) const {
-        typename Map::const_iterator it = m_map.find(indexr);
-        if (VL_UNLIKELY(it == m_map.end())) return 0;
-        if (VL_UNLIKELY(it == m_map.begin())) return 0;
-        --it;
-        indexr = it->first;
-        return 1;
-    }
-    // Setting. Verilog: assoc[index] = v
-    // Can't just overload operator[] or provide a "at" reference to set,
-    // because we need to be able to insert only when the value is set
-    T_Value& at(const T_Key& index) {
-        typename Map::iterator it = m_map.find(index);
-        if (it == m_map.end()) {
-            std::pair<typename Map::iterator, bool> pit
-                = m_map.insert(std::make_pair(index, m_defaultValue));
-            return pit.first->second;
-        }
-        return it->second;
-    }
-    // Accessing. Verilog: v = assoc[index]
-    const T_Value& at(const T_Key& index) const {
-        typename Map::iterator it = m_map.find(index);
-        if (it == m_map.end()) {
-            return m_defaultValue;
-        } else {
-            return it->second;
-        }
-    }
-    // For save/restore
-    const_iterator begin() const { return m_map.begin(); }
-    const_iterator end() const { return m_map.end(); }
-
-    // Dumping. Verilog: str = $sformatf("%p", assoc)
-    std::string to_string() const {
-        std::string out = "'{";
-        std::string comma;
-        for (typename Map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-            out += comma + VL_TO_STRING(it->first) + ":" + VL_TO_STRING(it->second);
-            comma = ", ";
-        }
-        // Default not printed - maybe random init data
-        return out + "} ";
-    }
-};
-
-template <class T_Key, class T_Value>
-std::string VL_TO_STRING(const VlAssocArray<T_Key, T_Value>& obj) {
-    return obj.to_string();
-}
-
-template <class T_Key, class T_Value>
-void VL_READMEM_N(bool hex, int bits, const std::string& filename,
-                  VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
-    VlReadMem rmem(hex, bits, filename, start, end);
-    if (VL_UNLIKELY(!rmem.isOpen())) return;
-    while (true) {
-        QData addr;
-        std::string data;
-        if (rmem.get(addr /*ref*/, data /*ref*/)) {
-            rmem.setData(&(obj.at(addr)), data);
-        } else {
-            break;
-        }
-    }
-}
-
-template <class T_Key, class T_Value>
-void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
-                   const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
-    VlWriteMem wmem(hex, bits, filename, start, end);
-    if (VL_UNLIKELY(!wmem.isOpen())) return;
-    for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = obj.begin(); it != obj.end();
-         ++it) {
-        QData addr = it->first;
-        if (addr >= start && addr <= end) wmem.print(addr, true, &(it->second));
-    }
-}
-
 //===================================================================
 // Verilog queue and dynamic array container
 // There are no multithreaded locks on this; the base variable must
@@ -253,7 +139,7 @@ void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
 //
 // 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 {
+template <class T_Value, size_t T_MaxSize = 0> class VlQueue final {
 private:
    // TYPES
    typedef std::deque<T_Value> Deque;
@@ -268,21 +154,61 @@ private:

 public:
    // CONSTRUCTORS
-    VlQueue() {
-        // m_defaultValue isn't defaulted. Caller's constructor must do it.
-    }
-    ~VlQueue() {}
+    // m_defaultValue isn't defaulted. Caller's constructor must do it.
+    VlQueue() = default;
+    ~VlQueue() = default;
+    VlQueue(const VlQueue&) = default;
+    VlQueue(VlQueue&&) = default;
+    VlQueue& operator=(const VlQueue&) = default;
+    VlQueue& operator=(VlQueue&&) = default;
+
    // Standard copy constructor works. Verilog: assoca = assocb
+    // Also must allow conversion from a different T_MaxSize queue
+    template <size_t U_MaxSize = 0> VlQueue operator=(const VlQueue<T_Value, U_MaxSize>& rhs) {
+        m_deque = rhs.privateDeque();
+        if (VL_UNLIKELY(T_MaxSize && T_MaxSize < m_deque.size())) m_deque.resize(T_MaxSize - 1);
+        return *this;
+    }
+
+    static VlQueue cons(const T_Value& lhs) {
+        VlQueue out;
+        out.push_back(lhs);
+        return out;
+    }
+    static VlQueue cons(const T_Value& lhs, const T_Value& rhs) {
+        VlQueue out;
+        out.push_back(rhs);
+        out.push_back(lhs);
+        return out;
+    }
+    static VlQueue cons(const VlQueue& lhs, const T_Value& rhs) {
+        VlQueue out = lhs;
+        out.push_front(rhs);
+        return out;
+    }
+    static VlQueue cons(const T_Value& lhs, const VlQueue& rhs) {
+        VlQueue out = rhs;
+        out.push_back(lhs);
+        return out;
+    }
+    static VlQueue cons(const VlQueue& lhs, const VlQueue& rhs) {
+        VlQueue out = rhs;
+        for (const auto& i : lhs.m_deque) out.push_back(i);
+        return out;
+    }

    // METHODS
    T_Value& atDefault() { return m_defaultValue; }
+    const T_Value& atDefault() const { return m_defaultValue; }
+    const Deque& privateDeque() const { return m_deque; }

    // Size. Verilog: function int size(), or int num()
    int size() const { return m_deque.size(); }
    // Clear array. Verilog: function void delete([input index])
    void clear() { m_deque.clear(); }
-    void erase(size_t index) {
-        if (VL_LIKELY(index < m_deque.size())) m_deque.erase(index);
+    void erase(vlsint32_t index) {
+        if (VL_LIKELY(index >= 0 && index < m_deque.size()))
+            m_deque.erase(m_deque.begin() + index);
    }

    // Dynamic array new[] becomes a renew()
@@ -327,10 +253,10 @@ public:
    // Setting. Verilog: assoc[index] = v
    // Can't just overload operator[] or provide a "at" reference to set,
    // because we need to be able to insert only when the value is set
-    T_Value& at(size_t index) {
+    T_Value& at(vlsint32_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())) {
+        if (VL_UNLIKELY(index < 0 || index >= m_deque.size())) {
            s_throwAway = atDefault();
            return s_throwAway;
        } else {
@@ -338,31 +264,221 @@ public:
        }
    }
    // Accessing. Verilog: v = assoc[index]
-    const T_Value& at(size_t index) const {
+    const T_Value& at(vlsint32_t index) const {
        static T_Value s_throwAway;
        // Needs to work for dynamic arrays, so does not use T_MaxSize
-        if (VL_UNLIKELY(index >= m_deque.size())) {
+        if (VL_UNLIKELY(index < 0 || index >= m_deque.size())) {
            return atDefault();
        } else {
            return m_deque[index];
        }
    }
    // function void q.insert(index, value);
-    void insert(size_t index, const T_Value& value) {
-        if (VL_UNLIKELY(index >= m_deque.size())) return;
-        m_deque[index] = value;
+    void insert(vlsint32_t index, const T_Value& value) {
+        if (VL_UNLIKELY(index < 0 || index >= m_deque.size())) return;
+        m_deque.insert(m_deque.begin() + index, value);
+    }
+
+    // Return slice q[lsb:msb]
+    VlQueue slice(vlsint32_t lsb, vlsint32_t msb) const {
+        VlQueue out;
+        if (VL_UNLIKELY(lsb < 0)) lsb = 0;
+        if (VL_UNLIKELY(lsb >= m_deque.size())) lsb = m_deque.size() - 1;
+        if (VL_UNLIKELY(msb >= m_deque.size())) msb = m_deque.size() - 1;
+        for (vlsint32_t i = lsb; i <= msb; ++i) out.push_back(m_deque[i]);
+        return out;
    }

    // For save/restore
    const_iterator begin() const { return m_deque.begin(); }
    const_iterator end() const { return m_deque.end(); }

+    // Methods
+    void sort() { std::sort(m_deque.begin(), m_deque.end()); }
+    template <typename Func> void sort(Func with_func) {
+        // with_func returns arbitrary type to use for the sort comparison
+        std::sort(m_deque.begin(), m_deque.end(), [=](const T_Value& a, const T_Value& b) {
+            // index number is meaninless with sort, as it changes
+            return with_func(0, a) < with_func(0, b);
+        });
+    }
+    void rsort() { std::sort(m_deque.rbegin(), m_deque.rend()); }
+    template <typename Func> void rsort(Func with_func) {
+        // with_func returns arbitrary type to use for the sort comparison
+        std::sort(m_deque.rbegin(), m_deque.rend(), [=](const T_Value& a, const T_Value& b) {
+            // index number is meaninless with sort, as it changes
+            return with_func(0, a) < with_func(0, b);
+        });
+    }
+    void reverse() { std::reverse(m_deque.begin(), m_deque.end()); }
+    void shuffle() { std::shuffle(m_deque.begin(), m_deque.end(), VlURNG()); }
+    VlQueue unique() const {
+        VlQueue out;
+        std::unordered_set<T_Value> saw;
+        for (const auto& i : m_deque) {
+            auto it = saw.find(i);
+            if (it == saw.end()) {
+                saw.insert(it, i);
+                out.push_back(i);
+            }
+        }
+        return out;
+    }
+    VlQueue<IData> unique_index() const {
+        VlQueue<IData> out;
+        IData index = 0;
+        std::unordered_set<T_Value> saw;
+        for (const auto& i : m_deque) {
+            auto it = saw.find(i);
+            if (it == saw.end()) {
+                saw.insert(it, i);
+                out.push_back(index);
+            }
+            ++index;
+        }
+        return out;
+    }
+    template <typename Func> VlQueue find(Func with_func) const {
+        VlQueue out;
+        IData index = 0;
+        for (const auto& i : m_deque) {
+            if (with_func(index, i)) out.push_back(i);
+            ++index;
+        }
+        return out;
+    }
+    template <typename Func> VlQueue<IData> find_index(Func with_func) const {
+        VlQueue<IData> out;
+        IData index = 0;
+        for (const auto& i : m_deque) {
+            if (with_func(index, i)) out.push_back(index);
+            ++index;
+        }
+        return out;
+    }
+    template <typename Func> VlQueue find_first(Func with_func) const {
+        // Can't use std::find_if as need index number
+        IData index = 0;
+        for (const auto& i : m_deque) {
+            if (with_func(index, i)) return VlQueue::cons(i);
+            ++index;
+        }
+        return VlQueue{};
+    }
+    template <typename Func> VlQueue<IData> find_first_index(Func with_func) const {
+        IData index = 0;
+        for (const auto& i : m_deque) {
+            if (with_func(index, i)) return VlQueue<IData>::cons(index);
+            ++index;
+        }
+        return VlQueue<IData>{};
+    }
+    template <typename Func> VlQueue find_last(Func with_func) const {
+        IData index = m_deque.size() - 1;
+        for (auto it = m_deque.rbegin(); it != m_deque.rend(); ++it) {
+            if (with_func(index, *it)) return VlQueue::cons(*it);
+            --index;
+        }
+        return VlQueue{};
+    }
+    template <typename Func> VlQueue<IData> find_last_index(Func with_func) const {
+        IData index = m_deque.size() - 1;
+        for (auto it = m_deque.rbegin(); it != m_deque.rend(); ++it) {
+            if (with_func(index, *it)) return VlQueue<IData>::cons(index);
+            --index;
+        }
+        return VlQueue<IData>{};
+    }
+
+    // Reduction operators
+    VlQueue min() const {
+        if (m_deque.empty()) return VlQueue();
+        const auto it = std::min_element(m_deque.begin(), m_deque.end());
+        return VlQueue::cons(*it);
+    }
+    VlQueue max() const {
+        if (m_deque.empty()) return VlQueue();
+        const auto it = std::max_element(m_deque.begin(), m_deque.end());
+        return VlQueue::cons(*it);
+    }
+
+    T_Value r_sum() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_deque) out += i;
+        return out;
+    }
+    template <typename Func> T_Value r_sum(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        IData index = 0;
+        for (const auto& i : m_deque) out += with_func(index++, i);
+        return out;
+    }
+    T_Value r_product() const {
+        if (m_deque.empty()) return T_Value(0);
+        auto it = m_deque.begin();
+        T_Value out{*it};
+        ++it;
+        for (; it != m_deque.end(); ++it) out *= *it;
+        return out;
+    }
+    template <typename Func> T_Value r_product(Func with_func) const {
+        if (m_deque.empty()) return T_Value(0);
+        auto it = m_deque.begin();
+        IData index = 0;
+        T_Value out{with_func(index, *it)};
+        ++it;
+        ++index;
+        for (; it != m_deque.end(); ++it) out *= with_func(index++, *it);
+        return out;
+    }
+    T_Value r_and() const {
+        if (m_deque.empty()) return T_Value(0);
+        auto it = m_deque.begin();
+        T_Value out{*it};
+        ++it;
+        for (; it != m_deque.end(); ++it) out &= *it;
+        return out;
+    }
+    template <typename Func> T_Value r_and(Func with_func) const {
+        if (m_deque.empty()) return T_Value(0);
+        auto it = m_deque.begin();
+        IData index = 0;
+        T_Value out{with_func(index, *it)};
+        ++it;
+        ++index;
+        for (; it != m_deque.end(); ++it) out &= with_func(index, *it);
+        return out;
+    }
+    T_Value r_or() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_deque) out |= i;
+        return out;
+    }
+    template <typename Func> T_Value r_or(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        IData index = 0;
+        for (const auto& i : m_deque) out |= with_func(index++, i);
+        return out;
+    }
+    T_Value r_xor() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_deque) out ^= i;
+        return out;
+    }
+    template <typename Func> T_Value r_xor(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        IData index = 0;
+        for (const auto& i : m_deque) out ^= with_func(index++, i);
+        return out;
+    }
+
    // Dumping. Verilog: str = $sformatf("%p", assoc)
    std::string to_string() const {
+        if (m_deque.empty()) return "'{}";  // No trailing space
        std::string out = "'{";
        std::string comma;
-        for (typename Deque::const_iterator it = m_deque.begin(); it != m_deque.end(); ++it) {
-            out += comma + VL_TO_STRING(*it);
+        for (const auto& i : m_deque) {
+            out += comma + VL_TO_STRING(i);
            comma = ", ";
        }
        return out + "} ";
@@ -373,19 +489,352 @@ template <class T_Value> std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
    return obj.to_string();
 }

+//===================================================================
+// Verilog associative array container
+// There are no multithreaded locks on this; the base variable must
+// be protected by other means
+//
+template <class T_Key, class T_Value> class VlAssocArray final {
+private:
+    // TYPES
+    typedef std::map<T_Key, T_Value> Map;
+
+public:
+    typedef typename Map::const_iterator const_iterator;
+
+private:
+    // MEMBERS
+    Map m_map;  // State of the assoc array
+    T_Value m_defaultValue;  // Default value
+
+public:
+    // CONSTRUCTORS
+    // m_defaultValue isn't defaulted. Caller's constructor must do it.
+    VlAssocArray() = default;
+    ~VlAssocArray() = default;
+    VlAssocArray(const VlAssocArray&) = default;
+    VlAssocArray(VlAssocArray&&) = default;
+    VlAssocArray& operator=(const VlAssocArray&) = default;
+    VlAssocArray& operator=(VlAssocArray&&) = default;
+
+    // METHODS
+    T_Value& atDefault() { return m_defaultValue; }
+    const T_Value& atDefault() const { return m_defaultValue; }
+
+    // Size of array. Verilog: function int size(), or int num()
+    int size() const { return m_map.size(); }
+    // Clear array. Verilog: function void delete([input index])
+    void clear() { m_map.clear(); }
+    void erase(const T_Key& index) { m_map.erase(index); }
+    // Return 0/1 if element exists. Verilog: function int exists(input index)
+    int exists(const T_Key& index) const { return m_map.find(index) != m_map.end(); }
+    // Return first element.  Verilog: function int first(ref index);
+    int first(T_Key& indexr) const {
+        const auto it = m_map.cbegin();
+        if (it == m_map.end()) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return last element.  Verilog: function int last(ref index)
+    int last(T_Key& indexr) const {
+        const auto it = m_map.crbegin();
+        if (it == m_map.rend()) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return next element. Verilog: function int next(ref index)
+    int next(T_Key& indexr) const {
+        auto it = m_map.find(indexr);
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        ++it;
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        indexr = it->first;
+        return 1;
+    }
+    // Return prev element. Verilog: function int prev(ref index)
+    int prev(T_Key& indexr) const {
+        auto it = m_map.find(indexr);
+        if (VL_UNLIKELY(it == m_map.end())) return 0;
+        if (VL_UNLIKELY(it == m_map.begin())) return 0;
+        --it;
+        indexr = it->first;
+        return 1;
+    }
+    // Setting. Verilog: assoc[index] = v
+    // Can't just overload operator[] or provide a "at" reference to set,
+    // because we need to be able to insert only when the value is set
+    T_Value& at(const T_Key& index) {
+        const auto it = m_map.find(index);
+        if (it == m_map.end()) {
+            std::pair<typename Map::iterator, bool> pit = m_map.emplace(index, m_defaultValue);
+            return pit.first->second;
+        }
+        return it->second;
+    }
+    // Accessing. Verilog: v = assoc[index]
+    const T_Value& at(const T_Key& index) const {
+        const auto it = m_map.find(index);
+        if (it == m_map.end()) {
+            return m_defaultValue;
+        } else {
+            return it->second;
+        }
+    }
+    // Setting as a chained operation
+    VlAssocArray& set(const T_Key& index, const T_Value& value) {
+        at(index) = value;
+        return *this;
+    }
+    VlAssocArray& setDefault(const T_Value& value) {
+        atDefault() = value;
+        return *this;
+    }
+
+    // For save/restore
+    const_iterator begin() const { return m_map.begin(); }
+    const_iterator end() const { return m_map.end(); }
+
+    // Methods
+    VlQueue<T_Value> unique() const {
+        VlQueue<T_Value> out;
+        std::set<T_Value> saw;
+        for (const auto& i : m_map) {
+            auto it = saw.find(i.second);
+            if (it == saw.end()) {
+                saw.insert(it, i.second);
+                out.push_back(i.second);
+            }
+        }
+        return out;
+    }
+    VlQueue<T_Key> unique_index() const {
+        VlQueue<T_Key> out;
+        std::set<T_Key> saw;
+        for (const auto& i : m_map) {
+            auto it = saw.find(i.second);
+            if (it == saw.end()) {
+                saw.insert(it, i.second);
+                out.push_back(i.first);
+            }
+        }
+        return out;
+    }
+    template <typename Func> VlQueue<T_Value> find(Func with_func) const {
+        VlQueue<T_Value> out;
+        for (const auto& i : m_map)
+            if (with_func(i.first, i.second)) out.push_back(i.second);
+        return out;
+    }
+    template <typename Func> VlQueue<T_Key> find_index(Func with_func) const {
+        VlQueue<T_Key> out;
+        for (const auto& i : m_map)
+            if (with_func(i.first, i.second)) out.push_back(i.first);
+        return out;
+    }
+    template <typename Func> VlQueue<T_Value> find_first(Func with_func) const {
+        const auto it
+            = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
+        if (it == m_map.end()) return VlQueue<T_Value>{};
+        return VlQueue<T_Value>::cons(it->second);
+    }
+    template <typename Func> VlQueue<T_Key> find_first_index(Func with_func) const {
+        const auto it
+            = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
+        if (it == m_map.end()) return VlQueue<T_Value>{};
+        return VlQueue<T_Key>::cons(it->first);
+    }
+    template <typename Func> VlQueue<T_Value> find_last(Func with_func) const {
+        const auto it
+            = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
+        if (it == m_map.rend()) return VlQueue<T_Value>{};
+        return VlQueue<T_Value>::cons(it->second);
+    }
+    template <typename Func> VlQueue<T_Key> find_last_index(Func with_func) const {
+        const auto it
+            = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
+        if (it == m_map.rend()) return VlQueue<T_Value>{};
+        return VlQueue<T_Key>::cons(it->first);
+    }
+
+    // Reduction operators
+    VlQueue<T_Value> min() const {
+        if (m_map.empty()) return VlQueue<T_Value>();
+        const auto it = std::min_element(
+            m_map.begin(), m_map.end(),
+            [](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
+                return a.second < b.second;
+            });
+        return VlQueue<T_Value>::cons(it->second);
+    }
+    VlQueue<T_Value> max() const {
+        if (m_map.empty()) return VlQueue<T_Value>();
+        const auto it = std::max_element(
+            m_map.begin(), m_map.end(),
+            [](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
+                return a.second < b.second;
+            });
+        return VlQueue<T_Value>::cons(it->second);
+    }
+
+    T_Value r_sum() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out += i.second;
+        return out;
+    }
+    template <typename Func> T_Value r_sum(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out += with_func(i.first, i.second);
+        return out;
+    }
+    T_Value r_product() const {
+        if (m_map.empty()) return T_Value(0);
+        auto it = m_map.begin();
+        T_Value out{it->second};
+        ++it;
+        for (; it != m_map.end(); ++it) out *= it->second;
+        return out;
+    }
+    template <typename Func> T_Value r_product(Func with_func) const {
+        if (m_map.empty()) return T_Value(0);
+        auto it = m_map.begin();
+        T_Value out{with_func(it->first, it->second)};
+        ++it;
+        for (; it != m_map.end(); ++it) out *= with_func(it->first, it->second);
+        return out;
+    }
+    T_Value r_and() const {
+        if (m_map.empty()) return T_Value(0);
+        auto it = m_map.begin();
+        T_Value out{it->second};
+        ++it;
+        for (; it != m_map.end(); ++it) out &= it->second;
+        return out;
+    }
+    template <typename Func> T_Value r_and(Func with_func) const {
+        if (m_map.empty()) return T_Value(0);
+        auto it = m_map.begin();
+        T_Value out{with_func(it->first, it->second)};
+        ++it;
+        for (; it != m_map.end(); ++it) out &= with_func(it->first, it->second);
+        return out;
+    }
+    T_Value r_or() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out |= i.second;
+        return out;
+    }
+    template <typename Func> T_Value r_or(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out |= with_func(i.first, i.second);
+        return out;
+    }
+    T_Value r_xor() const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out ^= i.second;
+        return out;
+    }
+    template <typename Func> T_Value r_xor(Func with_func) const {
+        T_Value out(0);  // Type must have assignment operator
+        for (const auto& i : m_map) out ^= with_func(i.first, i.second);
+        return out;
+    }
+
+    // Dumping. Verilog: str = $sformatf("%p", assoc)
+    std::string to_string() const {
+        if (m_map.empty()) return "'{}";  // No trailing space
+        std::string out = "'{";
+        std::string comma;
+        for (const auto& i : m_map) {
+            out += comma + VL_TO_STRING(i.first) + ":" + VL_TO_STRING(i.second);
+            comma = ", ";
+        }
+        // Default not printed - maybe random init data
+        return out + "} ";
+    }
+};
+
+template <class T_Key, class T_Value>
+std::string VL_TO_STRING(const VlAssocArray<T_Key, T_Value>& obj) {
+    return obj.to_string();
+}
+
+template <class T_Key, class T_Value>
+void VL_READMEM_N(bool hex, int bits, const std::string& filename,
+                  VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
+    VlReadMem rmem(hex, bits, filename, start, end);
+    if (VL_UNLIKELY(!rmem.isOpen())) return;
+    while (true) {
+        QData addr;
+        std::string data;
+        if (rmem.get(addr /*ref*/, data /*ref*/)) {
+            rmem.setData(&(obj.at(addr)), data);
+        } else {
+            break;
+        }
+    }
+}
+
+template <class T_Key, class T_Value>
+void VL_WRITEMEM_N(bool hex, int bits, const std::string& filename,
+                   const VlAssocArray<T_Key, T_Value>& obj, QData start, QData end) VL_MT_SAFE {
+    VlWriteMem wmem(hex, bits, filename, start, end);
+    if (VL_UNLIKELY(!wmem.isOpen())) return;
+    for (const auto& i : obj) {
+        QData addr = i.first;
+        if (addr >= start && addr <= end) wmem.print(addr, true, &(i.second));
+    }
+}
+
+//===================================================================
+// Verilog packed array container
+// For when a standard C++[] array is not sufficient, e.g. an
+// array under a queue, or methods operating on the array
+
+template <class T_Value, std::size_t T_Depth> class VlUnpacked final {
+private:
+    // TYPES
+    typedef std::array<T_Value, T_Depth> Array;
+
+public:
+    typedef typename Array::const_iterator const_iterator;
+
+private:
+    // MEMBERS
+    Array m_array;  // State of the assoc array
+
+public:
+    // CONSTRUCTORS
+    VlUnpacked() = default;
+    ~VlUnpacked() = default;
+    VlUnpacked(const VlUnpacked&) = default;
+    VlUnpacked(VlUnpacked&&) = default;
+    VlUnpacked& operator=(const VlUnpacked&) = default;
+    VlUnpacked& operator=(VlUnpacked&&) = default;
+
+    // METHODS
+    // Raw access
+    WData* data() { return &m_array[0]; }
+    const WData* data() const { return &m_array[0]; }
+
+    T_Value& operator[](size_t index) { return m_array[index]; };
+    const T_Value& operator[](size_t index) const { return m_array[index]; };
+};
+
 //===================================================================
 // 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
+#define VlClassRef std::shared_ptr

 template <class T>  // T typically of type VlClassRef<x>
 inline T VL_NULL_CHECK(T t, const char* filename, int linenum) {
@@ -393,6 +842,17 @@ inline T VL_NULL_CHECK(T t, const char* filename, int linenum) {
    return t;
 }

+template <typename T, typename U>
+static inline bool VL_CAST_DYNAMIC(VlClassRef<T> in, VlClassRef<U>& outr) {
+    VlClassRef<U> casted = std::dynamic_pointer_cast<U>(in);
+    if (VL_LIKELY(casted)) {
+        outr = casted;
+        return true;
+    } else {
+        return false;
+    }
+}
+
 //======================================================================
 // Conversion functions

@@ -403,6 +863,7 @@ inline std::string VL_CVT_PACK_STR_NQ(QData lhs) VL_PURE {
    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(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);
@@ -427,7 +888,8 @@ 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 IData VL_FOPEN_NN(const std::string& filename, const std::string& mode) VL_MT_SAFE;
+extern IData VL_FOPEN_MCD_N(const std::string& filename) VL_MT_SAFE;
 extern void VL_READMEM_N(bool hex, int bits, QData depth, int array_lsb,
                         const std::string& filename, void* memp, QData start,
                         QData end) VL_MT_SAFE;
@@ -483,17 +945,17 @@ extern std::string VL_SUBSTR_N(const std::string& lhs, IData rhs, IData ths) VL_
 inline IData VL_CMP_NN(const std::string& lhs, const std::string& rhs, bool ignoreCase) VL_PURE {
    // SystemVerilog does not allow a string variable to contain '\0'.
    // So C functions such as strcmp() can correctly compare strings.
-    int result;
    if (ignoreCase) {
-        result = VL_STRCASECMP(lhs.c_str(), rhs.c_str());
+        return VL_STRCASECMP(lhs.c_str(), rhs.c_str());
    } else {
-        result = std::strcmp(lhs.c_str(), rhs.c_str());
+        return std::strcmp(lhs.c_str(), rhs.c_str());
    }
-    return result;
 }

 extern IData VL_ATOI_N(const std::string& str, int base) VL_PURE;

+extern IData VL_FGETS_NI(std::string& dest, IData fpi);
+
 //======================================================================
 // Dumping

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -32,6 +32,7 @@
 #include <deque>
 #include <set>
 #include <vector>
+#include <numeric>
 #ifdef VL_THREADED
 # include <functional>
 # include <queue>
@@ -45,7 +46,7 @@ class VerilatedScope;

 #ifdef VL_THREADED
 /// Message, enqueued on an mtask, and consumed on the main eval thread
-class VerilatedMsg {
+class VerilatedMsg final {
 public:
    // TYPES
    struct Cmp {
@@ -60,10 +61,14 @@ private:
    std::function<void()> m_cb;  ///< Lambda to execute when message received
 public:
    // CONSTRUCTORS
-    VerilatedMsg(const std::function<void()>& cb)
-        : m_mtaskId(Verilated::mtaskId())
-        , m_cb(cb) {}
-    ~VerilatedMsg() {}
+    explicit VerilatedMsg(const std::function<void()>& cb)
+        : m_mtaskId{Verilated::mtaskId()}
+        , m_cb{cb} {}
+    ~VerilatedMsg() = default;
+    VerilatedMsg(const VerilatedMsg&) = default;
+    VerilatedMsg(VerilatedMsg&&) = default;
+    VerilatedMsg& operator=(const VerilatedMsg&) = default;
+    VerilatedMsg& operator=(VerilatedMsg&&) = default;
    // METHODS
    vluint32_t mtaskId() const { return m_mtaskId; }
    /// Execute the lambda function
@@ -73,7 +78,7 @@ public:
 /// Each thread has a queue it pushes to
 /// This assumes no thread starts pushing the next tick until the previous has drained.
 /// If more aggressiveness is needed, a double-buffered scheme might work well.
-class VerilatedEvalMsgQueue {
+class VerilatedEvalMsgQueue final {
    typedef std::multiset<VerilatedMsg, VerilatedMsg::Cmp> VerilatedThreadQueue;

    std::atomic<vluint64_t> m_depth;  ///< Current depth of queue (see comments below)
@@ -83,10 +88,10 @@ class VerilatedEvalMsgQueue {
 public:
    // CONSTRUCTORS
    VerilatedEvalMsgQueue()
-        : m_depth(0) {
+        : m_depth{0} {
        assert(atomic_is_lock_free(&m_depth));
    }
-    ~VerilatedEvalMsgQueue() {}
+    ~VerilatedEvalMsgQueue() = default;

 private:
    VL_UNCOPYABLE(VerilatedEvalMsgQueue);
@@ -95,7 +100,7 @@ public:
    // METHODS
    //// Add message to queue (called by producer)
    void post(const VerilatedMsg& msg) VL_EXCLUDES(m_mutex) {
-        VerilatedLockGuard lock(m_mutex);
+        const VerilatedLockGuard lock(m_mutex);
        m_queue.insert(msg);  // Pass by value to copy the message into queue
        ++m_depth;
    }
@@ -111,7 +116,7 @@ public:
            // Unfortunately to release the lock we need to copy the message
            // (Or have the message be a pointer, but then new/delete cost on each message)
            // We assume messages are small, so copy
-            auto it = m_queue.begin();
+            const auto it = m_queue.begin();
            const VerilatedMsg msg = *(it);
            m_queue.erase(it);
            m_mutex.unlock();
@@ -125,7 +130,7 @@ public:
 };

 /// Each thread has a local queue to build up messages until the end of the eval() call
-class VerilatedThreadMsgQueue {
+class VerilatedThreadMsgQueue final {
    std::queue<VerilatedMsg> m_queue;

 public:
@@ -168,13 +173,31 @@ public:
 };
 #endif  // VL_THREADED

+// FILE* list constructed from a file-descriptor
+class VerilatedFpList final {
+    FILE* m_fp[31];
+    std::size_t m_sz = 0;
+
+public:
+    typedef FILE* const* const_iterator;
+    explicit VerilatedFpList() {}
+    const_iterator begin() const { return m_fp; }
+    const_iterator end() const { return m_fp + m_sz; }
+    std::size_t size() const { return m_sz; }
+    std::size_t capacity() const { return 31; }
+    void push_back(FILE* fd) {
+        if (VL_LIKELY(size() < capacity())) m_fp[m_sz++] = fd;
+    }
+};
+
 //======================================================================
 // VerilatedImp

-class VerilatedImp {
+class VerilatedImpData final {
    // Whole class is internal use only - Global information shared between verilated*.cpp files.
 protected:
    friend class Verilated;
+    friend class VerilatedImp;

    // TYPES
    typedef std::vector<std::string> ArgVec;
@@ -182,18 +205,14 @@ protected:
    typedef std::map<const char*, int, VerilatedCStrCmp> ExportNameMap;

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

    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
+        int m_timeFormatUnits = UNITS_NONE;  // $timeformat units
+        int m_timeFormatPrecision = 0;  // $timeformat number of decimal places
+        int m_timeFormatWidth = 20;  // $timeformat character width
        enum { UNITS_NONE = 99 };  // Default based on precision
-        Serialized()
-            : m_timeFormatUnits(UNITS_NONE)
-            , m_timeFormatPrecision(0)
-            , m_timeFormatWidth(20) {}
-        ~Serialized() {}
+        Serialized() = default;
+        ~Serialized() = default;
    } m_ser;

    VerilatedMutex m_sergMutex;  ///< Protect m_ser
@@ -216,7 +235,7 @@ protected:
    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);

    VerilatedMutex m_hierMapMutex;  ///< Protect m_hierMap
-    /// Map the represents scope hierarchy
+    /// Map that represents scope hierarchy
    VerilatedHierarchyMap m_hierMap VL_GUARDED_BY(m_hierMapMutex);

    // Slow - somewhat static:
@@ -229,19 +248,41 @@ protected:
    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);
+    std::vector<IData> m_fdFree VL_GUARDED_BY(m_fdMutex);
+    // List of free descriptors in the MCT region [4, 32)
+    std::vector<IData> m_fdFreeMct VL_GUARDED_BY(m_fdMutex);
+
+    // CONSTRUCTORS
+    VerilatedImpData()
+        : m_argVecLoaded{false}
+        , m_exportNext{0} {
+
+        m_fdps.resize(31);
+        std::fill(m_fdps.begin(), m_fdps.end(), (FILE*)0);
+        m_fdFreeMct.resize(30);
+        for (std::size_t i = 0, id = 1; i < m_fdFreeMct.size(); ++i, ++id) { m_fdFreeMct[i] = id; }
+    }
+};
+
+class VerilatedImp final {
+    // Whole class is internal use only - Global information shared between verilated*.cpp files.
+protected:
+    friend class Verilated;
+
+    // MEMBERS
+    union VerilatedImpU {  ///< Enclose in an union to call ctor/dtor manually
+        VerilatedImpData v;
+        VerilatedImpU() {}  // Can't be = default;
+        ~VerilatedImpU() {}  // Can't be = default;
+    };
+    static VerilatedImpU s_s;  ///< Static Singleton; One and only static this

 public:  // But only for verilated*.cpp
    // CONSTRUCTORS
-    VerilatedImp()
-        : m_argVecLoaded(false)
-        , m_exportNext(0) {
-        m_fdps.resize(3);
-        m_fdps[0] = stdin;
-        m_fdps[1] = stdout;
-        m_fdps[2] = stderr;
-    }
-    ~VerilatedImp() {}
+    VerilatedImp() = default;
+    ~VerilatedImp() = default;
+    static void setup();
+    static void teardown();

 private:
    VL_UNCOPYABLE(VerilatedImp);
@@ -253,28 +294,28 @@ public:

    // METHODS - arguments
 public:
-    static void commandArgs(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex);
-    static void commandArgsAdd(int argc, const char** argv) VL_EXCLUDES(s_s.m_argMutex);
-    static std::string argPlusMatch(const char* prefixp) VL_EXCLUDES(s_s.m_argMutex) {
-        VerilatedLockGuard lock(s_s.m_argMutex);
+    static void commandArgs(int argc, const char** argv) VL_EXCLUDES(s_s.v.m_argMutex);
+    static void commandArgsAdd(int argc, const char** argv) VL_EXCLUDES(s_s.v.m_argMutex);
+    static std::string argPlusMatch(const char* prefixp) VL_EXCLUDES(s_s.v.m_argMutex) {
+        const VerilatedLockGuard lock(s_s.v.m_argMutex);
        // Note prefixp does not include the leading "+"
        size_t len = strlen(prefixp);
-        if (VL_UNLIKELY(!s_s.m_argVecLoaded)) {
-            s_s.m_argVecLoaded = true;  // Complain only once
+        if (VL_UNLIKELY(!s_s.v.m_argVecLoaded)) {
+            s_s.v.m_argVecLoaded = true;  // Complain only once
            VL_FATAL_MT("unknown", 0, "",
                        "%Error: Verilog called $test$plusargs or $value$plusargs without"
                        " testbench C first calling Verilated::commandArgs(argc,argv).");
        }
-        for (ArgVec::const_iterator it = s_s.m_argVec.begin(); it != s_s.m_argVec.end(); ++it) {
-            if ((*it)[0] == '+') {
-                if (0 == strncmp(prefixp, it->c_str() + 1, len)) return *it;
+        for (const auto& i : s_s.v.m_argVec) {
+            if (i[0] == '+') {
+                if (0 == strncmp(prefixp, i.c_str() + 1, len)) return i;
            }
        }
        return "";
    }

 private:
-    static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex);
+    static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.v.m_argMutex);
    static void commandArgVl(const std::string& arg);
    static bool commandArgVlValue(const std::string& arg, const std::string& prefix,
                                  std::string& valuer);
@@ -285,18 +326,18 @@ public:
    // There's often many more scopes than userdata's and thus having a ~48byte
    // per map overhead * N scopes would take much more space and cache thrashing.
    static inline void userInsert(const void* scopep, void* userKey, void* userData) 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()) {
+        const VerilatedLockGuard lock(s_s.v.m_userMapMutex);
+        const auto it = s_s.v.m_userMap.find(std::make_pair(scopep, userKey));
+        if (it != s_s.v.m_userMap.end()) {
            it->second = userData;
        } else {
-            s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep, userKey), userData));
+            s_s.v.m_userMap.emplace(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_UNLIKELY(it == s_s.m_userMap.end())) return NULL;
+        const VerilatedLockGuard lock(s_s.v.m_userMapMutex);
+        const auto& it = vlstd::as_const(s_s.v.m_userMap).find(std::make_pair(scopep, userKey));
+        if (VL_UNLIKELY(it == s_s.v.m_userMap.end())) return nullptr;
        return it->second;
    }

@@ -304,25 +345,26 @@ private:
    /// Symbol table destruction cleans up the entries for each scope.
    static void userEraseScope(const VerilatedScope* scopep) VL_MT_SAFE {
        // Slow ok - called once/scope on destruction, so we simply iterate.
-        VerilatedLockGuard lock(s_s.m_userMapMutex);
-        for (UserMap::iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end();) {
+        const VerilatedLockGuard lock(s_s.v.m_userMapMutex);
+        for (auto it = s_s.v.m_userMap.begin(); it != s_s.v.m_userMap.end();) {
            if (it->first.first == scopep) {
-                s_s.m_userMap.erase(it++);
+                s_s.v.m_userMap.erase(it++);
            } else {
                ++it;
            }
        }
    }
    static void userDump() VL_MT_SAFE {
-        VerilatedLockGuard lock(s_s.m_userMapMutex);  // Avoid it changing in middle of dump
+        const VerilatedLockGuard lock(
+            s_s.v.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) {
+        for (const auto& i : s_s.v.m_userMap) {
            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);
+            VL_PRINTF_MT("    DPI_USER_DATA scope %p key %p: %p\n", i.first.first, i.first.second,
+                         i.second);
        }
    }

@@ -330,51 +372,58 @@ public:  // But only for verilated*.cpp
    // METHODS - scope name
    static void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE {
        // Slow ok - called once/scope at construction
-        VerilatedLockGuard lock(s_s.m_nameMutex);
-        VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name());
-        if (it == s_s.m_nameMap.end()) {
-            s_s.m_nameMap.insert(it, std::make_pair(scopep->name(), scopep));
-        }
+        const VerilatedLockGuard lock(s_s.v.m_nameMutex);
+        const auto it = s_s.v.m_nameMap.find(scopep->name());
+        if (it == s_s.v.m_nameMap.end()) s_s.v.m_nameMap.emplace(scopep->name(), scopep);
    }
    static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
-        VerilatedLockGuard lock(s_s.m_nameMutex);
+        const VerilatedLockGuard lock(s_s.v.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_UNLIKELY(it == s_s.m_nameMap.end())) return NULL;
+        const auto& it = s_s.v.m_nameMap.find(namep);
+        if (VL_UNLIKELY(it == s_s.v.m_nameMap.end())) return nullptr;
        return it->second;
    }
    static void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
        // Slow ok - called once/scope at destruction
-        VerilatedLockGuard lock(s_s.m_nameMutex);
+        const VerilatedLockGuard lock(s_s.v.m_nameMutex);
        userEraseScope(scopep);
-        VerilatedScopeNameMap::iterator it = s_s.m_nameMap.find(scopep->name());
-        if (it != s_s.m_nameMap.end()) s_s.m_nameMap.erase(it);
+        const auto it = s_s.v.m_nameMap.find(scopep->name());
+        if (it != s_s.v.m_nameMap.end()) s_s.v.m_nameMap.erase(it);
    }
    static void scopesDump() VL_MT_SAFE {
-        VerilatedLockGuard lock(s_s.m_nameMutex);
+        const VerilatedLockGuard lock(s_s.v.m_nameMutex);
        VL_PRINTF_MT("  scopesDump:\n");
-        for (VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.begin();
-             it != s_s.m_nameMap.end(); ++it) {
-            const VerilatedScope* scopep = it->second;
+        for (const auto& i : s_s.v.m_nameMap) {
+            const VerilatedScope* scopep = i.second;
            scopep->scopeDump();
        }
        VL_PRINTF_MT("\n");
    }
    static const VerilatedScopeNameMap* scopeNameMap() VL_MT_SAFE_POSTINIT {
        // Thread save only assuming this is called only after model construction completed
-        return &s_s.m_nameMap;
+        return &s_s.v.m_nameMap;
    }

 public:  // But only for verilated*.cpp
    // METHODS - hierarchy
    static void hierarchyAdd(const VerilatedScope* fromp, const VerilatedScope* top) VL_MT_SAFE {
        // Slow ok - called at construction for VPI accessible elements
-        VerilatedLockGuard lock(s_s.m_hierMapMutex);
-        s_s.m_hierMap[fromp].push_back(top);
+        const VerilatedLockGuard lock(s_s.v.m_hierMapMutex);
+        s_s.v.m_hierMap[fromp].push_back(top);
+    }
+    static void hierarchyRemove(const VerilatedScope* fromp,
+                                const VerilatedScope* top) VL_MT_SAFE {
+        // Slow ok - called at destruction for VPI accessible elements
+        const VerilatedLockGuard lock(s_s.v.m_hierMapMutex);
+        VerilatedHierarchyMap& map = s_s.v.m_hierMap;
+        if (map.find(fromp) == map.end()) return;
+        auto& scopes = map[fromp];
+        const auto it = find(scopes.begin(), scopes.end(), top);
+        if (it != scopes.end()) scopes.erase(it);
    }
    static const VerilatedHierarchyMap* hierarchyMap() VL_MT_SAFE_POSTINIT {
        // Thread save only assuming this is called only after model construction completed
-        return &s_s.m_hierMap;
+        return &s_s.v.m_hierMap;
    }

 public:  // But only for verilated*.cpp
@@ -388,19 +437,19 @@ public:  // But only for verilated*.cpp
    // miss at the cost of a multiply, and all lookups move to slowpath.
    static int exportInsert(const char* namep) VL_MT_SAFE {
        // Slow ok - called once/function at creation
-        VerilatedLockGuard lock(s_s.m_exportMutex);
-        ExportNameMap::iterator it = s_s.m_exportMap.find(namep);
-        if (it == s_s.m_exportMap.end()) {
-            s_s.m_exportMap.insert(it, std::make_pair(namep, s_s.m_exportNext++));
-            return s_s.m_exportNext++;
+        const VerilatedLockGuard lock(s_s.v.m_exportMutex);
+        const auto it = s_s.v.m_exportMap.find(namep);
+        if (it == s_s.v.m_exportMap.end()) {
+            s_s.v.m_exportMap.emplace(namep, s_s.v.m_exportNext++);
+            return s_s.v.m_exportNext++;
        } else {
            return it->second;
        }
    }
    static int exportFind(const char* namep) VL_MT_SAFE {
-        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;
+        const VerilatedLockGuard lock(s_s.v.m_exportMutex);
+        const auto& it = s_s.v.m_exportMap.find(namep);
+        if (VL_LIKELY(it != s_s.v.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");
        VL_FATAL_MT("unknown", 0, "", msg.c_str());
@@ -408,23 +457,21 @@ public:  // But only for verilated*.cpp
    }
    static const char* exportName(int funcnum) VL_MT_SAFE {
        // Slowpath; find name for given export; errors only so no map to reverse-map it
-        VerilatedLockGuard lock(s_s.m_exportMutex);
-        for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin();
-             it != s_s.m_exportMap.end(); ++it) {
-            if (it->second == funcnum) return it->first;
+        const VerilatedLockGuard lock(s_s.v.m_exportMutex);
+        for (const auto& i : s_s.v.m_exportMap) {
+            if (i.second == funcnum) return i.first;
        }
        return "*UNKNOWN*";
    }
    static void exportsDump() VL_MT_SAFE {
-        VerilatedLockGuard lock(s_s.m_exportMutex);
+        const VerilatedLockGuard lock(s_s.v.m_exportMutex);
        bool first = true;
-        for (ExportNameMap::const_iterator it = s_s.m_exportMap.begin();
-             it != s_s.m_exportMap.end(); ++it) {
+        for (const auto& i : s_s.v.m_exportMap) {
            if (first) {
                VL_PRINTF_MT("  exportDump:\n");
                first = false;
            }
-            VL_PRINTF_MT("    DPI_EXPORT_NAME %05d: %s\n", it->second, it->first);
+            VL_PRINTF_MT("    DPI_EXPORT_NAME %05d: %s\n", i.second, i.first);
        }
    }
    // We don't free up m_exportMap until the end, because we can't be sure
@@ -435,49 +482,124 @@ public:  // But only for verilated*.cpp
    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) {
+        if (s_s.v.m_ser.m_timeFormatUnits == VerilatedImpData::Serialized::UNITS_NONE) {
            return Verilated::timeprecision();
        }
-        return s_s.m_ser.m_timeFormatUnits;
+        return s_s.v.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 int timeFormatPrecision() VL_MT_SAFE { return s_s.v.m_ser.m_timeFormatPrecision; }
+    static int timeFormatWidth() VL_MT_SAFE { return s_s.v.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 {
+    static IData fdNewMcd(const char* filenamep) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        if (s_s.v.m_fdFreeMct.empty()) return 0;
+        IData idx = s_s.v.m_fdFreeMct.back();
+        s_s.v.m_fdFreeMct.pop_back();
+        s_s.v.m_fdps[idx] = fopen(filenamep, "w");
+        if (VL_UNLIKELY(!s_s.v.m_fdps[idx])) return 0;
+        return (1 << idx);
+    }
+    static IData fdNew(const char* filenamep, const char* modep) VL_MT_SAFE {
+        FILE* fp = fopen(filenamep, modep);
        if (VL_UNLIKELY(!fp)) return 0;
        // Bit 31 indicates it's a descriptor not a MCD
-        VerilatedLockGuard lock(s_s.m_fdMutex);
-        if (s_s.m_fdFree.empty()) {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        if (s_s.v.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));
+            const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, s_s.v.m_fdps.size());
+            const std::size_t excess = 10;
+            s_s.v.m_fdps.resize(start + excess);
+            std::fill(s_s.v.m_fdps.begin() + start, s_s.v.m_fdps.end(), (FILE*)0);
+            s_s.v.m_fdFree.resize(excess);
+            for (std::size_t i = 0, id = start; i < s_s.v.m_fdFree.size(); ++i, ++id) {
+                s_s.v.m_fdFree[i] = id;
            }
        }
-        IData idx = s_s.m_fdFree.back();
-        s_s.m_fdFree.pop_back();
-        s_s.m_fdps[idx] = fp;
+        IData idx = s_s.v.m_fdFree.back();
+        s_s.v.m_fdFree.pop_back();
+        s_s.v.m_fdps[idx] = fp;
        return (idx | (1UL << 31));  // bit 31 indicates not MCD
    }
-    static void fdDelete(IData fdi) VL_MT_SAFE {
-        IData idx = VL_MASK_I(31) & fdi;
-        VerilatedLockGuard lock(s_s.m_fdMutex);
-        if (VL_UNLIKELY(!(fdi & (VL_ULL(1) << 31)) || idx >= s_s.m_fdps.size())) return;
-        if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
-        s_s.m_fdps[idx] = NULL;
-        s_s.m_fdFree.push_back(idx);
+    static void fdFlush(IData fdi) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        for (const auto& i : fdlist) fflush(i);
+    }
+    static IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
+        return static_cast<IData>(
+            fseek(*fdlist.begin(), static_cast<long>(offset), static_cast<int>(origin)));
+    }
+    static IData fdTell(IData fdi) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
+        return static_cast<IData>(ftell(*fdlist.begin()));
+    }
+    static void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        for (const auto& i : fdlist) {
+            if (VL_UNLIKELY(!i)) continue;
+            (void)fwrite(output.c_str(), 1, output.size(), i);
+        }
+    }
+    static void fdClose(IData fdi) VL_MT_SAFE {
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        if ((fdi & (1 << 31)) != 0) {
+            // Non-MCD case
+            IData idx = VL_MASK_I(31) & fdi;
+            if (VL_UNLIKELY(idx >= s_s.v.m_fdps.size())) return;
+            if (VL_UNLIKELY(!s_s.v.m_fdps[idx])) return;  // Already free
+            fclose(s_s.v.m_fdps[idx]);
+            s_s.v.m_fdps[idx] = (FILE*)0;
+            s_s.v.m_fdFree.push_back(idx);
+        } else {
+            // MCD case
+            for (int i = 0; (fdi != 0) && (i < 31); i++, fdi >>= 1) {
+                if (fdi & VL_MASK_I(1)) {
+                    fclose(s_s.v.m_fdps[i]);
+                    s_s.v.m_fdps[i] = nullptr;
+                    s_s.v.m_fdFreeMct.push_back(i);
+                }
+            }
+        }
    }
    static inline FILE* fdToFp(IData fdi) VL_MT_SAFE {
-        IData idx = VL_MASK_I(31) & fdi;
-        VerilatedLockGuard lock(s_s.m_fdMutex);  // This might get slow, if it does we can cache it
-        if (VL_UNLIKELY(!(fdi & (VL_ULL(1) << 31)) || idx >= s_s.m_fdps.size())) return NULL;
-        return s_s.m_fdps[idx];
+        const VerilatedLockGuard lock(s_s.v.m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr;
+        return *fdlist.begin();
+    }
+
+private:
+    static inline VerilatedFpList fdToFpList(IData fdi) VL_REQUIRES(s_s.v.m_fdMutex) {
+        VerilatedFpList fp;
+        if ((fdi & (1 << 31)) != 0) {
+            // Non-MCD case
+            const IData idx = fdi & VL_MASK_I(31);
+            switch (idx) {
+            case 0: fp.push_back(stdin); break;
+            case 1: fp.push_back(stdout); break;
+            case 2: fp.push_back(stderr); break;
+            default:
+                if (VL_LIKELY(idx < s_s.v.m_fdps.size())) fp.push_back(s_s.v.m_fdps[idx]);
+                break;
+            }
+        } else {
+            // MCD Case
+            for (size_t i = 0; (fdi != 0) && (i < fp.capacity()); ++i, fdi >>= 1) {
+                if (fdi & VL_MASK_I(1)) fp.push_back(s_s.v.m_fdps[i]);
+            }
+        }
+        return fp;
    }
 };

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

 // clang-format off

-// Use VL_DISABLE_INTRINSICS to disable all intrinsics based optimization
-#if !defined(VL_DISABLE_INTRINSICS) && !defined(VL_PORTABLE_ONLY)
+// Use VL_PORTABLE_ONLY to disable all intrinsics based optimization
+#ifndef VL_PORTABLE_ONLY
 # if defined(__SSE2__) && !defined(VL_DISABLE_SSE2)
 #  define VL_HAVE_SSE2 1
 #  include <emmintrin.h>
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 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.
@@ -42,9 +42,10 @@
 // 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_TRAILER_STR = "vltsaved";  ///< Value of last bytes of each file
+/// Value of first bytes of each file (must be multiple of 8 bytes)
+static const char* const VLTSAVE_HEADER_STR = "verilatorsave01\n";
+/// Value of last bytes of each file (must be multiple of 8 bytes)
+static const char* const VLTSAVE_TRAILER_STR = "vltsaved";

 //=============================================================================
 //=============================================================================
@@ -64,10 +65,10 @@ VerilatedDeserialize& VerilatedDeserialize::readAssert(const void* __restrict da
                                                       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();
+        // Die before we close() as close would infinite loop
    }
    return *this;  // For function chaining
 }
@@ -88,9 +89,11 @@ void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
    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(
+                  "Can't deserialize; file has wrong header signature, or file not found: ")
+              + filename();
        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
-        close();
+        // Die before we close() as close would infinite loop
    }
    os.read(Verilated::serialized1Ptr(), Verilated::serialized1Size());
    os.read(Verilated::serialized2Ptr(), Verilated::serialized2Size());
@@ -109,7 +112,7 @@ void VerilatedDeserialize::trailer() VL_MT_UNSAFE_ONE {
        std::string msg = std::string("Can't deserialize; file has wrong end-of-file signature: ")
                          + filename();
        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
-        close();
+        // Die before we close() as close would infinite loop
    }
 }

@@ -123,13 +126,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] == '|') {
-        assert(0);  // Not supported yet.
+    if (VL_UNCOVERABLE(filenamep[0] == '|')) {
+        assert(0);  // LCOV_EXCL_LINE // 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) {
+        if (VL_UNLIKELY(m_fd < 0)) {
            // User code can check isOpen()
            m_isOpen = false;
            return;
@@ -146,12 +149,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] == '|') {
-        assert(0);  // Not supported yet.
+    if (VL_UNCOVERABLE(filenamep[0] == '|')) {
+        assert(0);  // LCOV_EXCL_LINE // Not supported yet.
    } else {
        // cppcheck-suppress duplicateExpression
        m_fd = ::open(filenamep, O_CREAT | O_RDONLY | O_LARGEFILE | O_CLOEXEC, 0666);
-        if (m_fd < 0) {
+        if (VL_UNLIKELY(m_fd < 0)) {
            // User code can check isOpen()
            m_isOpen = false;
            return;
@@ -194,13 +197,15 @@ void VerilatedSave::flush() VL_MT_UNSAFE_ONE {
        ssize_t got = ::write(m_fd, wp, remaining);
        if (got > 0) {
            wp += got;
-        } else if (got < 0) {
-            if (errno != EAGAIN && errno != EINTR) {
+        } else if (VL_UNCOVERABLE(got < 0)) {
+            if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
+                // LCOV_EXCL_START
                // write failed, presume error (perhaps out of disk space)
                std::string msg = std::string(__FUNCTION__) + ": " + strerror(errno);
                VL_FATAL_MT("", 0, "", msg.c_str());
                close();
                break;
+                // LCOV_EXCL_STOP
            }
        }
    }
@@ -223,13 +228,15 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
        ssize_t got = ::read(m_fd, m_endp, remaining);
        if (got > 0) {
            m_endp += got;
-        } else if (got < 0) {
-            if (errno != EAGAIN && errno != EINTR) {
+        } else if (VL_UNCOVERABLE(got < 0)) {
+            if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
+                // LCOV_EXCL_START
                // write failed, presume error (perhaps out of disk space)
                std::string msg = std::string(__FUNCTION__) + ": " + strerror(errno);
                VL_FATAL_MT("", 0, "", msg.c_str());
                close();
                break;
+                // LCOV_EXCL_STOP
            }
        } else {  // got==0, EOF
            // Fill buffer from here to end with NULLs so reader's don't
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2000-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2000-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -28,18 +28,18 @@
 // VerilatedSerialize - convert structures to a stream representation
 // This class is not thread safe, it must be called by a single thread

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

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

    void header() VL_MT_UNSAFE_ONE;
    void trailer() VL_MT_UNSAFE_ONE;
@@ -49,13 +49,12 @@ protected:

 public:
    VerilatedSerialize() {
-        m_isOpen = false;
        m_bufp = new vluint8_t[bufferSize()];
        m_cp = m_bufp;
    }
    virtual ~VerilatedSerialize() {
        close();
-        if (m_bufp) VL_DO_CLEAR(delete m_bufp, m_bufp = NULL);
+        if (m_bufp) VL_DO_CLEAR(delete[] m_bufp, m_bufp = nullptr);
    }
    // METHODS
    bool isOpen() const { return m_isOpen; }
@@ -88,19 +87,19 @@ private:
 // VerilatedDeserial - load structures from a stream representation
 // This class is not thread safe, it must be called by a single thread

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

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

    virtual void fill() = 0;
    void header() VL_MT_UNSAFE_ONE;
@@ -111,14 +110,12 @@ protected:

 public:
    VerilatedDeserialize() {
-        m_isOpen = false;
        m_bufp = new vluint8_t[bufferSize()];
        m_cp = m_bufp;
-        m_endp = NULL;
    }
    virtual ~VerilatedDeserialize() {
        close();
-        if (m_bufp) VL_DO_CLEAR(delete m_bufp, m_bufp = NULL);
+        if (m_bufp) VL_DO_CLEAR(delete[] m_bufp, m_bufp = nullptr);
    }
    // METHODS
    bool isOpen() const { return m_isOpen; }
@@ -157,44 +154,42 @@ private:
 // VerilatedSave - serialize to a file
 // This class is not thread safe, it must be called by a single thread

-class VerilatedSave : public VerilatedSerialize {
+class VerilatedSave final : public VerilatedSerialize {
 private:
-    int m_fd;  ///< File descriptor we're writing to
+    int m_fd = -1;  ///< File descriptor we're writing to

 public:
    // CONSTRUCTORS
-    VerilatedSave()
-        : m_fd(-1) {}
-    virtual ~VerilatedSave() VL_OVERRIDE { close(); }
+    VerilatedSave() = default;
+    virtual ~VerilatedSave() override { close(); }
    // METHODS
    /// 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;
+    virtual void close() override VL_MT_UNSAFE_ONE;
+    virtual void flush() override VL_MT_UNSAFE_ONE;
 };

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

-class VerilatedRestore : public VerilatedDeserialize {
+class VerilatedRestore final : public VerilatedDeserialize {
 private:
-    int m_fd;  ///< File descriptor we're writing to
+    int m_fd = -1;  ///< File descriptor we're writing to

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

    // METHODS
    /// 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 {}
-    virtual void fill() VL_OVERRIDE VL_MT_UNSAFE_ONE;
+    virtual void close() override VL_MT_UNSAFE_ONE;
+    virtual void flush() override VL_MT_UNSAFE_ONE {}
+    virtual void fill() override VL_MT_UNSAFE_ONE;
 };

 //=============================================================================
@@ -257,10 +252,9 @@ 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) {
-        T_Key index = it->first;  // Copy to get around const_iterator
-        T_Value value = it->second;
+    for (const auto& i : rhs) {
+        T_Key index = i.first;  // Copy to get around const_iterator
+        T_Value value = i.second;
        os << index << value;
    }
    return os;
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2009-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2009-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -34,7 +34,7 @@
 // This class is thread safe (though most of SystemC is not).

 #define VL_SC_BV_DATAP(bv) (VlScBvExposer::sp_datap(bv))
-class VlScBvExposer : public sc_bv_base {
+class VlScBvExposer final : public sc_bv_base {
 public:
    static const vluint32_t* sp_datap(const sc_bv_base& base) VL_MT_SAFE {
        return static_cast<const VlScBvExposer*>(&base)->sp_datatp();
@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //*************************************************************************
 //
-// Copyright 2003-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2003-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -29,31 +29,31 @@

 #include "verilatedos.h"

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

 // See also V3Ast::VNumRange
-class VerilatedRange {
-    int m_left;
-    int m_right;
+class VerilatedRange final {
+    int m_left = 0;
+    int m_right = 0;

 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) {}
+    VerilatedRange() = default;
    void init(int left, int right) {
        m_left = left;
        m_right = right;
    }

 public:
-    ~VerilatedRange() {}
+    VerilatedRange(int left, int right)
+        : m_left{left}
+        , m_right{right} {}
+    ~VerilatedRange() = default;
    int left() const { return m_left; }
    int right() const { return m_right; }
    int low() const { return (m_left < m_right) ? m_left : m_right; }
@@ -68,110 +68,75 @@ public:
 /// Verilator variable
 /// Thread safety: Assume is constructed only with model, then any number of readers

-class VerilatedVarProps {
+class VerilatedVarProps VL_NOT_FINAL {
    // 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
+    const int m_pdims;  // Packed dimensions, 0 = none
+    const int m_udims;  // Unpacked dimensions, 0 = none
    VerilatedRange m_packed;  // Packed array range
-    VerilatedRange m_unpacked[3];  // Unpacked array range
+    std::vector<VerilatedRange> m_unpacked;  // Unpacked array ranges
+    void initUnpacked(const int* ulims) {
+        for (int i = 0; i < m_udims; ++i) {
+            const int uleft = ulims ? ulims[2 * i + 0] : 0;
+            const int uright = ulims ? ulims[2 * i + 1] : 0;
+            m_unpacked.emplace_back(uleft, uright);
+        }
+    }
    // 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) {}
+        : m_magic{MAGIC}
+        , m_vltype{vltype}
+        , m_vlflags{vlflags}
+        , m_pdims{pdims}
+        , m_udims{udims} {
+        initUnpacked(nullptr);
+    }

 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))  // Need () or GCC 4.8 false warning
+        , m_pdims{0}
+        , m_udims{0} {}
+    VerilatedVarProps(VerilatedVarType vltype, int vlflags, Unpacked, int udims, const int* ulims)
+        : m_magic{MAGIC}
+        , m_vltype{vltype}
+        , m_vlflags(VerilatedVarFlags(vlflags))  // Need () or GCC 4.8 false warning
+        , m_pdims{0}
+        , m_udims{udims} {
+        initUnpacked(ulims);
    }
    // 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) {}
+        : m_magic{MAGIC}
+        , m_vltype{vltype}
+        , m_vlflags(VerilatedVarFlags(vlflags))  // Need () or GCC 4.8 false warning
+        , 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);
+                      int udims, const int* ulims)
+        : m_magic{MAGIC}
+        , m_vltype{vltype}
+        , m_vlflags(VerilatedVarFlags(vlflags))  // Need () or GCC 4.8 false warning
+        , m_pdims{1}
+        , m_udims{udims}
+        , m_packed{pl, pr} {
+        initUnpacked(ulims);
    }

 public:
-    ~VerilatedVarProps() {}
+    ~VerilatedVarProps() = default;
    // METHODS
    bool magicOk() const { return m_magic == MAGIC; }
    VerilatedVarType vltype() const { return m_vltype; }
@@ -189,27 +154,29 @@ public:
    // 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;
+                        : VL_LIKELY(dim >= 1 && dim <= udims()) ? 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;
+                        : VL_LIKELY(dim >= 1 && dim <= udims()) ? 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;
+                        : VL_LIKELY(dim >= 1 && dim <= udims()) ? 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;
+                        : VL_LIKELY(dim >= 1 && dim <= udims()) ? 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 <= udims()) ? 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 <= udims()) ? m_unpacked[dim - 1].elements() : 0;
    }
    /// Total size in bytes (note DPI limited to 4GB)
    size_t totalSize() const;
@@ -220,19 +187,19 @@ public:
 //===========================================================================
 /// Verilator DPI open array variable

-class VerilatedDpiOpenVar {
+class VerilatedDpiOpenVar final {
    // MEMBERS
    const VerilatedVarProps* m_propsp;  // Variable properties
    void* m_datap;  // Location of data (local to thread always, so safe)
 public:
    // CONSTRUCTORS
    VerilatedDpiOpenVar(const VerilatedVarProps* propsp, void* datap)
-        : m_propsp(propsp)
-        , m_datap(datap) {}
+        : m_propsp{propsp}
+        , m_datap{datap} {}
    VerilatedDpiOpenVar(const VerilatedVarProps* propsp, const void* datap)
-        : m_propsp(propsp)
-        , m_datap(const_cast<void*>(datap)) {}
-    ~VerilatedDpiOpenVar() {}
+        : m_propsp{propsp}
+        , m_datap{const_cast<void*>(datap)} {}
+    ~VerilatedDpiOpenVar() = default;
    // METHODS
    void* datap() const { return m_datap; }
    // METHODS - from VerilatedVarProps
@@ -258,26 +225,29 @@ public:
 /// Verilator variable
 /// Thread safety: Assume is constructed only with model, then any number of readers

-class VerilatedVar : public VerilatedVarProps {
+class VerilatedVar final : public VerilatedVarProps {
    // MEMBERS
    void* m_datap;  // Location of data
    const char* m_namep;  // Name - slowpath
 protected:
+    bool m_isParam;
    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) {}
+                 VerilatedVarFlags vlflags, int dims, bool isParam)
+        : VerilatedVarProps{vltype, vlflags, (dims > 0 ? 1 : 0), ((dims > 1) ? dims - 1 : 0)}
+        , m_datap{datap}
+        , m_namep{namep}
+        , m_isParam{isParam} {}

 public:
-    ~VerilatedVar() {}
+    ~VerilatedVar() = default;
    // ACCESSORS
    void* datap() const { return m_datap; }
    const VerilatedRange& range() const { return packed(); }  // Deprecated
    const VerilatedRange& array() const { return unpacked(); }  // Deprecated
    const char* name() const { return m_namep; }
+    bool isParam() const { return m_isParam; }
 };

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

 #include <map>
+#include <unordered_map>
 #include <vector>

 //======================================================================
@@ -42,26 +43,29 @@ struct VerilatedCStrCmp {
 };

 /// Map of sorted scope names to find associated scope class
-class VerilatedScopeNameMap
+// This is a class instead of typedef/using to allow forward declaration in verilated.h
+class VerilatedScopeNameMap final
    : public std::map<const char*, const VerilatedScope*, VerilatedCStrCmp> {
 public:
-    VerilatedScopeNameMap() {}
-    ~VerilatedScopeNameMap() {}
+    VerilatedScopeNameMap() = default;
+    ~VerilatedScopeNameMap() = default;
 };

 /// Map of sorted variable names to find associated variable class
-class VerilatedVarNameMap : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
+// This is a class instead of typedef/using to allow forward declaration in verilated.h
+class VerilatedVarNameMap final : public std::map<const char*, VerilatedVar, VerilatedCStrCmp> {
 public:
-    VerilatedVarNameMap() {}
-    ~VerilatedVarNameMap() {}
+    VerilatedVarNameMap() = default;
+    ~VerilatedVarNameMap() = default;
 };

-typedef std::vector<const VerilatedScope*> VerilatedScopeVector;
-
-class VerilatedHierarchyMap : public std::map<const VerilatedScope*, VerilatedScopeVector> {
+/// Map of parent scope to vector of children scopes
+// This is a class instead of typedef/using to allow forward declaration in verilated.h
+class VerilatedHierarchyMap final
+    : public std::unordered_map<const VerilatedScope*, std::vector<const VerilatedScope*>> {
 public:
-    VerilatedHierarchyMap() {}
-    ~VerilatedHierarchyMap() {}
+    VerilatedHierarchyMap() = default;
+    ~VerilatedHierarchyMap() = default;
 };

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

 std::atomic<vluint64_t> VlMTaskVertex::s_yields;

-VL_THREAD_LOCAL VlThreadPool::ProfileTrace* VlThreadPool::t_profilep = NULL;
+VL_THREAD_LOCAL VlThreadPool::ProfileTrace* VlThreadPool::t_profilep = nullptr;

 //=============================================================================
 // 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));
 }

@@ -36,13 +36,11 @@ VlMTaskVertex::VlMTaskVertex(vluint32_t upstreamDepCount)
 // VlWorkerThread

 VlWorkerThread::VlWorkerThread(VlThreadPool* poolp, bool profiling)
-    : 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:
-    , m_cthread(startWorker, this) {}
+    : m_waiting{false}
+    , m_poolp{poolp}
+    , m_profiling{profiling}  // Must init this last -- after setting up fields that it might read:
+    , m_exiting{false}
+    , m_cthread{startWorker, this} {}

 VlWorkerThread::~VlWorkerThread() {
    m_exiting.store(true, std::memory_order_release);
@@ -55,7 +53,7 @@ void VlWorkerThread::workerLoop() {
    if (VL_UNLIKELY(m_profiling)) m_poolp->setupProfilingClientThread();

    ExecRec work;
-    work.m_fnp = NULL;
+    work.m_fnp = nullptr;

    while (true) {
        if (VL_LIKELY(!work.m_fnp)) dequeWork(&work);
@@ -65,7 +63,7 @@ void VlWorkerThread::workerLoop() {

        if (VL_LIKELY(work.m_fnp)) {
            work.m_fnp(work.m_evenCycle, work.m_sym);
-            work.m_fnp = NULL;
+            work.m_fnp = nullptr;
        }
    }

@@ -78,7 +76,7 @@ void VlWorkerThread::startWorker(VlWorkerThread* workerp) { workerp->workerLoop(
 // VlThreadPool

 VlThreadPool::VlThreadPool(int nThreads, bool profiling)
-    : m_profiling(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) {
@@ -100,17 +98,15 @@ VlThreadPool::VlThreadPool(int nThreads, bool profiling)
 }

 VlThreadPool::~VlThreadPool() {
-    for (int i = 0; i < m_workers.size(); ++i) {
-        // Each ~WorkerThread will wait for its thread to exit.
-        delete m_workers[i];
-    }
+    // Each ~WorkerThread will wait for its thread to exit.
+    for (auto& i : m_workers) delete i;
    if (VL_UNLIKELY(m_profiling)) tearDownProfilingClientThread();
 }

 void VlThreadPool::tearDownProfilingClientThread() {
    assert(t_profilep);
    delete t_profilep;
-    t_profilep = NULL;
+    t_profilep = nullptr;
 }

 void VlThreadPool::setupProfilingClientThread() {
@@ -120,28 +116,28 @@ void VlThreadPool::setupProfilingClientThread() {
    // try not to malloc while collecting profiling.
    t_profilep->reserve(4096);
    {
-        VerilatedLockGuard lk(m_mutex);
+        const VerilatedLockGuard lk(m_mutex);
        m_allProfiles.insert(t_profilep);
    }
 }

 void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
-    VerilatedLockGuard lk(m_mutex);
-    for (ProfileSet::iterator it = m_allProfiles.begin(); it != m_allProfiles.end(); ++it) {
+    const VerilatedLockGuard lk(m_mutex);
+    for (const auto& profilep : m_allProfiles) {
        // Every thread's profile trace gets a copy of rec.
-        (*it)->emplace_back(rec);
+        profilep->emplace_back(rec);
    }
 }

 void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
-    VerilatedLockGuard lk(m_mutex);
+    const VerilatedLockGuard lk(m_mutex);
    VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep););

    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;
+        return;  // LCOV_EXCL_LINE
    }

    // TODO Perhaps merge with verilated_coverage output format, so can
@@ -154,13 +150,12 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
    fprintf(fp, "VLPROF stat yields %" VL_PRI64 "u\n", VlMTaskVertex::yields());

    vluint32_t thread_id = 0;
-    for (ProfileSet::const_iterator pit = m_allProfiles.begin(); pit != m_allProfiles.end();
-         ++pit) {
+    for (const auto& pi : m_allProfiles) {
        ++thread_id;

        bool printing = false;  // False while in warmup phase
-        for (ProfileTrace::const_iterator eit = (*pit)->begin(); eit != (*pit)->end(); ++eit) {
-            switch (eit->m_type) {
+        for (const auto& ei : *pi) {
+            switch (ei.m_type) {
            case VlProfileRec::TYPE_BARRIER:  //
                printing = true;
                break;
@@ -170,9 +165,8 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
                        "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,
-                        thread_id);
+                        ei.m_mtaskId, ei.m_startTime, ei.m_endTime,
+                        (ei.m_endTime - ei.m_startTime), ei.m_predictTime, ei.m_cpu, thread_id);
                break;
            default: assert(false); break;  // LCOV_EXCL_LINE
            }
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2012-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2012-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -22,6 +22,15 @@
 #include "verilatedos.h"
 #include "verilated.h"  // for VerilatedMutex and clang annotations

+#ifndef VL_THREADED
+// Hitting this likely means verilated_threads.cpp is being compiled when
+// 'verilator --threads' was not used.  'verilator --threads' sets
+// VL_THREADED.
+// Alternatively it is always safe but may harm performance to always
+// define VL_THREADED for all compiles.
+#error "verilated_threads.h/cpp expected VL_THREADED (from verilator --threads)"
+#endif
+
 #include <condition_variable>
 #include <set>
 #include <vector>
@@ -43,7 +52,7 @@ typedef void* VlThrSymTab;
 typedef void (*VlExecFnp)(bool, VlThrSymTab);

 /// Track dependencies for a single MTask.
-class VlMTaskVertex {
+class VlMTaskVertex final {
    // MEMBERS
    static std::atomic<vluint64_t> s_yields;  // Statistics

@@ -73,7 +82,7 @@ public:
    // that must notify this MTaskVertex before it will become ready
    // to run.
    explicit VlMTaskVertex(vluint32_t upstreamDepCount);
-    ~VlMTaskVertex() {}
+    ~VlMTaskVertex() = default;

    static vluint64_t yields() { return s_yields; }
    static void yieldThread() {
@@ -115,27 +124,20 @@ public:
 };

 // Profiling support
-class VlProfileRec {
+class VlProfileRec final {
 protected:
    friend class VlThreadPool;
    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
-    vluint64_t m_startTime;  // Tick at start of execution
-    vluint64_t m_endTime;  // Tick at end of execution
+    VlProfileE m_type = TYPE_BARRIER;  // Record type
+    vluint32_t m_mtaskId = 0;  // Mtask we're logging
+    vluint32_t m_predictTime = 0;  // How long scheduler predicted would take
+    vluint64_t m_startTime = 0;  // Tick at start of execution
+    vluint64_t m_endTime = 0;  // Tick at end of execution
    unsigned m_cpu;  // Execution CPU number (at start anyways)
 public:
    class Barrier {};
-    VlProfileRec() {}
-    explicit VlProfileRec(Barrier) {
-        m_type = TYPE_BARRIER;
-        m_mtaskId = 0;
-        m_predictTime = 0;
-        m_startTime = 0;
-        m_endTime = 0;
-        m_cpu = getcpu();
-    }
+    VlProfileRec() = default;
+    explicit VlProfileRec(Barrier) { m_cpu = getcpu(); }
    void startRecord(vluint64_t time, uint32_t mtask, uint32_t predict) {
        m_type = VlProfileRec::TYPE_MTASK_RUN;
        m_mtaskId = mtask;
@@ -166,7 +168,7 @@ public:

 class VlThreadPool;

-class VlWorkerThread {
+class VlWorkerThread final {
 private:
    // TYPES
    struct ExecRec {
@@ -174,13 +176,13 @@ private:
        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) {}
+            : m_fnp{nullptr}
+            , m_sym{nullptr}
+            , 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
@@ -234,7 +236,7 @@ public:
    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym) {
        bool notify;
        {
-            VerilatedLockGuard lk(m_mutex);
+            const VerilatedLockGuard lk(m_mutex);
            m_ready.emplace_back(fnp, evenCycle, sym);
            m_ready_size.fetch_add(1, std::memory_order_relaxed);
            notify = m_waiting;
@@ -245,7 +247,7 @@ public:
    static void startWorker(VlWorkerThread* workerp);
 };

-class VlThreadPool {
+class VlThreadPool final {
    // TYPES
    typedef std::vector<VlProfileRec> ProfileTrace;
    typedef std::set<ProfileTrace*> ProfileSet;
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -40,7 +40,7 @@
 // Threaded tracing

 // A simple synchronized first in first out queue
-template <class T> class VerilatedThreadQueue {
+template <class T> class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
 private:
    VerilatedMutex m_mutex;  // Protects m_queue
    std::condition_variable_any m_cv;
@@ -73,8 +73,8 @@ public:

    // Non blocking get
    bool tryGet(T& result) {
-        VerilatedLockGuard lockGuard(m_mutex);
-        if (m_queue.empty()) { return false; }
+        const VerilatedLockGuard lockGuard(m_mutex);
+        if (m_queue.empty()) return false;
        result = m_queue.front();
        m_queue.pop_front();
        return true;
@@ -83,11 +83,11 @@ public:

 // 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 {
+class VerilatedTraceCommand final {
 public:
    // These must all fit in 4 bit at the moment, as the tracing routines
    // pack parameters in the top bits.
-    enum {
+    enum : vluint8_t {
        CHG_BIT_0 = 0x0,
        CHG_BIT_1 = 0x1,
        CHG_CDATA = 0x2,
@@ -95,7 +95,6 @@ public:
        CHG_IDATA = 0x4,
        CHG_QDATA = 0x5,
        CHG_WDATA = 0x6,
-        CHG_FLOAT = 0x7,
        CHG_DOUBLE = 0x8,
        // TODO: full..
        TIME_CHANGE = 0xd,
@@ -105,22 +104,45 @@ public:
 };
 #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:
+template <class T_Derived> class VerilatedTrace VL_NOT_FINAL {
+public:
    //=========================================================================
    // Generic tracing internals

+    typedef void (*initCb_t)(void*, T_Derived*, uint32_t);  // Type of init callbacks
+    typedef void (*dumpCb_t)(void*, T_Derived*);  // Type of all but init callbacks
+
+private:
+    struct CallbackRecord {
+        // Note: would make these fields const, but some old STL implementations
+        // (the one in Ubuntu 14.04 with GCC 4.8.4 in particular) use the
+        // assignment operator on inserting into collections, so they don't work
+        // with const fields...
+        union {
+            initCb_t m_initCb;  // The callback function
+            dumpCb_t m_dumpCb;  // The callback function
+        };
+        void* m_userp;  // The user pointer to pass to the callback (the symbol table)
+        CallbackRecord(initCb_t cb, void* userp)
+            : m_initCb{cb}
+            , m_userp{userp} {}
+        CallbackRecord(dumpCb_t cb, void* userp)
+            : m_dumpCb{cb}
+            , m_userp{userp} {}
+    };
+
    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
+    std::vector<CallbackRecord> m_initCbs;  ///< Routines to initialize traciong
+    std::vector<CallbackRecord> m_fullCbs;  ///< Routines to perform full dump
+    std::vector<CallbackRecord> m_chgCbs;  ///< Routines to perform incremental dump
+    std::vector<CallbackRecord> m_cleanupCbs;  ///< Routines to call at the end of dump
    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
@@ -130,10 +152,17 @@ private:
    double m_timeRes;  ///< Time resolution (ns/ms etc)
    double m_timeUnit;  ///< Time units (ns/ms etc)

+    void addCallbackRecord(std::vector<CallbackRecord>& cbVec, CallbackRecord& cbRec);
+
    // 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); }

+    // Flush any remaining data for this file
+    static void onFlush(void* selfp) VL_MT_UNSAFE_ONE;
+    // Close the file on termination
+    static void onExit(void* selfp) VL_MT_UNSAFE_ONE;
+
 #ifdef VL_TRACE_THREADED
    // Number of total trace buffers that have been allocated
    vluint32_t m_numTraceBuffers;
@@ -187,14 +216,13 @@ protected:
    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; }
+    bool isScopeEscape(char c) { return c != '\f' && (isspace(c) || c == m_scopeEscape); }
    /// Character that splits scopes.  Note whitespace are ALWAYS escapes.
    char scopeEscape() { return m_scopeEscape; }

@@ -209,8 +237,8 @@ protected:

    // 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; }
+    virtual bool preFullDump() = 0;
+    virtual bool preChangeDump() = 0;

 public:
    //=========================================================================
@@ -232,13 +260,13 @@ public:
    //=========================================================================
    // Non-hot path internal interface to Verilator generated code

-    typedef void (*callback_t)(T_Derived* tracep, void* userthis, vluint32_t code);
+    void addInitCb(initCb_t cb, void* userp) VL_MT_UNSAFE_ONE;
+    void addFullCb(dumpCb_t cb, void* userp) VL_MT_UNSAFE_ONE;
+    void addChgCb(dumpCb_t cb, void* userp) VL_MT_UNSAFE_ONE;
+    void addCleanupCb(dumpCb_t cb, void* userp) VL_MT_UNSAFE_ONE;

    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;
@@ -261,7 +289,6 @@ public:
    // 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; }
@@ -273,7 +300,6 @@ public:
    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
@@ -319,14 +345,6 @@ public:
        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;
@@ -374,10 +392,6 @@ public:
            }
        }
    }
-    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);
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -19,6 +19,7 @@

 // clang-format off

+#ifndef VL_CPPCHECK
 #ifndef VL_DERIVED_T
 # error "This file should be included in trace format implementations"
 #endif
@@ -39,14 +40,14 @@
 // Static utility functions

 static double timescaleToDouble(const char* unitp) {
-    char* endp;
+    char* endp = nullptr;
    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 's': value *= 1e0; break;
    case 'm': value *= 1e-3; break;
    case 'u': value *= 1e-6; break;
    case 'n': value *= 1e-9; break;
@@ -69,35 +70,10 @@ static std::string doubleToTimescale(double value) {
    else if (value >= 1e-18) { suffixp = "as"; value *= 1e18; }
    // clang-format on
    char valuestr[100];
-    sprintf(valuestr, "%3.0f%s", value, suffixp);
+    sprintf(valuestr, "%0.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
@@ -196,11 +172,6 @@ template <> void VerilatedTrace<VL_DERIVED_T>::workerThreadMain() {
                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));
@@ -224,13 +195,14 @@ template <> void VerilatedTrace<VL_DERIVED_T>::workerThreadMain() {
                shutdown = true;
                break;

-                //===
-                // Unknown command
-            default:
+            //===
+            // Unknown command
+            default: {  // LCOV_EXCL_START
                VL_TRACE_THREAD_DEBUG("Command UNKNOWN");
                VL_PRINTF_MT("Trace command: 0x%08x\n", cmd);
                VL_FATAL_MT(__FILE__, __LINE__, "", "Unknown trace command");
                break;
+            }  // LCOV_EXCL_STOP
            }

            // The above switch will execute 'continue' when necessary,
@@ -287,22 +259,37 @@ template <> void VerilatedTrace<VL_DERIVED_T>::flush() {
 #endif
 }

+//=============================================================================
+// Callbacks to run on global events
+
+template <> void VerilatedTrace<VL_DERIVED_T>::onFlush(void* selfp) {
+    // Note this calls 'flush' on the derived class
+    reinterpret_cast<VL_DERIVED_T*>(selfp)->flush();
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::onExit(void* selfp) {
+    // Note this calls 'close' on the derived class
+    reinterpret_cast<VL_DERIVED_T*>(selfp)->close();
+}
+
 //=============================================================================
 // 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)
+    : m_sigs_oldvalp{nullptr}
+    , 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)
+, m_numTraceBuffers { 0 }
 #endif
 {
    set_time_unit(Verilated::timeunitString());
@@ -310,11 +297,9 @@ VerilatedTrace<VL_DERIVED_T>::VerilatedTrace()
 }

 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();
-    }
+    if (m_sigs_oldvalp) VL_DO_CLEAR(delete[] m_sigs_oldvalp, m_sigs_oldvalp = nullptr);
+    Verilated::removeFlushCb(VerilatedTrace<VL_DERIVED_T>::onFlush, this);
+    Verilated::removeExitCb(VerilatedTrace<VL_DERIVED_T>::onExit, this);
 #ifdef VL_TRACE_THREADED
    close();
 #endif
@@ -334,11 +319,12 @@ template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
    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);
+    // Call all initialize callbacks, which will:
+    // - Call decl* for each signal
+    // - Store the base code
+    for (vluint32_t i = 0; i < m_initCbs.size(); ++i) {
+        const CallbackRecord& cbr = m_initCbs[i];
+        cbr.m_initCb(cbr.m_userp, self(), nextCode());
    }

    if (expectedCodes && nextCode() != expectedCodes) {
@@ -350,6 +336,10 @@ template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
    // holding previous signal values.
    if (!m_sigs_oldvalp) m_sigs_oldvalp = new vluint32_t[nextCode()];

+    // Set callback so flush/abort will flush this file
+    Verilated::addFlushCb(VerilatedTrace<VL_DERIVED_T>::onFlush, this);
+    Verilated::addExitCb(VerilatedTrace<VL_DERIVED_T>::onExit, this);
+
 #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
@@ -384,10 +374,6 @@ 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

@@ -409,12 +395,12 @@ template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const std::st

 template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
    m_assertOne.check();
-    if (VL_UNLIKELY(m_timeLastDump && timeui <= m_timeLastDump)) {
+    if (VL_UNCOVERABLE(m_timeLastDump && timeui <= m_timeLastDump)) {  // LCOV_EXCL_START
        VL_PRINTF_MT("%%Warning: previous dump at t=%" VL_PRI64 "u, requesting t=%" VL_PRI64
                     "u, dump call ignored\n",
                     m_timeLastDump, timeui);
        return;
-    }
+    }  // LCOV_EXCL_STOP
    m_timeLastDump = timeui;

    Verilated::quiesce();
@@ -452,17 +438,22 @@ template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
    // 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);
+        for (vluint32_t i = 0; i < m_fullCbs.size(); ++i) {
+            const CallbackRecord& cbr = m_fullCbs[i];
+            cbr.m_dumpCb(cbr.m_userp, self());
        }
    } 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);
+        for (vluint32_t i = 0; i < m_chgCbs.size(); ++i) {
+            const CallbackRecord& cbr = m_chgCbs[i];
+            cbr.m_dumpCb(cbr.m_userp, self());
        }
    }

+    for (vluint32_t i = 0; i < m_cleanupCbs.size(); ++i) {
+        const CallbackRecord& cbr = m_cleanupCbs[i];
+        cbr.m_dumpCb(cbr.m_userp, self());
+    }
+
 #ifdef VL_TRACE_THREADED
    if (VL_LIKELY(bufferp)) {
        // Mark end of the trace buffer we just filled
@@ -481,17 +472,32 @@ template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
 // 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 {
+void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>& cbVec,
+                                                     CallbackRecord& cbRec) {
    m_assertOne.check();
-    if (VL_UNLIKELY(timeLastDump() != 0)) {
+    if (VL_UNCOVERABLE(timeLastDump() != 0)) {  // LCOV_EXCL_START
        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);
+    }  // LCOV_EXCL_STOP
+    cbVec.push_back(cbRec);
+}
+
+template <> void VerilatedTrace<VL_DERIVED_T>::addInitCb(initCb_t cb, void* userp) {
+    CallbackRecord cbr(cb, userp);
+    addCallbackRecord(m_initCbs, cbr);
+}
+template <> void VerilatedTrace<VL_DERIVED_T>::addFullCb(dumpCb_t cb, void* userp) {
+    CallbackRecord cbr(cb, userp);
+    addCallbackRecord(m_fullCbs, cbr);
+}
+template <> void VerilatedTrace<VL_DERIVED_T>::addChgCb(dumpCb_t cb, void* userp) {
+    CallbackRecord cbr(cb, userp);
+    addCallbackRecord(m_chgCbs, cbr);
+}
+template <> void VerilatedTrace<VL_DERIVED_T>::addCleanupCb(dumpCb_t cb, void* userp) {
+    CallbackRecord cbr(cb, userp);
+    addCallbackRecord(m_cleanupCbs, cbr);
 }

 //=========================================================================
@@ -537,12 +543,6 @@ void VerilatedTrace<VL_DERIVED_T>::fullWData(vluint32_t* oldp, const WData* newv
    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;
@@ -555,7 +555,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::fullDouble(vluint32_t* oldp, doub
 // 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) {
+static inline 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);
@@ -577,7 +577,7 @@ inline static void cvtCDataToStr(char* dstp, CData value) {
 #endif
 }

-inline static void cvtSDataToStr(char* dstp, SData value) {
+static inline 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
@@ -613,7 +613,7 @@ inline static void cvtSDataToStr(char* dstp, SData value) {
 #endif
 }

-inline static void cvtIDataToStr(char* dstp, IData value) {
+static inline 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
@@ -632,9 +632,46 @@ inline static void cvtIDataToStr(char* dstp, IData value) {
 #endif
 }

-inline static void cvtQDataToStr(char* dstp, QData value) {
+static inline void cvtQDataToStr(char* dstp, QData value) {
    cvtIDataToStr(dstp, value >> 32);
    cvtIDataToStr(dstp + 32, value);
 }

 #define cvtEDataToStr cvtIDataToStr
+
+//=============================================================================
+
+#ifdef VERILATED_VCD_TEST
+
+void verilated_trace_imp_selftest() {
+#define SELF_CHECK(got, exp) \
+    do { \
+        if ((got) != (exp)) VL_FATAL_MT(__FILE__, __LINE__, "", "%Error: selftest\n"); \
+    } while (0)
+
+#define SELF_CHECK_TS(scale) \
+    SELF_CHECK(doubleToTimescale(timescaleToDouble(scale)), std::string{scale});
+    SELF_CHECK_TS("1s");
+    SELF_CHECK_TS("100ms");
+    SELF_CHECK_TS("10ms");
+    SELF_CHECK_TS("1ms");
+    SELF_CHECK_TS("100us");
+    SELF_CHECK_TS("10us");
+    SELF_CHECK_TS("1us");
+    SELF_CHECK_TS("100ns");
+    SELF_CHECK_TS("10ns");
+    SELF_CHECK_TS("1ns");
+    SELF_CHECK_TS("100ps");
+    SELF_CHECK_TS("10ps");
+    SELF_CHECK_TS("1ps");
+    SELF_CHECK_TS("100fs");
+    SELF_CHECK_TS("10fs");
+    SELF_CHECK_TS("1fs");
+    SELF_CHECK_TS("100as");
+    SELF_CHECK_TS("10as");
+    SELF_CHECK_TS("1as");
+}
+
+#endif
+
+#endif  // VL_CPPCHECK
@@ -1,497 +0,0 @@
-// -*- mode: C++; c-file-style: "cc-mode" -*-
-//*************************************************************************
-// DESCRIPTION: Verilator: pre-C++11 replacements for std::unordered_set
-//                         and std::unordered_map.
-//
-// Code available from: https://verilator.org
-//
-//*************************************************************************
-//
-// 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
-//
-//*************************************************************************
-
-//*************************************************************************
-// This file has clones of the std::unordered_set and std::unordered_map
-// hash table types. They are here so that Verilator can use hash tables
-// in pre-C++11 compilers, and the same client code can link against the
-// std:: types when they are available.
-//
-// The implementations in this file do not implement the complete APIs
-// of the std:: types. Nor are they correct in every detail,
-// notably, the const_iterators do not enforce constness. We can extend
-// these implementations to cover more of the std API as needed.
-//
-// TODO: In the future, when Verilator requires C++11 to compile,
-//       remove this entire file and switch to the std:: types.
-//
-//*************************************************************************
-
-#ifndef _V3_UNORDERED_SET_MAP_H_
-#define _V3_UNORDERED_SET_MAP_H_
-
-#include "verilatedos.h"
-
-#include <list>
-#include <stdexcept>
-#include <string>
-
-// Abstract 'vl_hash' and 'vl_equal_to' templates.
-template <typename T> struct vl_hash { size_t operator()(const T& k) const; };
-
-template <typename T> struct vl_equal_to { bool operator()(const T& a, const T& b) const; };
-
-// Specializations of 'vl_hash' and 'vl_equal_to'.
-inline size_t vl_hash_bytes(const void* vbufp, size_t nbytes) {
-    const vluint8_t* bufp = static_cast<const vluint8_t*>(vbufp);
-    size_t hash = 0;
-    for (size_t i = 0; i < nbytes; i++) {
-        hash = bufp[i] + 31U * hash;  // the K&R classic!
-    }
-    return hash;
-}
-
-template <> inline size_t vl_hash<unsigned int>::operator()(const unsigned int& k) const {
-    return k;
-}
-
-template <>
-inline bool vl_equal_to<unsigned int>::operator()(const unsigned int& a,
-                                                  const unsigned int& b) const {
-    return a == b;
-}
-
-template <> inline size_t vl_hash<std::string>::operator()(const std::string& k) const {
-    return vl_hash_bytes(k.data(), k.size());
-}
-
-template <>
-inline bool vl_equal_to<std::string>::operator()(const std::string& a,
-                                                 const std::string& b) const {
-    // Don't scan the strings if the sizes are different.
-    if (a.size() != b.size()) return false;
-    return (0 == a.compare(b));  // Must scan.
-}
-
-template <typename T> struct vl_hash<T*> {
-    size_t operator()(T* kp) const {
-        return ((sizeof(size_t) == sizeof(kp)) ? reinterpret_cast<size_t>(kp)
-                                               : vl_hash_bytes(&kp, sizeof(kp)));
-    }
-};
-
-template <typename T> struct vl_equal_to<T*> {
-    bool operator()(T* ap, T* bp) const { return ap == bp; }
-};
-
-//===================================================================
-//
-/// Functional clone of the std::unordered_set hash table.
-template <class T_Key, class T_Hash = vl_hash<T_Key>, class T_Equal = vl_equal_to<T_Key> >
-class vl_unordered_set {
-public:
-    // TYPES
-    typedef std::list<T_Key> Bucket;
-    enum RehashType { GROW, SHRINK };
-
-    template <class KK, class VV, class HH, class EQ> friend class vl_unordered_map;
-
-    class iterator {
-    protected:
-        // MEMBERS
-        size_t m_bucketIdx;  //  Bucket this iterator points into
-        typename Bucket::iterator m_bit;  // Bucket-local iterator
-        const vl_unordered_set* m_setp;  // The containing set
-
-    public:
-        // CONSTRUCTORS
-        iterator(size_t bucketIdx, typename Bucket::iterator bit, const vl_unordered_set* setp)
-            : m_bucketIdx(bucketIdx)
-            , m_bit(bit)
-            , m_setp(setp) {}
-
-        // METHODS
-        const T_Key& operator*() const { return *m_bit; }
-        // This should really be 'const T_Key*' type for unordered_set,
-        // however this iterator is shared with unordered_map whose
-        // operator-> returns a non-const ValueType*, so keep this
-        // non-const to avoid having to define a whole separate iterator
-        // for unordered_map.
-        T_Key* operator->() const { return &(*m_bit); }
-        bool operator==(const iterator& other) const {
-            return ((m_bucketIdx == other.m_bucketIdx) && (m_bit == other.m_bit));
-        }
-        bool operator!=(const iterator& other) const { return (!this->operator==(other)); }
-        void advanceUntilValid() {
-            while (true) {
-                if (m_bit != m_setp->m_bucketsp[m_bucketIdx].end()) {
-                    // Valid iterator in this bucket; we're done.
-                    return;
-                }
-
-                // Try the next bucket?
-                m_bucketIdx++;
-                if (m_bucketIdx == m_setp->numBuckets()) {
-                    // Ran past the end of buckets, set to end().
-                    *this = m_setp->end();
-                    return;
-                }
-                m_bit = m_setp->m_bucketsp[m_bucketIdx].begin();
-            }
-        }
-        void operator++() {
-            ++m_bit;
-            advanceUntilValid();
-        }
-
-        typename Bucket::iterator bit() const { return m_bit; }
-    };
-
-    // TODO: there's no real const enforcement on the 'const_iterator'.
-    typedef iterator const_iterator;
-
-private:
-    // MEMBERS
-    size_t m_numElements;  //  Number of entries present.
-    size_t m_log2Buckets;  //  Log-base-2 of the number of buckets.
-    mutable Bucket* m_bucketsp;  //  Hash table buckets. May be NULL;
-    //                          //   we'll allocate it on the fly when
-    //                          //   the first entries are created.
-    Bucket m_emptyBucket;  //  A fake bucket, used to construct end().
-    T_Hash m_hash;  //  Hash function provider.
-    T_Equal m_equal;  //  Equal-to function provider.
-
-public:
-    // CONSTRUCTORS
-    vl_unordered_set()
-        : m_numElements(0)
-        , m_log2Buckets(initLog2Buckets())
-        , m_bucketsp(NULL)
-        , m_hash()
-        , m_equal() {}
-
-    vl_unordered_set(const vl_unordered_set& other)
-        : m_numElements(other.m_numElements)
-        , m_log2Buckets(other.m_log2Buckets)
-        , m_bucketsp(NULL)
-        , m_hash()
-        , m_equal() {
-        if (other.m_bucketsp) {
-            m_bucketsp = new Bucket[numBuckets()];
-            for (size_t i = 0; i < numBuckets(); i++) m_bucketsp[i] = other.m_bucketsp[i];
-        }
-    }
-    ~vl_unordered_set() { VL_DO_DANGLING(delete[] m_bucketsp, m_bucketsp); }
-
-    vl_unordered_set& operator=(const vl_unordered_set& other) {
-        if (this != &other) {
-            clear();
-            delete[] m_bucketsp;
-            m_numElements = other.m_numElements;
-            m_log2Buckets = other.m_log2Buckets;
-            if (other.m_bucketsp) {
-                m_bucketsp = new Bucket[numBuckets()];
-                for (size_t i = 0; i < numBuckets(); i++) m_bucketsp[i] = other.m_bucketsp[i];
-            } else {
-                m_bucketsp = NULL;
-            }
-        }
-        return *this;
-    }
-
-    // METHODS
-    static size_t initLog2Buckets() { return 4; }
-
-    iterator begin() {
-        if (m_numElements) {
-            initBuckets();
-            iterator result = iterator(0, m_bucketsp[0].begin(), this);
-            result.advanceUntilValid();
-            return result;
-        }
-        return end();
-    }
-    const_iterator begin() const {
-        if (m_numElements) {
-            initBuckets();
-            const_iterator result = iterator(0, m_bucketsp[0].begin(), this);
-            result.advanceUntilValid();
-            return result;
-        }
-        return end();
-    }
-    const_iterator end() const {
-        return iterator(VL_ULL(0xFFFFFFFFFFFFFFFF), const_cast<Bucket&>(m_emptyBucket).begin(),
-                        this);
-    }
-
-    bool empty() const { return m_numElements == 0; }
-
-    size_t size() const { return m_numElements; }
-
-    size_t count(const T_Key& key) const { return (find(key) == end()) ? 0 : 1; }
-
-    size_t hashToBucket(size_t hashVal) const { return hashToBucket(hashVal, m_log2Buckets); }
-    static size_t hashToBucket(size_t hashVal, unsigned log2Buckets) {
-        // Fibonacci hashing, see
-        // https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization
-        // -that-the-world-forgot-or-a-better-alternative-to-integer-modulo/
-        //
-        // * The magic numbers below are UINT_MAX/phi where phi is the
-        //   golden ratio number (1.618...)  for either 64- or 32-bit
-        //   values of UINT_MAX.
-        //
-        // * Fibonacci hashing mixes the result of the client's hash
-        //   function further. This permits the use of very fast client
-        //   hash funcs (like just returning the int or pointer value as
-        //   is!) and tolerates crappy client hash functions pretty well.
-        size_t mult
-            = hashVal * ((sizeof(size_t) == 8) ? VL_ULL(11400714819323198485) : 2654435769lu);
-        size_t result = (mult >> (((sizeof(size_t) == 8) ? 64 : 32) - log2Buckets));
-        return result;
-    }
-
-    iterator find_internal(const T_Key& key, size_t& bucketIdxOut) {
-        size_t hash = m_hash.operator()(key);
-        bucketIdxOut = hashToBucket(hash);
-        initBuckets();
-        Bucket* bucketp = &m_bucketsp[bucketIdxOut];
-
-        for (typename Bucket::iterator it = bucketp->begin(); it != bucketp->end(); ++it) {
-            if (m_equal.operator()(*it, key)) return iterator(bucketIdxOut, it, this);
-        }
-        return end();
-    }
-
-    const_iterator find(const T_Key& key) const {
-        size_t bucketIdx;
-        return const_cast<vl_unordered_set*>(this)->find_internal(key, bucketIdx);
-    }
-
-    iterator find(const T_Key& key) {
-        size_t bucketIdx;
-        return find_internal(key, bucketIdx);
-    }
-
-    std::pair<iterator, bool> insert(const T_Key& val) {
-        size_t bucketIdx;
-        iterator existIt = find_internal(val, bucketIdx);
-        if (existIt != end()) {
-            // Collision with existing element.
-            //
-            // An element may be inserted only if it is not
-            // equal to an existing element. So fail.
-            return std::pair<iterator, bool>(end(), false);
-        }
-
-        // No collision, so insert it.
-        m_numElements++;
-
-        m_bucketsp[bucketIdx].push_front(val);
-
-        // Compute result iterator. This pointer will be valid
-        // if we don't rehash:
-        iterator result_it(bucketIdx, m_bucketsp[bucketIdx].begin(), this);
-
-        if (needToRehash(GROW)) {
-            rehash(GROW);
-            // ... since we rehashed, do a lookup to get the result iterator.
-            result_it = find(val);
-        }
-
-        return std::pair<iterator, bool>(result_it, true);
-    }
-
-    iterator erase(iterator it) {
-        iterator next_it = it;
-        ++next_it;
-        erase(*it);
-        return next_it;
-    }
-
-    size_t erase(const T_Key& key) {
-        size_t bucketIdx;
-        iterator it = find_internal(key, bucketIdx);
-        if (it != end()) {
-            m_bucketsp[bucketIdx].erase(it.bit());
-            m_numElements--;
-            // Rehashing to handle a shrinking data set is important
-            // for the Scoreboard in V3Partition, which begins tracking
-            // a huge number of vertices and then tracks a successively
-            // smaller number over time.
-            if (needToRehash(SHRINK)) rehash(SHRINK);
-            return 1;
-        }
-        return 0;
-    }
-
-    void clear() {
-        if (m_bucketsp) {
-            delete[] m_bucketsp;
-            m_bucketsp = NULL;
-        }
-        m_numElements = 0;
-        m_log2Buckets = initLog2Buckets();
-    }
-
-private:
-    size_t numBuckets() const { return (VL_ULL(1) << m_log2Buckets); }
-
-    Bucket* getBucket(size_t idx) {
-        initBuckets();
-        return &m_bucketsp[idx];
-    }
-
-    void initBuckets() const {
-        if (!m_bucketsp) m_bucketsp = new Bucket[numBuckets()];
-    }
-
-    bool needToRehash(RehashType rt) const {
-        if (rt == GROW) {
-            return ((4 * numBuckets()) < m_numElements);
-        } else {
-            return (numBuckets() > (4 * m_numElements));
-        }
-    }
-
-    void rehash(RehashType rt) {
-        size_t new_log2Buckets;
-        if (rt == GROW) {
-            new_log2Buckets = m_log2Buckets + 2;
-        } else {
-            if (m_log2Buckets <= 4) {
-                // On shrink, saturate m_log2Buckets at its
-                // initial size of 2^4 == 16 buckets. Don't risk
-                // underflowing!
-                return;
-            }
-            new_log2Buckets = m_log2Buckets - 2;
-        }
-
-        size_t new_num_buckets = VL_ULL(1) << new_log2Buckets;
-        Bucket* new_bucketsp = new Bucket[new_num_buckets];
-
-        for (size_t i = 0; i < numBuckets(); i++) {
-            while (!m_bucketsp[i].empty()) {
-                typename Bucket::iterator bit = m_bucketsp[i].begin();
-                size_t hash = m_hash.operator()(*bit);
-                size_t new_idx = hashToBucket(hash, new_log2Buckets);
-                // Avoid mallocing one list elem and freeing another;
-                // splice just moves it over.
-                new_bucketsp[new_idx].splice(new_bucketsp[new_idx].begin(), m_bucketsp[i], bit);
-            }
-        }
-
-        delete[] m_bucketsp;
-        m_bucketsp = new_bucketsp;
-        m_log2Buckets = new_log2Buckets;
-    }
-};
-
-//===================================================================
-//
-/// Functional clone of the std::unordered_map hash table.
-template <class T_Key, class T_Value, class T_Hash = vl_hash<T_Key>,
-          class T_Equal = vl_equal_to<T_Key> >
-class vl_unordered_map {
-private:
-    // TYPES
-    typedef std::pair<T_Key, T_Value> KeyValPair;
-
-    class KeyHash {
-    private:
-        T_Hash key_hash;
-
-    public:
-        KeyHash() {}
-        size_t operator()(const KeyValPair& kv_pair) const {
-            return key_hash.operator()(kv_pair.first);
-        }
-    };
-
-    class KeyEqual {
-    private:
-        T_Equal key_eq;
-
-    public:
-        KeyEqual() {}
-        bool operator()(const KeyValPair& kv_a, const KeyValPair& kv_b) const {
-            return key_eq.operator()(kv_a.first, kv_b.first);
-        }
-    };
-
-    // MEMBERS
-    typedef vl_unordered_set<KeyValPair, KeyHash, KeyEqual> MapSet;
-    MapSet m_set;  // Wrap this vl_unordered_set which holds all state.
-
-public:
-    // CONSTRUCTORS
-    vl_unordered_map() {}
-    ~vl_unordered_map() {}
-
-    typedef typename MapSet::iterator iterator;
-    typedef typename MapSet::const_iterator const_iterator;
-
-    // METHODS
-    iterator begin() { return m_set.begin(); }
-    const_iterator begin() const { return m_set.begin(); }
-    const_iterator end() const { return m_set.end(); }
-    bool empty() const { return m_set.empty(); }
-    iterator find(const T_Key& k) {
-        // We can't assume that T_Value() is defined.
-        // ie, this does not work:
-        //    return m_set.find(std::make_pair(k, T_Value()));
-
-        // So, do this instead:
-        T_Hash mapHash;
-        T_Equal mapEq;
-        size_t hash = mapHash.operator()(k);
-        size_t bucketIdxOut = m_set.hashToBucket(hash);
-        typename MapSet::Bucket* bucketp = m_set.getBucket(bucketIdxOut);
-
-        for (typename MapSet::Bucket::iterator it = bucketp->begin(); it != bucketp->end(); ++it) {
-            if (mapEq.operator()(it->first, k)) return iterator(bucketIdxOut, it, &m_set);
-        }
-        return end();
-    }
-    const_iterator find(const T_Key& k) const {
-        return const_cast<vl_unordered_map*>(this)->find(k);
-    }
-    std::pair<iterator, bool> insert(const KeyValPair& val) { return m_set.insert(val); }
-    iterator erase(iterator it) { return m_set.erase(it); }
-    size_t erase(const T_Key& k) {
-        iterator it = find(k);
-        if (it == end()) return 0;
-        m_set.erase(it);
-        return 1;
-    }
-    T_Value& operator[](const T_Key& k) {
-        // Here we can assume T_Value() is defined, as
-        // std::unordered_map::operator[] relies on it too.
-        KeyValPair dummy = std::make_pair(k, T_Value());
-        iterator it = m_set.find(dummy);
-        if (it == m_set.end()) it = m_set.insert(dummy).first;
-        // For the 'set', it's generally not safe to modify
-        // the value after deref. For the 'map' though, we know
-        // it's safe to modify the value field and we can allow it:
-        return it->second;
-    }
-    T_Value& at(const T_Key& k) {
-        iterator it = find(k);
-        if (it == end()) { throw std::out_of_range("sorry"); }
-        return it->second;
-    }
-    const T_Value& at(const T_Key& k) const {
-        iterator it = find(k);
-        if (it == end()) { throw std::out_of_range("sorry"); }
-        return it->second;
-    }
-    void clear() { m_set.clear(); }
-    size_t size() const { return m_set.size(); }
-};
-
-#endif
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 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.
@@ -27,7 +27,6 @@
 #include <cerrno>
 #include <ctime>
 #include <fcntl.h>
-#include <sys/stat.h>

 #if defined(_WIN32) && !defined(__MINGW32__) && !defined(__CYGWIN__)
 # include <io.h>
@@ -35,8 +34,6 @@
 # include <unistd.h>
 #endif

-#include "verilated_intrinsics.h"
-
 // SPDIFF_ON

 #ifndef O_LARGEFILE  // For example on WIN32
@@ -54,13 +51,14 @@
 // This size comes form VCD allowing use of printable ASCII characters between
 // '!' and '~' inclusive, which are a total of 94 different values. Encoding a
 // 32 bit code hence needs a maximum of ceil(log94(2**32-1)) == 5 bytes.
-#define VL_TRACE_MAX_VCD_CODE_SIZE 5  ///< Maximum length of a VCD string code
+constexpr unsigned VL_TRACE_MAX_VCD_CODE_SIZE = 5;  ///< Maximum length of a VCD string code
+
 // We use 8 bytes per code in a suffix buffer array.
 // 1 byte optional separator + VL_TRACE_MAX_VCD_CODE_SIZE bytes for code
 // + 1 byte '\n' + 1 byte suffix size. This luckily comes out to a power of 2,
 // meaning the array can be aligned such that entries never straddle multiple
 // cache-lines.
-#define VL_TRACE_SUFFIX_ENTRY_SIZE 8  ///< Size of a suffix entry
+constexpr unsigned VL_TRACE_SUFFIX_ENTRY_SIZE = 8;  ///< Size of a suffix entry

 //=============================================================================
 // Specialization of the generics for this trace format
@@ -69,47 +67,6 @@
 #include "verilated_trace_imp.cpp"
 #undef VL_DERIVED_T

-//=============================================================================
-// VerilatedVcdImp
-/// Base class to hold some static state
-/// This is an internally used class
-
-class VerilatedVcdSingleton {
-private:
-    typedef std::vector<VerilatedVcd*> VcdVec;
-    struct Singleton {
-        VerilatedMutex s_vcdMutex;  ///< Protect the singleton
-        VcdVec s_vcdVecp VL_GUARDED_BY(s_vcdMutex);  ///< List of all created traces
-    };
-    static Singleton& singleton() {
-        static Singleton s;
-        return s;
-    }
-
-public:
-    static void pushVcd(VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-        VerilatedLockGuard lock(singleton().s_vcdMutex);
-        singleton().s_vcdVecp.push_back(vcdp);
-    }
-    static void removeVcd(const VerilatedVcd* vcdp) VL_EXCLUDES(singleton().s_vcdMutex) {
-        VerilatedLockGuard lock(singleton().s_vcdMutex);
-        VcdVec::iterator pos
-            = find(singleton().s_vcdVecp.begin(), singleton().s_vcdVecp.end(), vcdp);
-        if (pos != singleton().s_vcdVecp.end()) { singleton().s_vcdVecp.erase(pos); }
-    }
-    static void flush_all() VL_EXCLUDES(singleton().s_vcdMutex) VL_MT_UNSAFE_ONE {
-        // Thread safety: Although this function is protected by a mutex so
-        // perhaps in the future we can allow tracing in separate threads,
-        // vcdp->flush() assumes call from single thread
-        VerilatedLockGuard lock(singleton().s_vcdMutex);
-        for (VcdVec::const_iterator it = singleton().s_vcdVecp.begin();
-             it != singleton().s_vcdVecp.end(); ++it) {
-            VerilatedVcd* vcdp = *it;
-            vcdp->flush();
-        }
-    }
-};
-
 //=============================================================================
 //=============================================================================
 //=============================================================================
@@ -132,21 +89,15 @@ ssize_t VerilatedVcdFile::write(const char* bufp, ssize_t len) VL_MT_UNSAFE {
 //=============================================================================
 // Opening/Closing

-VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep)
-    : m_isOpen(false)
-    , m_rolloverMB(0)
-    , m_modDepth(0) {
+VerilatedVcd::VerilatedVcd(VerilatedVcdFile* filep) {
    // Not in header to avoid link issue if header is included without this .cpp file
-    m_fileNewed = (filep == NULL);
+    m_fileNewed = (filep == nullptr);
    m_filep = m_fileNewed ? new VerilatedVcdFile : filep;
-    m_namemapp = NULL;
-    m_evcd = false;
    m_wrChunkSize = 8 * 1024;
    m_wrBufp = new char[m_wrChunkSize * 8];
    m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
    m_writep = m_wrBufp;
-    m_wroteBytes = 0;
-    m_suffixesp = NULL;
+    m_suffixesp = nullptr;
 }

 void VerilatedVcd::open(const char* filename) {
@@ -155,13 +106,7 @@ void VerilatedVcd::open(const char* filename) {

    // Set member variables
    m_filename = filename;  // "" is ok, as someone may overload open
-    VerilatedVcdSingleton::pushVcd(this);

-    // SPDIFF_OFF
-    // Set callback so an early exit will flush us
-    Verilated::flushCb(&flush_all);
-
-    // SPDIFF_ON
    openNext(m_rolloverMB != 0);
    if (!isOpen()) return;

@@ -193,7 +138,9 @@ void VerilatedVcd::openNext(bool incFilename) {
                    name[pos - 2] = '0';
                    if ((++(name[pos - 3])) > '9') {
                        name[pos - 3] = '0';
-                        if ((++(name[pos - 4])) > '9') { name[pos - 4] = '0'; }
+                        if ((++(name[pos - 4])) > '9') {  //
+                            name[pos - 4] = '0';
+                        }
                    }
                }
            }
@@ -203,8 +150,8 @@ void VerilatedVcd::openNext(bool incFilename) {
        }
        m_filename = name;
    }
-    if (m_filename[0] == '|') {
-        assert(0);  // Not supported yet.
+    if (VL_UNCOVERABLE(m_filename[0] == '|')) {
+        assert(0);  // LCOV_EXCL_LINE // Not supported yet.
    } else {
        // cppcheck-suppress duplicateExpression
        if (!m_filep->open(m_filename)) {
@@ -219,7 +166,7 @@ void VerilatedVcd::openNext(bool incFilename) {
 }

 bool VerilatedVcd::preChangeDump() {
-    if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > m_rolloverMB)) { openNext(true); }
+    if (VL_UNLIKELY(m_rolloverMB && m_wroteBytes > m_rolloverMB)) openNext(true);
    return isOpen();
 }

@@ -241,19 +188,19 @@ void VerilatedVcd::makeNameMap() {
    // If no scope was specified, prefix everything with a "top"
    // This comes from user instantiations with no name - IE Vtop("").
    bool nullScope = false;
-    for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) {
-        const std::string& hiername = it->first;
+    for (const auto& i : *m_namemapp) {
+        const std::string& hiername = i.first;
        if (!hiername.empty() && hiername[0] == '\t') nullScope = true;
    }
    if (nullScope) {
        NameMap* newmapp = new NameMap;
-        for (NameMap::const_iterator it = m_namemapp->begin(); it != m_namemapp->end(); ++it) {
-            const std::string& hiername = it->first;
-            const std::string& decl = it->second;
+        for (const auto& i : *m_namemapp) {
+            const std::string& hiername = i.first;
+            const std::string& decl = i.second;
            std::string newname = std::string("top");
            if (hiername[0] != '\t') newname += ' ';
            newname += hiername;
-            newmapp->insert(std::make_pair(newname, decl));
+            newmapp->emplace(newname, decl);
        }
        deleteNameMap();
        m_namemapp = newmapp;
@@ -261,15 +208,14 @@ void VerilatedVcd::makeNameMap() {
 }

 void VerilatedVcd::deleteNameMap() {
-    if (m_namemapp) VL_DO_CLEAR(delete m_namemapp, m_namemapp = NULL);
+    if (m_namemapp) VL_DO_CLEAR(delete m_namemapp, m_namemapp = nullptr);
 }

 VerilatedVcd::~VerilatedVcd() {
    close();
-    if (m_wrBufp) VL_DO_CLEAR(delete[] m_wrBufp, m_wrBufp = NULL);
+    if (m_wrBufp) VL_DO_CLEAR(delete[] m_wrBufp, m_wrBufp = nullptr);
    deleteNameMap();
-    if (m_filep && m_fileNewed) VL_DO_CLEAR(delete m_filep, m_filep = NULL);
-    VerilatedVcdSingleton::removeVcd(this);
+    if (m_filep && m_fileNewed) VL_DO_CLEAR(delete m_filep, m_filep = nullptr);
 }

 void VerilatedVcd::closePrev() {
@@ -337,7 +283,7 @@ void VerilatedVcd::bufferResize(vluint64_t minsize) {
        memcpy(m_wrBufp, oldbufp, m_writep - oldbufp);
        m_writep = m_wrBufp + (m_writep - oldbufp);
        m_wrFlushp = m_wrBufp + m_wrChunkSize * 6;
-        VL_DO_CLEAR(delete[] oldbufp, oldbufp = NULL);
+        VL_DO_CLEAR(delete[] oldbufp, oldbufp = nullptr);
    }
 }

@@ -358,13 +304,15 @@ void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
        if (got > 0) {
            wp += got;
            m_wroteBytes += got;
-        } else if (got < 0) {
-            if (errno != EAGAIN && errno != EINTR) {
+        } else if (VL_UNCOVERABLE(got < 0)) {
+            if (VL_UNCOVERABLE(errno != EAGAIN && errno != EINTR)) {
+                // LCOV_EXCL_START
                // write failed, presume error (perhaps out of disk space)
                std::string msg = std::string("VerilatedVcd::bufferFlush: ") + strerror(errno);
                VL_FATAL_MT("", 0, "", msg.c_str());
                closeErr();
                break;
+                // LCOV_EXCL_STOP
            }
        }
    }
@@ -399,7 +347,7 @@ void VerilatedVcd::printIndent(int level_change) {

 void VerilatedVcd::dumpHeader() {
    printStr("$version Generated by VerilatedVcd $end\n");
-    time_t time_str = time(NULL);
+    time_t time_str = time(nullptr);
    printStr("$date ");
    printStr(ctime(&time_str));
    printStr(" $end\n");
@@ -422,9 +370,9 @@ void VerilatedVcd::dumpHeader() {

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

        // Determine difference between the old and new names
        const char* hiername = hiernamestr.c_str();
@@ -455,13 +403,22 @@ void VerilatedVcd::dumpHeader() {
            if (*np == ' ') np++;
            if (*np == '\t') break;  // tab means signal name starts
            printIndent(1);
-            printStr("$scope module ");
+            // Find character after name end
+            const char* sp = np;
+            while (*sp && *sp != ' ' && *sp != '\t' && *sp != '\f') sp++;
+
+            if (*sp == '\f') {
+                printStr("$scope struct ");
+            } else {
+                printStr("$scope module ");
+            }
+
            for (; *np && *np != ' ' && *np != '\t'; np++) {
                if (*np == '[') {
                    printStr("(");
                } else if (*np == ']') {
                    printStr(")");
-                } else {
+                } else if (*np != '\f') {
                    *m_writep++ = *np;
                }
            }
@@ -565,7 +522,7 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
        decl += buf;
    }
    decl += " $end\n";
-    m_namemapp->insert(std::make_pair(hiername, decl));
+    m_namemapp->emplace(hiername, decl);
 }

 void VerilatedVcd::declBit(vluint32_t code, const char* name, bool array, int arraynum) {
@@ -583,9 +540,6 @@ void VerilatedVcd::declArray(vluint32_t code, const char* name, bool array, int
                             int lsb) {
    declare(code, name, "wire", array, arraynum, false, true, msb, lsb);
 }
-void VerilatedVcd::declFloat(vluint32_t code, const char* name, bool array, int arraynum) {
-    declare(code, name, "real", array, arraynum, false, false, 31, 0);
-}
 void VerilatedVcd::declDouble(vluint32_t code, const char* name, bool array, int arraynum) {
    declare(code, name, "real", array, arraynum, false, false, 63, 0);
 }
@@ -699,15 +653,6 @@ void VerilatedVcd::emitWData(vluint32_t code, const WData* newvalp, int bits) {
    finishLine(code, wp);
 }

-VL_ATTR_ALWINLINE
-void VerilatedVcd::emitFloat(vluint32_t code, float newval) {
-    char* wp = m_writep;
-    // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(wp, "r%.16g", static_cast<double>(newval));
-    wp += strlen(wp);
-    finishLine(code, wp);
-}
-
 VL_ATTR_ALWINLINE
 void VerilatedVcd::emitDouble(vluint32_t code, double newval) {
    char* wp = m_writep;
@@ -742,7 +687,7 @@ void VerilatedVcd::fullQuad(vluint32_t code, const vluint64_t newval, int bits)
    (*(reinterpret_cast<vluint64_t*>(oldp(code)))) = newval;
    *m_writep++ = 'b';
    for (int bit = bits - 1; bit >= 0; --bit) {
-        *m_writep++ = ((newval & (VL_ULL(1) << bit)) ? '1' : '0');
+        *m_writep++ = ((newval & (1ULL << bit)) ? '1' : '0');
    }
    *m_writep++ = ' ';
    m_writep = writeCode(m_writep, code);
@@ -764,7 +709,7 @@ void VerilatedVcd::fullArray(vluint32_t code, const vluint64_t* newval, int bits
    for (int word = 0; word < (((bits - 1) / 64) + 1); ++word) { oldp(code)[word] = newval[word]; }
    *m_writep++ = 'b';
    for (int bit = bits - 1; bit >= 0; --bit) {
-        *m_writep++ = ((newval[(bit / 64)] & (VL_ULL(1) << (bit & 0x3f))) ? '1' : '0');
+        *m_writep++ = ((newval[(bit / 64)] & (1ULL << (bit & 0x3f))) ? '1' : '0');
    }
    *m_writep++ = ' ';
    m_writep = writeCode(m_writep, code);
@@ -792,14 +737,13 @@ void VerilatedVcd::fullTriBus(vluint32_t code, const vluint32_t newval, const vl
    *m_writep++ = '\n';
    bufferCheck();
 }
-void VerilatedVcd::fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri,
+void VerilatedVcd::fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint64_t newtri,
                               int bits) {
    (*(reinterpret_cast<vluint64_t*>(oldp(code)))) = newval;
    (*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) = newtri;
    *m_writep++ = 'b';
    for (int bit = bits - 1; bit >= 0; --bit) {
-        *m_writep++
-            = "01zz"[((newval >> bit) & VL_ULL(1)) | (((newtri >> bit) & VL_ULL(1)) << VL_ULL(1))];
+        *m_writep++ = "01zz"[((newval >> bit) & 1ULL) | (((newtri >> bit) & 1ULL) << 1ULL)];
    }
    *m_writep++ = ' ';
    m_writep = writeCode(m_writep, code);
@@ -834,82 +778,55 @@ void VerilatedVcd::fullDouble(vluint32_t code, const double newval) {
    *m_writep++ = '\n';
    bufferCheck();
 }
-void VerilatedVcd::fullFloat(vluint32_t code, const float newval) {
-    // cppcheck-suppress invalidPointerCast
-    (*(reinterpret_cast<float*>(oldp(code)))) = newval;
-    // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(m_writep, "r%.16g", static_cast<double>(newval));
-    m_writep += strlen(m_writep);
-    *m_writep++ = ' ';
-    m_writep = writeCode(m_writep, code);
-    *m_writep++ = '\n';
-    bufferCheck();
-}
-void VerilatedVcd::fullBitX(vluint32_t code) {
-    *m_writep++ = 'x';
-    m_writep = writeCode(m_writep, code);
-    *m_writep++ = '\n';
-    bufferCheck();
-}
-void VerilatedVcd::fullBusX(vluint32_t code, int bits) {
-    *m_writep++ = 'b';
-    for (int bit = bits - 1; bit >= 0; --bit) *m_writep++ = 'x';
-    *m_writep++ = ' ';
-    m_writep = writeCode(m_writep, code);
-    *m_writep++ = '\n';
-    bufferCheck();
-}
-void VerilatedVcd::fullQuadX(vluint32_t code, int bits) { fullBusX(code, bits); }
-void VerilatedVcd::fullArrayX(vluint32_t code, int bits) { fullBusX(code, bits); }

 #endif  // VL_TRACE_VCD_OLD_API

 //======================================================================
-// Static members
-
-void VerilatedVcd::flush_all() VL_MT_UNSAFE_ONE { VerilatedVcdSingleton::flush_all(); }
-
 //======================================================================
 //======================================================================
-//======================================================================
-
-// clang-format off

 #ifdef VERILATED_VCD_TEST
 #include <iostream>

+extern void verilated_trace_imp_selftest();
+
 vluint32_t v1, v2, s1, s2[3];
 vluint32_t tri96[3];
 vluint32_t tri96__tri[3];
 vluint64_t quad96[2];
+vluint64_t tquad;
+vluint64_t tquad__tri;
 vluint8_t ch;
 vluint64_t timestamp = 1;
-double doub = 0;
+double doub = 0.0;
+float flo = 0.0f;

-void vcdInit(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdInit(void*, VerilatedVcd* vcdp, vluint32_t) {
    vcdp->scopeEscape('.');
    vcdp->module("top");
-     vcdp->declBus(0x2, "v1",-1,5,1);
-     vcdp->declBus(0x3, "v2",-1,6,0);
-     vcdp->module("top.sub1");
-      vcdp->declBit(0x4, "s1",-1);
-      vcdp->declBit(0x5, "ch",-1);
-     vcdp->module("top.sub2");
-      vcdp->declArray(0x6, "s2",-1, 40,3);
+    /**/ vcdp->declBus(0x2, "v1", -1, 0, 5, 1);
+    /**/ vcdp->declBus(0x3, "v2", -1, 0, 6, 1);
+    /**/ vcdp->module("top.sub1");
+    /***/ vcdp->declBit(0x4, "s1", -1, 0);
+    /***/ vcdp->declBit(0x5, "ch", -1, 0);
+    /**/ vcdp->module("top.sub2");
+    /***/ vcdp->declArray(0x6, "s2", -1, 0, 40, 3);
    // Note need to add 3 for next code.
    vcdp->module("top2");
-     vcdp->declBus(0x2, "t2v1",-1,4,1);
-     vcdp->declTriBit(0x10, "io1",-1);
-     vcdp->declTriBus(0x12, "io5",-1,4,0);
-     vcdp->declTriArray(0x16, "io96",-1,95,0);
-    // Note need to add 6 for next code.
-     vcdp->declDouble(0x1c, "doub",-1);
-    // Note need to add 2 for next code.
-     vcdp->declArray(0x1e, "q2",-1,95,0);
-    // Note need to add 4 for next code.
+    /**/ vcdp->declBus(0x2, "t2v1", -1, 0, 4, 1);
+    /**/ vcdp->declTriBit(0x10, "io1", -1, 0);
+    /**/ vcdp->declTriBus(0x12, "io5", -1, 0, 4, 0);
+    /**/ vcdp->declTriArray(0x16, "io96", -1, 0, 95, 0);
+    /**/  // Note need to add 6 for next code.
+    /**/ vcdp->declDouble(0x1c, "doub", -1, 0);
+    /**/  // Note need to add 2 for next code.
+    /**/ vcdp->declArray(0x20, "q2", -1, 0, 95, 0);
+    /**/  // Note need to add 4 for next code.
+    /**/ vcdp->declTriQuad(0x24, "tq", -1, 0, 63, 0);
+    /**/  // Note need to add 4 for next code.
 }

-void vcdFull(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdFull(void*, VerilatedVcd* vcdp) {
    vcdp->fullBus(0x2, v1, 5);
    vcdp->fullBus(0x3, v2, 7);
    vcdp->fullBit(0x4, s1);
@@ -919,10 +836,11 @@ void vcdFull(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
    vcdp->fullTriBus(0x12, tri96[0] & 0x1f, tri96__tri[0] & 0x1f, 5);
    vcdp->fullTriArray(0x16, tri96, tri96__tri, 96);
    vcdp->fullDouble(0x1c, doub);
-    vcdp->fullArray(0x1e, &quad96[0], 96);
+    vcdp->fullArray(0x20, &quad96[0], 96);
+    vcdp->fullTriQuad(0x24, tquad, tquad__tri, 64);
 }

-void vcdChange(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
+void vcdChange(void*, VerilatedVcd* vcdp) {
    vcdp->chgBus(0x2, v1, 5);
    vcdp->chgBus(0x3, v2, 7);
    vcdp->chgBit(0x4, s1);
@@ -932,11 +850,13 @@ void vcdChange(VerilatedVcd* vcdp, void* userthis, vluint32_t code) {
    vcdp->chgTriBus(0x12, tri96[0] & 0x1f, tri96__tri[0] & 0x1f, 5);
    vcdp->chgTriArray(0x16, tri96, tri96__tri, 96);
    vcdp->chgDouble(0x1c, doub);
-    vcdp->chgArray(0x1e, &quad96[0], 96);
+    vcdp->chgArray(0x20, &quad96[0], 96);
+    vcdp->chgTriQuad(0x24, tquad, tquad__tri, 64);
 }

-main() {
-    std::cout << "test: O_LARGEFILE=" << O_LARGEFILE << std::endl;
+// clang-format off
+void vcdTestMain(const char* filenamep) {
+    verilated_trace_imp_selftest();

    v1 = v2 = s1 = 0;
    s2[0] = s2[1] = s2[2] = 0;
@@ -945,43 +865,53 @@ main() {
    quad96[1] = quad96[0] = 0;
    ch = 0;
    doub = 0;
+    tquad = tquad__tri = 0;
    {
        VerilatedVcdC* vcdp = new VerilatedVcdC;
-        vcdp->spTrace()->addCallback(&vcdInit, &vcdFull, &vcdChange, 0);
-        vcdp->open("test.vcd");
+        vcdp->evcd(true);
+        vcdp->spTrace()->addInitCb(&vcdInit, 0);
+        vcdp->spTrace()->addFullCb(&vcdFull, 0);
+        vcdp->spTrace()->addChgCb(&vcdChange, 0);
+        vcdp->open(filenamep);
        // Dumping
-        vcdp->dump(timestamp++);
+        vcdp->dump(++timestamp);
        v1 = 0xfff;
        tri96[2] = 4; tri96[1] = 2; tri96[0] = 1;
        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = ~0;  // Still tri
        quad96[1] = 0xffffffff; quad96[0] = 0;
        doub = 1.5;
-        vcdp->dump(timestamp++);
+        flo = 1.4f;
+        vcdp->dump(++timestamp);
        v2 = 0x1;
        s2[1] = 2;
        tri96__tri[2] = tri96__tri[1] = tri96__tri[0] = 0;  // enable w/o data change
        quad96[1] = 0; quad96[0] = ~0;
        doub = -1.66e13;
-        vcdp->dump(timestamp++);
+        flo = 0.123f;
+        tquad = 0x00ff00ff00ff00ffULL;
+        tquad__tri = 0x0000fffff0000ffffULL;
+        vcdp->dump(++timestamp);
        ch = 2;
        tri96[2] = ~4; tri96[1] = ~2; tri96[0] = ~1;
        doub = -3.33e-13;
-        vcdp->dump(timestamp++);
-        vcdp->dump(timestamp++);
+        vcdp->dump(++timestamp);
+        vcdp->dump(++timestamp);
 # ifdef VERILATED_VCD_TEST_64BIT
-        vluint64_t bytesPerDump = VL_ULL(15);
-        for (vluint64_t i = 0; i < ((VL_ULL(1) << 32) / bytesPerDump); i++) {
+        vluint64_t bytesPerDump = 15ULL;
+        for (vluint64_t i = 0; i < ((1ULL << 32) / bytesPerDump); i++) {
            v1 = i;
-            vcdp->dump(timestamp++);
+            vcdp->dump(++timestamp);
        }
 # endif
        vcdp->close();
+        VL_DO_CLEAR(delete vcdp, vcdp = nullptr);
    }
 }
 #endif
+// clang-format on

 //********************************************************************
-// ;compile-command: "mkdir -p ../test_dir && cd ../test_dir && c++ -DVERILATED_VCD_TEST ../include/verilated_vcd_c.cpp -o verilated_vcd_c && ./verilated_vcd_c && cat test.vcd"
+// ;compile-command: "v4make test_regress/t/t_trace_c_api.pl"
 //
 // Local Variables:
 // End:
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you
 // can redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -34,14 +34,13 @@ class VerilatedVcd;
 // VerilatedFile
 /// File handling routines, which can be overrode for e.g. socket I/O

-class VerilatedVcdFile {
+class VerilatedVcdFile VL_NOT_FINAL {
 private:
-    int m_fd;  ///< File descriptor we're writing to
+    int m_fd = 0;  ///< File descriptor we're writing to
 public:
    // METHODS
-    VerilatedVcdFile()
-        : m_fd(0) {}
-    virtual ~VerilatedVcdFile() {}
+    VerilatedVcdFile() = default;
+    virtual ~VerilatedVcdFile() = default;
    virtual bool open(const std::string& name) VL_MT_UNSAFE;
    virtual void close() VL_MT_UNSAFE;
    virtual ssize_t write(const char* bufp, ssize_t len) VL_MT_UNSAFE;
@@ -52,7 +51,7 @@ public:
 /// Base class to create a Verilator VCD dump
 /// This is an internally used class - see VerilatedVcdC for what to call from applications

-class VerilatedVcd : public VerilatedTrace<VerilatedVcd> {
+class VerilatedVcd VL_NOT_FINAL : public VerilatedTrace<VerilatedVcd> {
 private:
    // Give the superclass access to private bits (to avoid virtual functions)
    friend class VerilatedTrace<VerilatedVcd>;
@@ -62,30 +61,30 @@ private:

    VerilatedVcdFile* m_filep;  ///< File we're writing to
    bool m_fileNewed;  ///< m_filep needs destruction
-    bool m_isOpen;  ///< True indicates open file
-    bool m_evcd;  ///< True for evcd format
+    bool m_isOpen = false;  ///< True indicates open file
+    bool m_evcd = false;  ///< True for evcd format
    std::string m_filename;  ///< Filename we're writing to (if open)
-    vluint64_t m_rolloverMB;  ///< MB of file size to rollover at
-    int m_modDepth;  ///< Depth of module hierarchy
+    vluint64_t m_rolloverMB = 0;  ///< MB of file size to rollover at
+    int m_modDepth = 0;  ///< Depth of module hierarchy

    char* m_wrBufp;  ///< Output buffer
    char* m_wrFlushp;  ///< Output buffer flush trigger location
    char* m_writep;  ///< Write pointer into output buffer
    vluint64_t m_wrChunkSize;  ///< Output buffer size
-    vluint64_t m_wroteBytes;  ///< Number of bytes written to this file
+    vluint64_t m_wroteBytes = 0;  ///< Number of bytes written to this file

    std::vector<char> m_suffixes;  ///< VCD line end string codes + metadata
    const char* m_suffixesp;  ///< Pointer to first element of above

-    typedef std::map<std::string, std::string> NameMap;
-    NameMap* m_namemapp;  ///< List of names for the header
+    typedef std::map<const std::string, const std::string> NameMap;
+    NameMap* m_namemapp = nullptr;  ///< List of names for the header

    void bufferResize(vluint64_t minsize);
    void bufferFlush() VL_MT_UNSAFE_ONE;
    inline void bufferCheck() {
        // Flush the write buffer if there's not enough space left for new information
        // We only call this once per vector, so we need enough slop for a very wide "b###" line
-        if (VL_UNLIKELY(m_writep > m_wrFlushp)) { bufferFlush(); }
+        if (VL_UNLIKELY(m_writep > m_wrFlushp)) bufferFlush();
    }
    void closePrev();
    void closeErr();
@@ -101,13 +100,10 @@ private:

    void dumpHeader();

-    char* writeCode(char* writep, vluint32_t code);
+    static char* writeCode(char* writep, vluint32_t code);

    void finishLine(vluint32_t code, char* writep);

-    /// Flush any remaining data from all files
-    static void flush_all() VL_MT_UNSAFE_ONE;
-
    // CONSTRUCTORS
    VL_UNCOPYABLE(VerilatedVcd);

@@ -116,11 +112,11 @@ protected:
    // Implementation of VerilatedTrace interface

    // Implementations of protected virtual methods for VerilatedTrace
-    void emitTimeChange(vluint64_t timeui) VL_OVERRIDE;
+    virtual void emitTimeChange(vluint64_t timeui) override;

    // Hooks called from VerilatedTrace
-    bool preFullDump() VL_OVERRIDE { return isOpen(); }
-    bool preChangeDump() VL_OVERRIDE;
+    virtual bool preFullDump() override { return isOpen(); }
+    virtual bool preChangeDump() override;

    // Implementations of duck-typed methods for VerilatedTrace. These are
    // called from only one place (namely full*) so always inline them.
@@ -130,14 +126,13 @@ protected:
    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:
    //=========================================================================
    // External interface to client code

-    explicit VerilatedVcd(VerilatedVcdFile* filep = NULL);
+    explicit VerilatedVcd(VerilatedVcdFile* filep = nullptr);
    ~VerilatedVcd();

    // ACCESSORS
@@ -163,7 +158,6 @@ public:
    void declBus(vluint32_t code, const char* name, bool array, int arraynum, int msb, int lsb);
    void declQuad(vluint32_t code, const char* name, bool array, int arraynum, int msb, int lsb);
    void declArray(vluint32_t code, const char* name, bool array, int arraynum, int msb, int lsb);
-    void declFloat(vluint32_t code, const char* name, bool array, int arraynum);
    void declDouble(vluint32_t code, const char* name, bool array, int arraynum);

 #ifdef VL_TRACE_VCD_OLD_API
@@ -195,7 +189,6 @@ public:
    void fullWData(vluint32_t* oldp, const WData* newvalp, int bits) {
        fullArray(oldp - this->oldp(0), newvalp, bits);
    }
-    void fullFloat(vluint32_t* oldp, float newval) { fullFloat(oldp - this->oldp(0), newval); }
    void fullDouble(vluint32_t* oldp, double newval) { fullDouble(oldp - this->oldp(0), newval); }

    inline void chgBit(vluint32_t* oldp, CData newval) { chgBit(oldp - this->oldp(0), newval); }
@@ -214,9 +207,6 @@ public:
    inline void chgWData(vluint32_t* oldp, const WData* newvalp, int bits) {
        chgArray(oldp - this->oldp(0), newvalp, bits);
    }
-    inline void chgFloat(vluint32_t* oldp, float newval) {
-        chgFloat(oldp - this->oldp(0), newval);
-    }
    inline void chgDouble(vluint32_t* oldp, double newval) {
        chgDouble(oldp - this->oldp(0), newval);
    }
@@ -230,20 +220,10 @@ public:
    void fullArray(vluint32_t code, const vluint64_t* newvalp, int bits);
    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 fullTriQuad(vluint32_t code, const vluint64_t newval, const vluint64_t newtri, int bits);
    void fullTriArray(vluint32_t code, const vluint32_t* newvalp, const vluint32_t* newtrip,
                      int bits);
    void fullDouble(vluint32_t code, const double newval);
-    void fullFloat(vluint32_t code, const float newval);
-
-    /// Inside dumping routines, dump one signal as unknowns
-    /// Presently this code doesn't change the oldval vector.
-    /// Thus this is for special standalone applications that after calling
-    /// fullBitX, must when then value goes non-X call fullBit.
-    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);

    /// Inside dumping routines, dump one signal if it has changed.
    /// We do want to inline these to avoid calls when the value did not change.
@@ -262,7 +242,7 @@ public:
    inline void chgQuad(vluint32_t code, const vluint64_t newval, int bits) {
        vluint64_t diff = (*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval;
        if (VL_UNLIKELY(diff)) {
-            if (VL_UNLIKELY(bits == 64 || (diff & ((VL_ULL(1) << bits) - 1)))) {
+            if (VL_UNLIKELY(bits == 64 || (diff & ((1ULL << bits) - 1)))) {
                fullQuad(code, newval, bits);
            }
        }
@@ -303,12 +283,12 @@ public:
            }
        }
    }
-    inline void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint32_t newtri,
+    inline void chgTriQuad(vluint32_t code, const vluint64_t newval, const vluint64_t newtri,
                           int bits) {
        vluint64_t diff = (((*(reinterpret_cast<vluint64_t*>(oldp(code)))) ^ newval)
                           | ((*(reinterpret_cast<vluint64_t*>(oldp(code + 1)))) ^ newtri));
        if (VL_UNLIKELY(diff)) {
-            if (VL_UNLIKELY(bits == 64 || (diff & ((VL_ULL(1) << bits) - 1)))) {
+            if (VL_UNLIKELY(bits == 64 || (diff & ((1ULL << bits) - 1)))) {
                fullTriQuad(code, newval, newtri, bits);
            }
        }
@@ -329,15 +309,9 @@ public:
            fullDouble(code, newval);
        }
    }
-    inline void chgFloat(vluint32_t code, const float newval) {
-        // cppcheck-suppress invalidPointerCast
-        if (VL_UNLIKELY((*(reinterpret_cast<float*>(oldp(code)))) != newval)) {
-            fullFloat(code, newval);
-        }
-    }

-protected:
    // METHODS
+    // Old/standalone API only
    void evcd(bool flag) { m_evcd = flag; }
 #endif  // VL_TRACE_VCD_OLD_API
 };
@@ -355,15 +329,15 @@ template <> void VerilatedTrace<VerilatedVcd>::set_time_resolution(const std::st
 /// Also derived for use in SystemC simulations.
 /// Thread safety: Unless otherwise indicated, every function is VL_MT_UNSAFE_ONE

-class VerilatedVcdC {
+class VerilatedVcdC VL_NOT_FINAL {
    VerilatedVcd m_sptrace;  ///< Trace file being created

    // CONSTRUCTORS
    VL_UNCOPYABLE(VerilatedVcdC);

 public:
-    explicit VerilatedVcdC(VerilatedVcdFile* filep = NULL)
-        : m_sptrace(filep) {}
+    explicit VerilatedVcdC(VerilatedVcdFile* filep = nullptr)
+        : m_sptrace{filep} {}
    ~VerilatedVcdC() { close(); }
    /// Routines can only be called from one thread; allow next call from different thread
    void changeThread() { spTrace()->changeThread(); }
@@ -405,6 +379,15 @@ public:

    /// Internal class access
    inline VerilatedVcd* spTrace() { return &m_sptrace; }
+
+#ifdef VL_TRACE_VCD_OLD_API
+    //=========================================================================
+    // Note: These are only for testing for backward compatibility with foreign
+    // code and is not used by Verilator. Do not use these as there is no
+    // guarantee of functionality.
+    /// Use evcd format
+    void evcd(bool flag) VL_MT_UNSAFE_ONE { m_sptrace.evcd(flag); }
+#endif
 };

 #endif  // guard
@@ -3,7 +3,7 @@
 //
 // THIS MODULE IS PUBLICLY LICENSED
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+// Copyright 2001-2021 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.
@@ -25,22 +25,21 @@
 //======================================================================

 //--------------------------------------------------
-#if (SYSTEMC_VERSION >= 20050714)
 // SystemC 2.1.v1
 // cppcheck-suppress unusedFunction
 void VerilatedVcdSc::write_comment(const std::string&) {}
 void VerilatedVcdSc::trace(const unsigned int&, const std::string&, const char**) {}

-// clang-format off
-# define DECL_TRACE_METHOD_A(tp) \
+#define DECL_TRACE_METHOD_A(tp) \
    void VerilatedVcdSc::trace(const tp& object, const std::string& name) {}
-# define DECL_TRACE_METHOD_B(tp) \
+#define DECL_TRACE_METHOD_B(tp) \
    void VerilatedVcdSc::trace(const tp& object, const std::string& name, int width) {}

-# if (SYSTEMC_VERSION >= 20171012)
+// clang-format off
+#if (SYSTEMC_VERSION >= 20171012)
    DECL_TRACE_METHOD_A( sc_event )
    DECL_TRACE_METHOD_A( sc_time )
-# endif
+#endif

    DECL_TRACE_METHOD_A( bool )
    DECL_TRACE_METHOD_A( sc_dt::sc_bit )
@@ -50,9 +49,9 @@ void VerilatedVcdSc::trace(const unsigned int&, const std::string&, const char**
    DECL_TRACE_METHOD_B( unsigned short )
    DECL_TRACE_METHOD_B( unsigned int )
    DECL_TRACE_METHOD_B( unsigned long )
-# ifdef SYSTEMC_64BIT_PATCHES
+#ifdef SYSTEMC_64BIT_PATCHES
    DECL_TRACE_METHOD_B( unsigned long long)
-# endif
+#endif
    DECL_TRACE_METHOD_B( char )
    DECL_TRACE_METHOD_B( short )
    DECL_TRACE_METHOD_B( int )
@@ -76,92 +75,6 @@ void VerilatedVcdSc::trace(const unsigned int&, const std::string&, const char**
    DECL_TRACE_METHOD_A( sc_dt::sc_lv_base )
 // clang-format on

-//--------------------------------------------------
-#elif (SYSTEMC_VERSION > 20011000)
-// SystemC 2.0.1
-// cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment(const sc_string&) {}
-void VerilatedVcdSc::trace(const unsigned int&, const sc_string&, const char**) {}
-
-#define DECL_TRACE_METHOD_A(tp) \
-    void VerilatedVcdSc::trace(const tp& object, const sc_string& name) {}
-#define DECL_TRACE_METHOD_B(tp) \
-    void VerilatedVcdSc::trace(const tp& object, const sc_string& name, int width) {}
-
-// clang-format off
-    DECL_TRACE_METHOD_A( bool )
-    DECL_TRACE_METHOD_A( sc_bit )
-    DECL_TRACE_METHOD_A( sc_logic )
-    DECL_TRACE_METHOD_B( unsigned char )
-    DECL_TRACE_METHOD_B( unsigned short )
-    DECL_TRACE_METHOD_B( unsigned int )
-    DECL_TRACE_METHOD_B( unsigned long )
-#ifdef SYSTEMC_64BIT_PATCHES
-    DECL_TRACE_METHOD_B( unsigned long long)
-#endif
-#if (SYSTEMC_VERSION > 20041000)
-    DECL_TRACE_METHOD_B( unsigned long long)
-    DECL_TRACE_METHOD_B( long long)
-#endif
-    DECL_TRACE_METHOD_B( char )
-    DECL_TRACE_METHOD_B( short )
-    DECL_TRACE_METHOD_B( int )
-    DECL_TRACE_METHOD_B( long )
-    DECL_TRACE_METHOD_A( float )
-    DECL_TRACE_METHOD_A( double )
-    DECL_TRACE_METHOD_A( sc_int_base )
-    DECL_TRACE_METHOD_A( sc_uint_base )
-    DECL_TRACE_METHOD_A( sc_signed )
-    DECL_TRACE_METHOD_A( sc_unsigned )
-    DECL_TRACE_METHOD_A( sc_fxval )
-    DECL_TRACE_METHOD_A( sc_fxval_fast )
-    DECL_TRACE_METHOD_A( sc_fxnum )
-    DECL_TRACE_METHOD_A( sc_fxnum_fast )
-    DECL_TRACE_METHOD_A( sc_bv_base )
-    DECL_TRACE_METHOD_A( sc_lv_base )
-// clang-format on
-
-//--------------------------------------------------
-#else
-// SystemC 1.2.1beta
-// cppcheck-suppress unusedFunction
-void VerilatedVcdSc::write_comment(const sc_string&) {}
-void VerilatedVcdSc::trace(const unsigned int&, const sc_string&, const char**) {}
-
-#define DECL_TRACE_METHOD_A(tp) \
-    void VerilatedVcdSc::trace(const tp& object, const sc_string& name) {}
-#define DECL_TRACE_METHOD_B(tp) \
-    void VerilatedVcdSc::trace(const tp& object, const sc_string& name, int width) {}
-
-// clang-format off
-    DECL_TRACE_METHOD_A( bool )
-    DECL_TRACE_METHOD_B( unsigned char )
-    DECL_TRACE_METHOD_B( short unsigned int )
-    DECL_TRACE_METHOD_B( unsigned int )
-    DECL_TRACE_METHOD_B( long unsigned int )
-    DECL_TRACE_METHOD_B( char )
-    DECL_TRACE_METHOD_B( short int )
-    DECL_TRACE_METHOD_B( int )
-    DECL_TRACE_METHOD_B( long int )
-    DECL_TRACE_METHOD_A( float )
-    DECL_TRACE_METHOD_A( double )
-    DECL_TRACE_METHOD_A( sc_bit )
-    DECL_TRACE_METHOD_A( sc_logic )
-    DECL_TRACE_METHOD_A( sc_bool_vector )
-    DECL_TRACE_METHOD_A( sc_logic_vector )
-    DECL_TRACE_METHOD_A( sc_signal_bool_vector )
-    DECL_TRACE_METHOD_A( sc_signal_logic_vector )
-    DECL_TRACE_METHOD_A( sc_uint_base )
-    DECL_TRACE_METHOD_A( sc_int_base )
-    DECL_TRACE_METHOD_A( sc_unsigned )
-    DECL_TRACE_METHOD_A( sc_signed )
-    DECL_TRACE_METHOD_A( sc_signal_resolved )
-    DECL_TRACE_METHOD_A( sc_signal_resolved_vector )
-    DECL_TRACE_METHOD_A( sc_bv_ns::sc_bv_base )
-    DECL_TRACE_METHOD_A( sc_bv_ns::sc_lv_base )
-// clang-format on
-#endif
-
 #undef DECL_TRACE_METHOD_A
 #undef DECL_TRACE_METHOD_B

@@ -1,7 +1,7 @@
 // -*- mode: C++; c-file-style: "cc-mode" -*-
 //=============================================================================
 //
-// Copyright 2001-2020 by Wilson Snyder. This program is free software; you can
+// Copyright 2001-2021 by Wilson Snyder. This program is free software; you can
 // redistribute it and/or modify it under the terms of either the GNU
 // Lesser General Public License Version 3 or the Perl Artistic License
 // Version 2.0.
@@ -31,14 +31,13 @@
 /// This class is passed to the SystemC simulation kernel, just like a
 /// documented SystemC trace format.

-class VerilatedVcdSc : sc_trace_file, public VerilatedVcdC {
+class VerilatedVcdSc final : sc_trace_file, public VerilatedVcdC {
    // CONSTRUCTORS
    VL_UNCOPYABLE(VerilatedVcdSc);

 public:
    VerilatedVcdSc() {
        sc_get_curr_simcontext()->add_trace_file(this);
-#if (SYSTEMC_VERSION >= 20060505)
        // We want to avoid a depreciated warning, but still be back compatible.
        // Turning off the message just for this still results in an
        // annoying "to turn off" message.
@@ -48,25 +47,13 @@ public:
            spTrace()->set_time_unit(tunits.to_string());
        }
        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
-#elif (SYSTEMC_VERSION > 20011000)
-        // To confuse matters 2.1.beta returns a char* here, while 2.1.v1 returns a std::string
-        // we allow both flavors with overloaded set_time_* functions.
-        spTrace()->set_time_unit(sc_get_default_time_unit().to_string());
-        spTrace()->set_time_resolution(sc_get_time_resolution().to_string());
-#endif
    }
    virtual ~VerilatedVcdSc() { close(); }

    // METHODS
    /// Called by SystemC simulate()
    virtual void cycle(bool delta_cycle) {
-#if (SYSTEMC_VERSION > 20011000)
-        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
-#else
-        // VCD files must have integer timestamps, so we write all times in
-        // increments of time_resolution
-        if (!delta_cycle) { this->dump(sc_time_stamp().to_double()); }
-#endif
+        if (!delta_cycle) this->dump(sc_time_stamp().to_double());
    }

 private:
@@ -76,26 +63,23 @@ private:
    // Cadence Incisive has these as abstract functions so we must create them
    virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
 #endif
-#if defined(NC_SYSTEMC) || (SYSTEMC_VERSION >= 20111100)
-    virtual void set_time_unit(double v, sc_time_unit tu) {}
-#endif
+    virtual void set_time_unit(double v, sc_time_unit tu) {}  // LCOV_EXCL_LINE

 //--------------------------------------------------
-#if (SYSTEMC_VERSION >= 20050714)
-    // SystemC 2.1.v1
-    // clang-format off
-# define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
-# define DECL_TRACE_METHOD_B(tp) \
+// SystemC 2.1.v1
+#define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const std::string& name);
+#define DECL_TRACE_METHOD_B(tp) \
    virtual void trace(const tp& object, const std::string& name, int width);

    virtual void write_comment(const std::string&);
    virtual void trace(const unsigned int&, const std::string&, const char**);

+    // clang-format off
    // Formatting matches that of sc_trace.h
-# if (SYSTEMC_VERSION >= 20171012)
+#if (SYSTEMC_VERSION >= 20171012)
    DECL_TRACE_METHOD_A( sc_event )
    DECL_TRACE_METHOD_A( sc_time )
-# endif
+#endif

    DECL_TRACE_METHOD_A( bool )
    DECL_TRACE_METHOD_A( sc_dt::sc_bit )
@@ -105,9 +89,9 @@ private:
    DECL_TRACE_METHOD_B( unsigned short )
    DECL_TRACE_METHOD_B( unsigned int )
    DECL_TRACE_METHOD_B( unsigned long )
-# ifdef SYSTEMC_64BIT_PATCHES
+#ifdef SYSTEMC_64BIT_PATCHES
    DECL_TRACE_METHOD_B( unsigned long long)
-# endif
+#endif
    DECL_TRACE_METHOD_B( char )
    DECL_TRACE_METHOD_B( short )
    DECL_TRACE_METHOD_B( int )
@@ -131,90 +115,6 @@ private:
    DECL_TRACE_METHOD_A( sc_dt::sc_lv_base )
    // clang-format on

-//--------------------------------------------------
-#elif (SYSTEMC_VERSION > 20011000)
-    // SystemC 2.0.1
-    // clang-format off
-# define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const sc_string& name);
-# define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace(const tp& object, const sc_string& name, int width);
-
-    virtual void write_comment(const sc_string&);
-    virtual void trace(const unsigned int&, const sc_string&, const char**);
-    virtual void delta_cycles(bool) {}
-    virtual void space(int n) {}
-
-    DECL_TRACE_METHOD_A( bool )
-    DECL_TRACE_METHOD_A( sc_bit )
-    DECL_TRACE_METHOD_A( sc_logic )
-    DECL_TRACE_METHOD_B( unsigned char )
-    DECL_TRACE_METHOD_B( unsigned short )
-    DECL_TRACE_METHOD_B( unsigned int )
-    DECL_TRACE_METHOD_B( unsigned long )
-# ifdef SYSTEMC_64BIT_PATCHES
-    DECL_TRACE_METHOD_B( unsigned long long)
-# endif
-# if (SYSTEMC_VERSION > 20041000)
-    DECL_TRACE_METHOD_B( unsigned long long)
-    DECL_TRACE_METHOD_B( long long)
-# endif
-    DECL_TRACE_METHOD_B( char )
-    DECL_TRACE_METHOD_B( short )
-    DECL_TRACE_METHOD_B( int )
-    DECL_TRACE_METHOD_B( long )
-    DECL_TRACE_METHOD_A( float )
-    DECL_TRACE_METHOD_A( double )
-    DECL_TRACE_METHOD_A( sc_int_base )
-    DECL_TRACE_METHOD_A( sc_uint_base )
-    DECL_TRACE_METHOD_A( sc_signed )
-    DECL_TRACE_METHOD_A( sc_unsigned )
-    DECL_TRACE_METHOD_A( sc_fxval )
-    DECL_TRACE_METHOD_A( sc_fxval_fast )
-    DECL_TRACE_METHOD_A( sc_fxnum )
-    DECL_TRACE_METHOD_A( sc_fxnum_fast )
-    DECL_TRACE_METHOD_A( sc_bv_base )
-    DECL_TRACE_METHOD_A( sc_lv_base )
-    // clang-format on
-
-//--------------------------------------------------
-#else
-    // SystemC 1.2.1beta
-    // clang-format off
-# define DECL_TRACE_METHOD_A(tp) virtual void trace(const tp& object, const sc_string& name);
-# define DECL_TRACE_METHOD_B(tp) \
-    virtual void trace(const tp& object, const sc_string& name, int width);
-
-    virtual void write_comment(const sc_string&);
-    virtual void trace(const unsigned int&, const sc_string&, const char**);
-
-    DECL_TRACE_METHOD_A( bool )
-    DECL_TRACE_METHOD_B( unsigned char )
-    DECL_TRACE_METHOD_B( short unsigned int )
-    DECL_TRACE_METHOD_B( unsigned int )
-    DECL_TRACE_METHOD_B( long unsigned int )
-    DECL_TRACE_METHOD_B( char )
-    DECL_TRACE_METHOD_B( short int )
-    DECL_TRACE_METHOD_B( int )
-    DECL_TRACE_METHOD_B( long int )
-    DECL_TRACE_METHOD_A( float )
-    DECL_TRACE_METHOD_A( double )
-    DECL_TRACE_METHOD_A( sc_bit )
-    DECL_TRACE_METHOD_A( sc_logic )
-    DECL_TRACE_METHOD_A( sc_bool_vector )
-    DECL_TRACE_METHOD_A( sc_logic_vector )
-    DECL_TRACE_METHOD_A( sc_signal_bool_vector )
-    DECL_TRACE_METHOD_A( sc_signal_logic_vector )
-    DECL_TRACE_METHOD_A( sc_uint_base )
-    DECL_TRACE_METHOD_A( sc_int_base )
-    DECL_TRACE_METHOD_A( sc_unsigned )
-    DECL_TRACE_METHOD_A( sc_signed )
-    DECL_TRACE_METHOD_A( sc_signal_resolved )
-    DECL_TRACE_METHOD_A( sc_signal_resolved_vector )
-    DECL_TRACE_METHOD_A( sc_bv_ns::sc_bv_base )
-    DECL_TRACE_METHOD_A( sc_bv_ns::sc_lv_base )
-# endif
-    // clang-format on
-
 #undef DECL_TRACE_METHOD_A
 #undef DECL_TRACE_METHOD_B
 };
--- a/Show More
+++ b/Show More