Version bump

**   Add simulation context (VerilatedContext) to allow multiple fully independent
      models to be in the same process.  Please see the updated examples.
**   Add context->time() and context->timeInc() API calls, to set simulation time.
      These now are recommended in place of the legacy sc_time_stamp().

.clang-format

@@ -104,7 +104,7 @@ SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard:        Cpp03
+Standard:        Cpp11
 TabWidth:        8
 UseTab:          Never
 ...

.clang-tidy

@@ -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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -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.rst)
 title: ''
 labels: new
 assignees: ''

.github/ISSUE_TEMPLATE/feature.md

@@ -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.rst)
 title: ''
 labels: new
 assignees: ''

.github/ISSUE_TEMPLATE/questions.md

@@ -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.rst)
 title: ''
 labels: new
 assignees: ''

.github/PULL_REQUEST_TEMPLATE.md

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

.github/workflows/build.yml

@@ -0,0 +1,137 @@
+# DESCRIPTION: Github actions config
+# This name is key to badges in README.rst, 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

.github/workflows/clang-format.yml

@@ -0,0 +1,43 @@
+# DESCRIPTION: Github actions config
+# 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

.github/workflows/contributor.yml

@@ -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

.github/workflows/coverage.yml

@@ -0,0 +1,106 @@
+# 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
+        - 4
+        - 5
+        - 6
+        - 7
+        - 8
+        - 9
+        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

.gitignore

@@ -15,6 +15,8 @@
 *.tex
 *.pdf
 /Makefile
+/.ccache
+/artifact/
 README
 TAGS
 autom4te.cache

.travis.yml

@@ -1,148 +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
-
-language: cpp
-
-cache:
-  directories:
-    - $HOME/.ccache
-
-env:
-  global:
-    - VERILATOR_ROOT=$TRAVIS_BUILD_DIR
-
-# The list and order of build stages
-stages:
-  - build # Build Verilator
-  - test  # Run tests
-
-# Dump info about the environment for debugging
-before_install:
-  # To dump the script that Travis itself is executing, add 'cat $0' here
-  - cd "$TRAVIS_BUILD_DIR" # Skipping the git clone in later stages requires this
-  - export CCACHE_MAXSIZE=$(ci/travis-ccache-size.bash) # Set here after the 'cd'
-  - env | sort
-  - ls -lA .
-  - ls -lA bin
-  - g++ -E -dM -c -x c++ /dev/null | sort
-  - clang++ -E -dM -c -x c++ /dev/null | sort
-
-# Install all dependencies
-install:
-  - ./ci/travis-install.bash
-
-before_script:
-  # ccache maintenance
-  - ./ci/travis-ccache-maint.bash
-  # Don't produce core dumps (esp. on FreeBSD)
-  - ulimit -c 0
-  # On Focal, set the SystemC installation location
-  - |
-    if [ "$TRAVIS_DIST" = "focal" ] && [ "$M32" != "1" ]; then
-      export SYSTEMC_INCLUDE=/usr/include
-      export SYSTEMC_LIBDIR=/usr/lib/x86_64-linux-gnu
-    fi
-  # Override compiler for M32
-  - |
-    if [ "$M32" = "1" ]; then
-      export CC="$CC -m32"
-      export CXX="$CXX -m32"
-      unset M32 # verilated.mk actually references $(M32) so unset
-    fi
-
-before_cache:
-  - ccache -s -z
-
-# All jobs run the same script
-script: ./ci/travis-script.bash
-
-# Enumerate all the jobs
-jobs:
-  include:
-    ############################################################################
-    # Jobs in the 'build' stage
-    ############################################################################
-    # GCC builds
-    - {stage: build, if: type  = cron, os: linux, dist: trusty, compiler: gcc,   workspaces: {create: {name: trusty-gcc,   paths: .}}}
-    - {stage: build, if: type  = cron, os: linux, dist: xenial, compiler: gcc,   workspaces: {create: {name: xenial-gcc,   paths: .}}}
-    - {stage: build, if: type  = cron, os: linux, dist: bionic, compiler: gcc,   workspaces: {create: {name: bionic-gcc,   paths: .}}}
-    - {stage: build,                   os: linux, dist: focal,  compiler: gcc,   workspaces: {create: {name: focal-gcc,    paths: .}}}
-    # Clang builds
-    - {stage: build, if: type  = cron, os: linux, dist: xenial, compiler: clang, workspaces: {create: {name: xenial-clang, paths: .}}}
-    - {stage: build,                   os: linux, dist: focal,  compiler: clang, workspaces: {create: {name: focal-clang,  paths: .}}}
-    # Coverage build
-    - {stage: build, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {create: {name: coverage,     paths: .}}, env: COVERAGE=1}
-    # 32-bit build
-    - {stage: build, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {create: {name: focal-gcc-m32, paths: .}}, env: M32=1}
-    # OS X build
-    - {stage: build, if: type  = cron, os: osx, osx_image: xcode11.6, compiler: clang, workspaces: {create: {name: osx-xcode11.6, paths: .}}}
-    # FreeBSD build
-    - {stage: build, if: type  = cron, os: freebsd, compiler: clang, workspaces: {create: {name: freebsd, paths: .}}}
-    ############################################################################
-    # Jobs in the 'test' stage
-    ############################################################################
-    # GCC tests
-    - {stage: test, if: type  = cron, os: linux, dist: trusty, compiler: gcc,   workspaces: {use: trusty-gcc},   git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: trusty, compiler: gcc,   workspaces: {use: trusty-gcc},   git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: trusty, compiler: gcc,   workspaces: {use: trusty-gcc},   git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: trusty, compiler: gcc,   workspaces: {use: trusty-gcc},   git: {clone: false}, env: TESTS=vltmt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: gcc,   workspaces: {use: xenial-gcc},   git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: gcc,   workspaces: {use: xenial-gcc},   git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: gcc,   workspaces: {use: xenial-gcc},   git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: gcc,   workspaces: {use: xenial-gcc},   git: {clone: false}, env: TESTS=vltmt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: bionic, compiler: gcc,   workspaces: {use: bionic-gcc},   git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: bionic, compiler: gcc,   workspaces: {use: bionic-gcc},   git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: bionic, compiler: gcc,   workspaces: {use: bionic-gcc},   git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: bionic, compiler: gcc,   workspaces: {use: bionic-gcc},   git: {clone: false}, env: TESTS=vltmt-1}
-    - {stage: test, if: type != cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc},    git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type != cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc},    git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc},    git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc},    git: {clone: false}, env: TESTS=vltmt-1}
-    # Clang tests
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: clang, workspaces: {use: xenial-clang}, git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: clang, workspaces: {use: xenial-clang}, git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: clang, workspaces: {use: xenial-clang}, git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: xenial, compiler: clang, workspaces: {use: xenial-clang}, git: {clone: false}, env: TESTS=vltmt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: clang, workspaces: {use: focal-clang},  git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: clang, workspaces: {use: focal-clang},  git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type != cron, os: linux, dist: focal,  compiler: clang, workspaces: {use: focal-clang},  git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type != cron, os: linux, dist: focal,  compiler: clang, workspaces: {use: focal-clang},  git: {clone: false}, env: TESTS=vltmt-1}
-    # Coverage tests
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-dist}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vlt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vlt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vlt-2}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vlt-3}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vltmt-0}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vltmt-1}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vltmt-2}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: coverage},     git: {clone: false}, env: TESTS=coverage-vltmt-3}
-    # 32-bit tests
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc-m32}, git: {clone: false}, env: [M32=1, TESTS=dist-vlt-0]}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc-m32}, git: {clone: false}, env: [M32=1, TESTS=dist-vlt-1]}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc-m32}, git: {clone: false}, env: [M32=1, TESTS=vltmt-0]}
-    - {stage: test, if: type  = cron, os: linux, dist: focal,  compiler: gcc,   workspaces: {use: focal-gcc-m32}, git: {clone: false}, env: [M32=1, TESTS=vltmt-1]}
-    # OS X tests
-    - {stage: test, if: type  = cron, os: osx, osx_image: xcode11.6, compiler: clang, workspaces: {use: osx-xcode11.6},  git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: osx, osx_image: xcode11.6, compiler: clang, workspaces: {use: osx-xcode11.6},  git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: osx, osx_image: xcode11.6, compiler: clang, workspaces: {use: osx-xcode11.6},  git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: osx, osx_image: xcode11.6, compiler: clang, workspaces: {use: osx-xcode11.6},  git: {clone: false}, env: TESTS=vltmt-1}
-    # FreeBSD tests
-    - {stage: test, if: type  = cron, os: freebsd, compiler: clang, workspaces: {use: freebsd}, git: {clone: false}, env: TESTS=dist-vlt-0}
-    - {stage: test, if: type  = cron, os: freebsd, compiler: clang, workspaces: {use: freebsd}, git: {clone: false}, env: TESTS=dist-vlt-1}
-    - {stage: test, if: type  = cron, os: freebsd, compiler: clang, workspaces: {use: freebsd}, git: {clone: false}, env: TESTS=vltmt-0}
-    - {stage: test, if: type  = cron, os: freebsd, compiler: clang, workspaces: {use: freebsd}, git: {clone: false}, env: TESTS=vltmt-1}
-
-notifications:
-  email:
-    if: repo = verilator/verilator
-    recipients:
-      - [email protected]
-      - [email protected]

Changes

@@ -2,6 +2,232 @@ Revision history for Verilator
 
 The contributors that suggested a given feature are shown in []. Thanks!
 
+* Verilator 4.200 2021-03-12
+
+**    Add simulation context (VerilatedContext) to allow multiple fully independent
+      models to be in the same process. Please see the updated examples. (#2660)
+
+**    Add context->time() and context->timeInc() API calls, to set simulation time.
+      These now are recommended in place of the legacy sc_time_stamp().
+
+****  Converted Asciidoc documentation into reStructuredText (RST) format.
+
+****  --inhibit-sim is planned for deprecation, file a bug if this is still being used.
+
+****  Fix range inheritance on port without data type (#2753). [Embedded Go]
+
+****  Fix slice-assign overflow (#2803) (#2811). [David Turner]
+
+****  Fix interface array connection ordering broken in v4.110 (#2827). [Don Owen]
+
+****  Fix or-reduction on different scopes broken in 4.110 (#2828). [Yinan Xu]
+
+****  Fix MSVC++ compile error. (#2831) (#2833) [Drew Taussig]
+
+
+* Verilator 4.110 2021-02-25
+
+***   Optimize bit operations and others (#2186) (#2632) (#2633) (#2751) (#2800) [Yutetsu TAKATSUKASA]
+
+****  Support concat selection (#2721).
+
+****  Support struct scopes when dumping structs to VCD (#2776) [Alex Torregrosa]
+
+****  Generate SELRANGE for potentially unreachable code (#2625) (#2754) [Pierre-Henri Horrein]
+
+****  For --flatten, override inlining of public and no_inline modules (#2761) [James Hanlon]
+
+****  Fix little endian interface pin swizzling (#2475). [Don Owen]
+
+****  Fix range inheritance on port without data type (#2753). [Embedded Go]
+
+****  Fix TIMESCALE warnings on primitives (#2763). [Xuanqi]
+
+****  Fix to exclude strings from toggle coverage (#2766) (#2767) [Paul Wright]
+
+****  Fix $fread extra semicolon inside statements. [Leendert van Doorn]
+
+****  Fix class extends with VM_PARALLEL_BUILDS (#2775). [Iru Cai]
+
+****  Fix shifts by > 32 bit values (#2785). [qrq992]
+
+****  Fix examples not flushing vcd (#2787). [Richard E George]
+
+****  Fix little endian packed array pattern assignment (#2795). [Alex Torregrosa]
+
+
+* Verilator 4.108 2021-01-10
+
+**    Many VPI changes for IEEE compatibility, which may alter behavior from previous releases.
+
+**    Support randomize() class method and rand (#2607). [Krzysztof Bieganski]
+
+***   Support $cast and new CASTCONST warning.
+
+***   Add --top option as alias of --top-module.
+
+***   Add LATCH and NOLATCH warnings (#1609) (#2740). [Julien Margetts]
+
+****  Remove Unix::Processors internal test dependency.
+
+****  Report UNUSED on parameters, localparam and genvars (#2627). [Charles Eric LaForest]
+
+****  Add error on real to non-real output pins (#2690). [Peter Monsson]
+
+****  Support package imports before parameters in interfaces (#2714). [James Hanlon]
+
+****  Support --sanitize in internal tests (#2705). [Yutetsu TAKATSUKASA]
+
+****  Fix passing parameter type instantiations by position number.
+
+****  Fix DPI open array handling issues.
+
+****  Fix error when dotted refers to missing module (#2095). [Alexander Grobman]
+
+****  Fix little endian packed array counting (#2499). [phantom-killua]
+
+****  Fix showing reference locations for BLKANDNBLK (#2170). [Yuri Victorovich]
+
+****  Fix genblk naming to match IEEE (#2686). [tinshark]
+
+****  Fix VPI memory word indexing (#2695). [Marlon James]
+
+****  Fix vpiLeftRange on little-endian memories (#2696). [Marlon James]
+
+****  Fix VPI module tree (#2704). [Todd Strader]
+
+****  Fix vpi_release_handle to be called implicitly per IEEE (#2706).
+
+****  Fix to allow inheriting 'VerilatedVcdFile' class. (#2720) [HyungKi Jeong]
+
+****  Fix $urandom_range maximum value (#2723). [Nandu Raj]
+
+****  Fix tracing empty sc module (#2729).
+
+****  Fix generate for unrolling to be signed (#2730). [yanx21]
+
+****  Fix to emit timescale in hierarchical blocks (#2735). [Yutetsu TAKATSUKASA]
+
+****  Fix to ignore coverage on real ports (#2741) (#2745). [Paul Wright]
+
+
+
+* Verilator 4.106 2020-12-02
+
+**    Change -sv option to select 1800-2017 instead of 1800-2005.
+
+***   Check for proper 'local' and 'protected' (#2228).
+
+***   Support $random and $urandom seeds.
+
+***   Support $monitor and $strobe.
+
+***   Support complex function arguments.
+
+***   Support 'super'.
+
+***   Support 'with item.index'.
+
+****  Fix the default GNU Make executable name on FreeBSD (#2553). [Yuri Victorovich]
+
+****  Fix trace signal names getting hashed (#2643).  [Barbara Gigerl]
+
+****  Fix unpacked array parameters near functions (#2639). [Anderson Ignacio da Silva]
+
+****  Fix access to non-overridden base class variable (#2654). [Tobias Rosenkranz]
+
+
+* Verilator 4.104 2020-11-14
+
+***   Support queue and associative array 'with' statements (#2616).
+
+***   Support queue slicing (#2326).
+
+***   Support associative array pattern assignments and defaults.
+
+***   Support static methods and typedefs in classes (#2615). [Krzysztof Bieganski]
+
+****  Report error on typedef referencing self (#2539). [Cody Piersall]
+
+****  With --debug, turn off address space layout randomization.
+
+****  Fix iteration over mutating list bug in VPI (#2588). [Kaleb Barrett]
+
+****  Fix cast width propagation (#2597). [flex-liu]
+
+****  Fix return from callValueCbs (#2589) (#2605). [Marlon James]
+
+****  Fix WIDTH warnings on comparisons with nullptr (#2602). [Rupert Swarbrick]
+
+****  Fix fault when $fgets, $sscanf, etc used with string (#2604). [Yutetsu TAKATSUKASA]
+
+****  Fix WIFEXITED missing from MinGW/MSYS2 (#2609). [Jean Berniolles]
+
+****  Fix queue poping wrong value when otherwise unused (#2512). [nanduraj1]
+
+****  Fix arrays of modport interfaces (#2614). [Thierry Tambe]
+
+****  Fix split_var internal error (#2640) (#2641). [Yutetsu TAKATSUKASA]
+
+
+* Verilator 4.102 2020-10-15
+
+****  Support const object new() assignments.
+
+****  Support # as a comment in -f files (#2497). [phantom-killua]
+
+****  Support 'this' (#2585). [Rafal Kapuscik]
+
+****  Support defines for FST tracing (#2592). [Markus Krause]
+
+****  Support |=> inside properties (#1292). [Peter Monsson]
+
+****  Fix timescale with --hierarchical (#2554). [Yutetsu TAKATSUKASA]
+
+****  Fix cmake build with --hierarchical (#2560). [Yutetsu TAKATSUKASA]
+
+****  Fix -G dropping public indication (#2561). [Andrew Goessling]
+
+****  Fix $urandom_range passed variable (#2563). [nanduraj1]
+
+****  Fix method calls to package class functions (#2565). [Peter Monsson]
+
+****  Fix class wide member display (#2567). [Nandu Raj P]
+
+****  Fix hierarchical references inside function (#2267) (#2572). [James Pallister]
+
+****  Fix flushCall for backward compatibility (#2580). [chenguokai]
+
+****  Fix preprocessor stringify of undefined macro. [Martin Whitaker]
+
+
+* Verilator 4.100 2020-09-07
+
+**    C++11 or newer compilers are now required.
+
+**    SystemC 2.3.0 or newer (SYSTEMC_VERSION >= 20111121) is now required.
+
+**    Support hierarchical Verilation (#2206). [Yutetsu TAKATSUKASA]
+
+****  Support (with limitations) class extern, class extends, virtual class.
+
+****  Support $urandom, $urandom_range without stability.
+
+****  Fix false DECLFILENAME on black-boxed modules (#2430). [Philipp Wagner]
+
+****  Fix naming of "id : begin" blocks.
+
+****  Fix class constructor error on assignments to const.
+
+****  Fix splitting eval functions with --output-split-cfuncs (#2368). [Geza Lore]
+
+****  Fix queues as class members (#2525). [nanduraj1]
+
+****  Add support for assume property. [Peter Monsson]
+
+****  Add support for |=> inside properties (#1292). [Peter Monsson]
+
+
 * Verilator 4.040 2020-08-15
 
 **    Version 4.040 is planned to be the final version that will
@@ -31,6 +257,10 @@ The contributors that suggested a given feature are shown in []. Thanks!
 
 ****  Fix SystemC net names (#2500). [Edgar E. Iglesias]
 
+****  Fix build with Bison 3.7 and newer (#2505). [Rupert Swarbrick]
+
+****  Fix slice of unpacked array (#2506) (#2507). [Yutetsu TAKATSUKASA]
+
 
 * Verilator 4.038 2020-07-11
 
@@ -3714,7 +3944,7 @@ of input ports exists for tracing.
 
 This uses outline mode in Emacs. See C-h m [M-x describe-mode].
 
-Copyright 2001-2020 by Wilson Snyder. This program is free software; you
+Copyright 2001-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.

MANIFEST.SKIP

@@ -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/
@@ -41,10 +43,12 @@ docs/clang-format.txt$
 docs/doxygen-doc/.*
 examples/xml_py/copied/
 examples/xml_py/graph.*
+sonar-project.properties
 src/Makefile$
 src/Makefile_obj$
 include/verilated.mk$
 test_regress/.gdbinit$
+test_regress/transcript
 codecov.yml
 config.cache$
 config.status$
@@ -66,4 +70,5 @@ ci/
 /csrc/
 obj_dir.*
 TAGS
+gmon.out
 .*~

Makefile.in

@@ -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. ####
@@ -125,7 +124,7 @@ DISTFILES_INC = $(INFOS) .gitignore \
 	Changes \
 	LICENSE \
 	MANIFEST.SKIP \
-	README.adoc \
+	README.rst \
 	verilator-config.cmake.in \
 	verilator-config-version.cmake.in \
 	bin/verilator \
@@ -135,16 +134,16 @@ DISTFILES_INC = $(INFOS) .gitignore \
 	bin/verilator_includer \
 	bin/verilator_profcfunc \
 	docs/.gitignore \
-	docs/CONTRIBUTING.adoc \
+	docs/CONTRIBUTING.rst \
 	docs/CONTRIBUTORS \
 	docs/Makefile.in \
 	docs/TODO \
 	docs/doxygen-mainpage \
 	docs/doxygen.config \
-	docs/install.adoc \
-	docs/internals.adoc \
+	docs/install.rst \
+	docs/internals.rst \
 	docs/verilator_logo.png \
-	docs/xml.adoc \
+	docs/xml.rst \
 	install-sh configure *.pod \
 	include/*.[chv]* \
 	include/*.in \
@@ -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,6 +422,7 @@ 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 \
@@ -428,7 +431,7 @@ CPPCHECK_H = $(wildcard \
 CPPCHECK_YL = $(wildcard \
 	$(srcdir)/src/*.y \
 	$(srcdir)/src/*.l )
-CPPCHECK = src/cppcheck_filtered
+CPPCHECK = src/cppcheck_filtered cppcheck
 CPPCHECK_FLAGS = --enable=all --inline-suppr \
 	--suppress=unusedScopedObject --suppress=cstyleCast --suppress=useInitializationList \
 	--suppress=nullPointerRedundantCheck
@@ -438,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
@@ -459,13 +463,57 @@ 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) $(CPPCHECK_YL)
+	$(CLANGFORMAT) $(CLANGFORMAT_FLAGS) $(CLANGFORMAT_FILES)
+
+PY_PROGRAMS = \
+	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/dot_importer \
+	nodist/fuzzer/actual_fail \
+	nodist/fuzzer/generate_dictionary \
+	nodist/install_test \
+
+PY_FILES = \
+	$(PY_PROGRAMS) \
+	nodist/code_coverage.dat \
+
+YAPF = yapf3
+YAPF_FLAGS = -i
+
+yapf:
+	$(YAPF) $(YAPF_FLAGS) $(PY_FILES)
+
+FLAKE8 = flake8
+FLAKE8_FLAGS = \
+	--extend-exclude=fastcov.py \
+	--ignore=E123,E129,E251,E501,W503,W504,E701
+
+PYLINT = pylint
+PYLINT_FLAGS = --disable=R0801
+
+lint-py:
+	$(FLAKE8) $(FLAKE8_FLAGS) $(PY_PROGRAMS)
+	$(PYLINT) $(PYLINT_FLAGS) $(PY_PROGRAMS)
+
+format-pl-exec:
+	-chmod a+x test_regress/t/*.pl
+
 
 ftp: info
 
@@ -546,9 +594,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
 

README.adoc

@@ -1,154 +0,0 @@
-// Github doesn't render images unless absolute URL
-:!toc:
-
-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://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg[Coverage,link=https://codecov.io/gh/verilator/verilator]
-image:https://travis-ci.com/verilator/verilator.svg?branch=master[Build Status (Travis CI),link=https://travis-ci.com/verilator/verilator]
-endif::[]
-
-ifdef::env-github[]
-:link_verilator_contributing: link:docs/CONTRIBUTING.adoc
-:link_verilator_install: link:docs/install.adoc
-endif::[]
-ifndef::env-github[]
-:link_verilator_contributing: https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.adoc
-:link_verilator_install: https://verilator.org/install
-endif::[]
-:link_verilator_commercial_support: https://verilator.org/verilator_commercial_support
-
-== Welcome to Verilator
-
-[cols="a,a",indent=0,frame="none",grid="rows"]
-|===
-^.^| *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
-+++ <br/> +++ &bullet; Creates XML to front-end your own tools
-<.^|image:https://www.veripool.org/img/verilator_256_200_min.png[Logo,256,200]
-
->.^|image:https://www.veripool.org/img/verilator_multithreaded_performance_bg-min.png[,388,178]
-^.^| *Fast*
-+++ <br/> +++ &bullet; Outperforms many commercial simulators
-+++ <br/> +++ &bullet; Single- and multi-threaded output models
-
-^.^| *Widely Used*
-+++ <br/> +++ &bullet; Wide industry and academic deployment
-+++ <br/> +++ &bullet; Out-of-the-box support from Arm, and RISC-V vendor IP
-<.^|image:https://www.veripool.org/img/verilator_usage_400x200-min.png[,400,200]
-
->.^|image:https://www.veripool.org/img/verilator_community_400x125-min.png[,400,125]
-^.^| *Community Driven & Openly Licensed*
-+++ <br/> +++ &bullet; Guided by the https://chipsalliance.org/[CHIPS Alliance] and https://www.linuxfoundation.org/[Linux Foundation]
-+++ <br/> +++ &bullet; Open, and free as in both speech and beer
-+++ <br/> +++ &bullet; More simulation for your verification budget
-
-^.^| *Commercial Support Available*
-+++ <br/> +++ &bullet; Commercial support contracts
-+++ <br/> +++ &bullet; Design support contracts
-+++ <br/> +++ &bullet; Enhancement contracts
-<.^|image:https://www.veripool.org/img/verilator_support_400x125-min.png[,400,125]
-
-|===
-
-== What Verilator Does
-
-Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
-"Verilates" the specified Verilog or SystemVerilog code by
-reading it, performing lint checks, and optionally inserting assertion
-checks and coverage-analysis points.  It outputs single- or multi-threaded
-.cpp and .h files, the "Verilated" code.
-
-The user writes a little {cpp}/SystemC wrapper file, which instantiates the
-"Verilated" model of the user's top level module.  These {cpp}/SystemC
-files are then compiled by a {cpp} compiler (gcc/clang/MSVC++).  The
-resulting executable performs the design simulation.  Verilator also
-supports linking its generated libraries, optionally encrypted, into other
-simulators.
-
-Verilator may not be the best choice if you are expecting a full featured
-replacement for NC-Verilog, VCS or another commercial Verilog simulator, or
-if you are looking for a behavioral Verilog simulator e.g. for a quick
-class project (we recommend http://iverilog.icarus.com[Icarus Verilog] for
-this.)  However, if you are looking for a path to migrate SystemVerilog to
-{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 module.  The results are a compiled
-Verilog model that executes even on a single-thread over 10x faster than
-standalone SystemC, and on a single thread is about 100 times faster than
-interpreted Verilog simulators such as http://iverilog.icarus.com[Icarus
-Verilog]. Another 2-10x speedup might be gained from multithreading
-(yielding 200-1000x total over interpreted simulators).
-
-Verilator has typically similar or better performance versus the
-closed-source Verilog simulators (Carbon Design Systems Carbonator,
-Modelsim, Cadence Incisive/NC-Verilog, Synopsys VCS, VTOC, and Pragmatic
-CVer/CVC). But, Verilator is open-sourced, so you can spend on computes
-rather than licenses. Thus Verilator gives you the best cycles/dollar.
-
-For more information on how Verilator stacks up to some of the other
-closed-sourced and open-sourced Verilog simulators, see the
-https://www.veripool.org/verilog_sim_benchmarks.html[Verilog Simulator
-Benchmarks].  (If you benchmark Verilator, please see the notes in the
-https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)], and also
-if possible post on the forums the results; there may be additional tweaks
-possible.)
-
-== Installation & Documentation
-
-For more information:
-
-* {link_verilator_install}[Verilator installation and package directory
-  structure]
-
-* 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]
-
-== Support
-
-Verilator is a community project, guided by the
-https://chipsalliance.org/[CHIPS Alliance] under the
-https://www.linuxfoundation.org/[Linux Foundation].
-
-We appreciate and welcome your contributions in whatever form; please see
-{link_verilator_contributing}[Contributing to Verilator].  Thanks to our
-https://verilator.org/verilator_doc.html#CONTRIBUTORS[Contributors and
-Sponsors].
-
-Verilator also supports and encourages commercial support models and
-organizations; please see {link_verilator_commercial_support}[Verilator
-Commercial Support].
-
-== Related Projects
-
-* http://gtkwave.sourceforge.net/[GTKwave] - Waveform viewer for Verilator
-traces.
-
-* http://iverilog.icarus.com[Icarus Verilog] - Icarus is a full featured
-interpreted Verilog simulator. If Verilator does not support your needs,
-perhaps Icarus may.
-
-== Open License
-
-Verilator is Copyright 2003-2020 by Wilson Snyder.  (Report bugs to
-https://verilator.org/issues[Verilator Issues].)
-
-Verilator is free software; you can redistribute it and/or modify it under
-the terms of either the GNU Lesser General Public License Version 3 or the
-Perl Artistic License Version 2.0.  See the documentation for more
-details.

README.rst

@@ -0,0 +1,160 @@
+.. Github doesn't render images unless absolute URL
+.. Do not know of a conditional tag, "only: github" nor "github display" works
+
+.. image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
+    :target: https://www.gnu.org/licenses/lgpl-3.0]
+.. image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
+    :target: https://opensource.org/licenses/Artistic-2.0
+.. image:: https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f
+    :target: https://www.codacy.com/gh/verilator/verilator
+.. image:: https://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg
+    :target: https://codecov.io/gh/verilator/verilator
+.. image:: https://github.com/verilator/verilator/workflows/build/badge.svg
+    :target: https://github.com/verilator/verilator/actions?query=workflow%3Abuild
+
+Welcome to Verilator
+====================
+
+.. list-table::
+
+   * - **Welcome to Verilator, the fastest Verilog/SystemVerilog simulator.**
+        * Accepts synthesizable Verilog or SystemVerilog
+        * Performs lint code-quality checks
+        * Compiles into multithreaded C++, or SystemC
+        * Creates XML to front-end your own tools
+     - |Logo|
+   * - |verilator multithreaded performance bg min|
+     - **Fast**
+        * Outperforms many commercial simulators
+        * Single- and multi-threaded output models
+   * - **Widely Used**
+        * Wide industry and academic deployment
+        * Out-of-the-box support from Arm, and RISC-V vendor IP
+     - |verilator usage 400x200 min|
+   * - |verilator community 400x125 min|
+     - **Community Driven & Openly Licensed**
+        * Guided by the `CHIPS Alliance`_ and `Linux Foundation`_
+        * Open, and free as in both speech and beer
+        * More simulation for your verification budget
+   * - **Commercial Support Available**
+        * Commercial support contracts
+        * Design support contracts
+        * Enhancement contracts
+     - |verilator support 400x125 min|
+
+
+What Verilator Does
+===================
+
+Verilator is invoked with parameters similar to GCC or Synopsys's VCS.  It
+"Verilates" the specified Verilog or SystemVerilog code by reading it,
+performing lint checks, and optionally inserting assertion checks and
+coverage-analysis points. It outputs single- or multi-threaded .cpp and .h
+files, the "Verilated" code.
+
+The user writes a little C++/SystemC wrapper file, which instantiates the
+"Verilated" model of the user's top level module. These C++/SystemC files
+are then compiled by a C++ compiler (gcc/clang/MSVC++). The resulting
+executable performs the design simulation. Verilator also supports linking
+its generated libraries, optionally encrypted, into other simulators.
+
+Verilator may not be the best choice if you are expecting a full featured
+replacement for NC-Verilog, VCS or another commercial Verilog simulator, or
+if you are looking for a behavioral Verilog simulator e.g. for a quick
+class project (we recommend `Icarus Verilog`_ for this.) However, if you
+are looking for a path to migrate SystemVerilog to C++ or SystemC, or your
+team is comfortable writing just a touch of C++ code, Verilator is the tool
+for you.
+
+
+Performance
+===========
+
+Verilator does not simply convert Verilog HDL to C++ or SystemC. Rather,
+Verilator compiles your code into a much faster optimized and optionally
+thread-partitioned model, which is in turn wrapped inside a C++/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 `Icarus Verilog`_. Another 2-10x speedup might be gained from
+multithreading (yielding 200-1000x total over interpreted simulators).
+
+Verilator has typically similar or better performance versus the
+closed-source Verilog simulators (Carbon Design Systems Carbonator,
+Modelsim, Cadence Incisive/NC-Verilog, Synopsys VCS, VTOC, and Pragmatic
+CVer/CVC). But, Verilator is open-sourced, so you can spend on computes
+rather than licenses. Thus Verilator gives you the best cycles/dollar.
+
+For more information on how Verilator stacks up to some of the other
+closed-sourced and open-sourced Verilog simulators, see the `Verilog
+Simulator Benchmarks
+<https://www.veripool.org/verilog_sim_benchmarks.html>`_.  (If you
+benchmark Verilator, please see the notes in the `Verilator manual (PDF)
+<https://verilator.org/verilator_doc.pdf>`_, and also if possible post on
+the forums the results; there may be additional tweaks possible.)
+
+
+Installation & Documentation
+============================
+
+For more information:
+
+- `Verilator installation and package directory structure
+  <https://verilator.org/install>`_
+
+- `Verilator manual (HTML) <https://verilator.org/verilator_doc.html>`_,
+  or `Verilator manual (PDF) <https://verilator.org/verilator_doc.pdf>`_
+
+- `Subscribe to verilator announcements
+  <https://github.com/verilator/verilator-announce>`_
+
+- `Verilator forum <https://verilator.org/forum>`_
+
+- `Verilator issues <https://verilator.org/issues>`_
+
+
+Support
+=======
+
+Verilator is a community project, guided by the `CHIPS Alliance`_ under the
+`Linux Foundation`_.
+
+We appreciate and welcome your contributions in whatever form; please see
+`Contributing to Verilator
+<https://github.com/verilator/verilator/blob/master/docs/CONTRIBUTING.rst>`_.
+Thanks to our `Contributors and Sponsors
+<https://verilator.org/verilator_doc.html#CONTRIBUTORS>`_.
+
+Verilator also supports and encourages commercial support models and
+organizations; please see `Verilator Commercial Support
+<https://verilator.org/verilator_commercial_support>`_.
+
+
+Related Projects
+================
+
+- `GTKwave <http://gtkwave.sourceforge.net/>`_ - Waveform viewer for
+  Verilator traces.
+
+- `Icarus Verilog`_ - Icarus is a full featured interpreted Verilog
+  simulator. If Verilator does not support your needs, perhaps Icarus may.
+
+
+Open License
+============
+
+Verilator is Copyright 2003-2021 by Wilson Snyder. (Report bugs to
+`Verilator Issues <https://verilator.org/issues>`_.)
+
+Verilator is free software; you can redistribute it and/or modify it under
+the terms of either the GNU Lesser General Public License Version 3 or the
+Perl Artistic License Version 2.0. See the documentation for more details.
+
+.. _CHIPS Alliance: https://chipsalliance.org
+.. _Icarus Verilog: http://iverilog.icarus.com
+.. _Linux Foundation: https://www.linuxfoundation.org
+.. |Logo| image:: https://www.veripool.org/img/verilator_256_200_min.png
+.. |verilator multithreaded performance bg min| image:: https://www.veripool.org/img/verilator_multithreaded_performance_bg-min.png
+.. |verilator usage 400x200 min| image:: https://www.veripool.org/img/verilator_usage_400x200-min.png
+.. |verilator community 400x125 min| image:: https://www.veripool.org/img/verilator_community_400x125-min.png
+.. |verilator support 400x125 min| image:: https://www.veripool.org/img/verilator_support_400x125-min.png

bin/verilator

@@ -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.
@@ -76,7 +76,8 @@ if ($opt_gdbbt && !gdb_works()) {
 my @quoted_sw = map {sh_escape($_)} @Opt_Verilator_Sw;
 if ($opt_gdb) {
     # Generic GDB interactive
-    run (($ENV{VERILATOR_GDB}||"gdb")
+    run (aslr_off()
+         .($ENV{VERILATOR_GDB}||"gdb")
          ." ".verilator_bin()
          # Note, uncomment to set breakpoints before running:
          #  ." -ex 'break main'"
@@ -91,16 +92,22 @@ if ($opt_gdb) {
          ." -ex 'bt'");
 } elsif ($opt_rr) {
     # Record with rr
-    run ("rr record ".verilator_bin()
+    run (aslr_off()
+         ."rr record ".verilator_bin()
          ." ".join(' ', @quoted_sw));
 } elsif ($opt_gdbbt && $Debug) {
     # Run under GDB to get gdbbt
-    run ("gdb"
+    run (aslr_off()
+         ."gdb"
          ." ".verilator_bin()
          ." --batch --quiet --return-child-result"
          ." -ex \"run ".join(' ', @quoted_sw)."\""
          ." -ex 'set width 0'"
          ." -ex 'bt' -ex 'quit'");
+} elsif ($Debug) {
+    # Debug
+    run(aslr_off()
+        .verilator_bin()." ".join(' ',@quoted_sw));
 } else {
     # Normal, non gdb
     run(verilator_bin()." ".join(' ',@quoted_sw));
@@ -165,6 +172,15 @@ sub gdb_works {
     return $status==0;
 }
 
+sub aslr_off {
+    my $ok = `setarch --addr-no-randomize echo ok 2>/dev/null` || "";
+    if ($ok =~ /ok/) {
+        return "setarch --addr-no-randomize ";
+    } else {
+        return "";
+    }
+}
+
 sub run {
     # Run command, check errors
     my $command = shift;
@@ -327,6 +343,7 @@ arguments.
     --generate-key              Create random key for --protect-key
     --getenv <var>              Get environment variable with defaults
     --help                      Display this help
+    --hierarchical              Enable hierarchical Verilation
      -I<dir>                    Directory to search for includes
      -j <jobs>                  Parallelism for --build
     --gate-stmts <value>        Tune gate optimizer depth
@@ -392,6 +409,7 @@ arguments.
     --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
     --timescale <timescale>     Sets default timescale
     --timescale-override <timescale>  Overrides all timescales
+    --top <topname>             Alias of --top-module
     --top-module <topname>      Name of top level input module
     --trace                     Enable waveform creation
     --trace-coverage            Enable tracing of coverage
@@ -437,11 +455,11 @@ ARGUMENTS"> for the detailed description of these arguments.
      +verilator+debug                  Enable debugging
      +verilator+debugi+<value>         Enable debugging at a level
      +verilator+help                   Display help
-     +verilator+prof+threads+file+I<filename>  Set profile filename
-     +verilator+prof+threads+start+I<value>    Set profile starting point
-     +verilator+prof+threads+window+I<value>   Set profile duration
-     +verilator+rand+reset+I<value>    Set random reset technique
-     +verilator+seed+I<value>          Set random seed
+     +verilator+prof+threads+file+<filename>  Set profile filename
+     +verilator+prof+threads+start+<value>    Set profile starting point
+     +verilator+prof+threads+window+<value>   Set profile duration
+     +verilator+rand+reset+<value>     Set random reset technique
+     +verilator+seed+<value>           Set random seed
      +verilator+noassert               Disable assert checking
      +verilator+V                      Verbose version and config
      +verilator+version                Show version and exit
@@ -738,7 +756,7 @@ is fairly standard across Verilog tools while -D is similar to GCC.
 
 Select the debug executable of Verilator (if available), and enable more
 internal assertions (equivalent to C<--debug-check>), debugging messages
-(equivalent to C<--debugi 4>), and intermediate form dump files (equivalent
+(equivalent to C<--debugi 3>), and intermediate form dump files (equivalent
 to C<--dump-treei 3>).
 
 =item --debug-check
@@ -951,6 +969,12 @@ immediately. This can be useful in makefiles. See also -V, and the various
 
 Displays this message and program version and exits.
 
+=item --hierarchical
+
+Enable hierarchical Verilation otherwise /*verilator hier_block*/ metacomment
+is ignored.
+See L</"HIERARCHICAL VERILATION">.
+
 =item -II<dir>
 
 See -y.
@@ -1237,8 +1261,8 @@ With -E, show comments in preprocessor output.
 =item --prefix I<topname>
 
 Specifies the name of the top level class and makefile.  Defaults to V
-prepended to the name of the --top-module switch, or V prepended to the
-first Verilog filename passed on the command line.
+prepended to the name of the --top switch, or V prepended to the first
+Verilog filename passed on the command line.
 
 =item --prof-cfuncs
 
@@ -1438,7 +1462,7 @@ future version of Verilator no longer always packs unpacked structures.
 =item -sv
 
 Specifies SystemVerilog language features should be enabled; equivalent to
-"--language 1800-2005".  This option is selected by default, it exists for
+"--language 1800-2017".  This option is selected by default, it exists for
 compatibility with other simulators.
 
 =item  +systemverilogext+I<ext>
@@ -1500,6 +1524,8 @@ sc_set_time_resolution, or the C++ code instantiating the Verilated module.
 As 1fs is the finest time precision it may be desirable to always use a
 precision of 1fs.
 
+=item --top I<topname>
+
 =item --top-module I<topname>
 
 When the input Verilog contains more than one top level module, specifies
@@ -1613,8 +1639,8 @@ into Verilator.  (Similar to perl -V.)  See also --getenv.
 =item -v I<filename>
 
 Read the filename as a Verilog library.  Any modules in the file may be
-used to resolve cell instantiations in the top level module, else ignored.
-Note -v is fairly standard across Verilog tools.
+used to resolve instances in the top level module, else ignored.  Note -v
+is fairly standard across Verilog tools.
 
 =item --no-verilate
 
@@ -1691,7 +1717,7 @@ than using this option.
 
 Disable all lint related warning messages, and all style warnings.  This is
 equivalent to "-Wno-ALWCOMBORDER -Wno-BSSPACE -Wno-CASEINCOMPLETE
--Wno-CASEOVERLAP -Wno-CASEX -Wno-CASEWITHX -Wno-CMPCONST -Wno-COLONPLUS
+-Wno-CASEOVERLAP -Wno-CASEX -Wno-CASTCONST -Wno-CASEWITHX -Wno-CMPCONST -Wno-COLONPLUS
 -Wno-ENDLABEL -Wno-IMPLICIT -Wno-LITENDIAN -Wno-PINCONNECTEMPTY
 -Wno-PINMISSING -Wno-SYNCASYNCNET -Wno-UNDRIVEN -Wno-UNSIGNED -Wno-UNUSED
 -Wno-WIDTH" plus the list shown for Wno-style.
@@ -1723,7 +1749,7 @@ Enables the specified warning message.
 Enable all lint related warning messages (note by default they are already
 enabled), but do not affect style messages.  This is equivalent to
 "-Wwarn-ALWCOMBORDER -Wwarn-BSSPACE -Wwarn-CASEINCOMPLETE
--Wwarn-CASEOVERLAP -Wwarn-CASEX -Wwarn-CASEWITHX -Wwarn-CMPCONST
+-Wwarn-CASEOVERLAP -Wwarn-CASEX -Wwarn-CASTCONST -Wwarn-CASEWITHX -Wwarn-CMPCONST
 -Wwarn-COLONPLUS -Wwarn-ENDLABEL -Wwarn-IMPLICIT -Wwarn-LITENDIAN
 -Wwarn-PINMISSING -Wwarn-REALCVT -Wwarn-UNSIGNED -Wwarn-WIDTH".
 
@@ -1927,7 +1953,8 @@ Displays program version and exits.
 
 =head1 EXAMPLE C++ EXECUTION
 
-We'll compile this example into C++.
+We'll compile this example into C++.  For an extended and commented version
+of what this C++ code is doing, see examples/make_tracing_c/sim_main.cpp.
 
     mkdir test_our
     cd test_our
@@ -1942,21 +1969,24 @@ We'll compile this example into C++.
       #include "Vour.h"
       #include "verilated.h"
       int main(int argc, char** argv, char** env) {
-          Verilated::commandArgs(argc, argv);
-          Vour* top = new Vour;
-          while (!Verilated::gotFinish()) { top->eval(); }
+          VerilatedContext* contextp = new VerilatedContext;
+          contextp->commandArgs(argc, argv);
+          Vour* top = new Vour{contextp};
+          while (!contextp->gotFinish()) { top->eval(); }
           delete top;
-          exit(0);
+          delete contextp;
+          return 0;
       }
     EOF
 
-See the README in the source kit for various ways to install or point to
-Verilator binaries.  In brief, if you installed Verilator using the package
-manager of your operating system, or did a "make install" to place
-Verilator into your default path, you do not need anything special in your
-environment, and should not have VERILATOR_ROOT set.  However, if you
-installed Verilator from sources and want to run Verilator out of where you
-compiled Verilator, you need to point to the kit:
+Next we need Verilator installed.  See the README in the source kit for
+various ways to install or point to Verilator binaries.  In brief, if you
+installed Verilator using the package manager of your operating system, or
+did a "make install" to place Verilator into your default path, you do not
+need anything special in your environment, and should not have
+VERILATOR_ROOT set.  However, if you installed Verilator from sources and
+want to run Verilator out of where you compiled Verilator, you need to
+point to the kit:
 
     # See above; don't do this if using an OS-distributed Verilator
     export VERILATOR_ROOT=/path/to/where/verilator/was/installed
@@ -1973,14 +2003,15 @@ section below for descriptions of some of the files that were created.
 
 (Verilator included a default compile rule and link rule, since we used
 --exe and passed a .cpp file on the Verilator command line.  Verilator also
-then used C<make> to build a final executable.  You can also write your own
-compile rules, and run make yourself as we'll show in the SYSTEMC section.)
+then used C<make> to build a final executable, since we used --build.  You
+can also write your own compile rules, and run make yourself as we'll show
+in the SYSTEMC section.
 
-And now we run it
+And now we run it:
 
     obj_dir/Vour
 
-And we get as output
+And we get as output:
 
     Hello World
     - our.v:2: Verilog $finish
@@ -2010,13 +2041,12 @@ This is an example similar to the above, but using SystemC.
       #include "Vour.h"
       int sc_main(int argc, char** argv) {
           Verilated::commandArgs(argc, argv);
-          sc_clock clk ("clk", 10, 0.5, 3, true);
-          Vour* top;
-          top = new Vour("top");
+          sc_clock clk{"clk", 10, SC_NS, 0.5, 3, SC_NS, true};
+          Vour* top = new Vour{"top"};
           top->clk(clk);
           while (!Verilated::gotFinish()) { sc_start(1, SC_NS); }
           delete top;
-          exit(0);
+          return 0;
       }
     EOF
 
@@ -2074,15 +2104,15 @@ When using SystemC, evaluation of the Verilated model is managed by the SystemC
 kernel, and for the most part can be ignored.  When using C++, the user
 must call eval(), or eval_step() and eval_end_step().
 
-1. When there is a single design instantiated at the C++ level that needs to
-evaluate, just call designp->eval().
+1. When there is a single design instantiated at the C++ level that needs
+to evaluate within a given context, just call designp->eval().
 
-2. When there are multiple designs instantiated at the C++ level that
-need to evaluate, call first_designp->eval_step() then ->eval_step() on all
-other designs.  Then call ->eval_end_step() on the first design then all
-other designs.  If there is only a single design, you would call
-eval_step() then eval_end_step(); in fact eval() described above is just a
-wrapper which calls these two functions.
+2. When there are multiple designs instantiated at the C++ level that need
+to evaluate within a context, call first_designp->eval_step() then
+->eval_step() on all other designs.  Then call ->eval_end_step() on the
+first design then all other designs.  If there is only a single design, you
+would call eval_step() then eval_end_step(); in fact eval() described above
+is just a wrapper which calls these two functions.
 
 When eval() is called Verilator looks for changes in clock signals and
 evaluates related sequential always blocks, such as computing always_ff @
@@ -2097,7 +2127,7 @@ or all inputs go directly to always_ff statements, as is typical, then you
 can change non-clock inputs on the negative edge of the input clock, which
 will be faster as there will be fewer eval() calls.
 
-For more information on evaluation, see docs/internals.adoc in the
+For more information on evaluation, see docs/internals.rst in the
 distribution.
 
 
@@ -2208,10 +2238,13 @@ For --make gmake, it creates:
 
     {prefix}.mk                         // Make include file for compiling
     {prefix}_classes.mk                 // Make include file with class names
+    {prefix}_hier.mk                    // Make file for hierarchy blocks
+    {prefix}_hierMkArgs.f               // Arguments for hierarchical Verilation.
 
 For --make cmake, it creates:
 
     {prefix}.cmake                      // CMake include script for compiling
+    {prefix}_hierCMakeArgs.f            // Arguments for hierarchical Verilation.
 
 For -cc and -sc mode, it also creates:
 
@@ -2223,6 +2256,13 @@ For -cc and -sc mode, it also creates:
     {prefix}{each_verilog_module}.h     // Lower level internal header files
     {prefix}{each_verilog_module}{__n}.cpp   // Additional lower C++ files (--output-split)
 
+For --hierarchy mode, it creates:
+    {prefix}__hierVer.d                 // Make dependencies of the top module in the
+                                           hierarchical Verilation
+    {prefix}__hier.dir/                 // Directory to store .dot, .vpp, .tree of the
+                                           top module in the hierarchical Verilation
+    V{hier_block}/                      // Directory to Verilate each hierarchy block
+
 In certain debug and other modes, it also creates:
 
     {prefix}.xml                        // XML tree information (--xml)
@@ -2509,6 +2549,27 @@ called from Verilog by querying the scope of that function. See the
 sections on DPI Context Functions and DPI Header Isolation below and the
 comments within the svdpi.h header for more information.
 
+=head2 DPI Imports that access signals
+
+If a DPI import accesses a signal through the VPI Verilator will not be
+able to know what variables are accessed and may schedule the code
+inappropriately.  Ideally pass the values as inputs/outputs so the VPI is
+not required.  Alternatively a workaround is to use a non-inlined task as a
+wrapper:
+
+    logic din;
+
+    // This DPI function will read "din"
+    import "DPI-C" context function void dpi_that_accesses_din();
+
+    always @ (...)
+       dpi_din_args(din);
+
+    task dpi_din_args(input din);
+       /* verilator no_inline_task */
+       dpi_that_accesses_din();
+    endtask
+
 =head2 DPI Display Functions
 
 Verilator allows writing $display like functions using this syntax:
@@ -2646,7 +2707,7 @@ accesses the above signal "readme" would be:
               read_and_check();
           }
           delete top;
-          exit(0);
+          return 0;
       }
     EOF
 
@@ -2830,6 +2891,71 @@ here, use DIRECTORY or PREFIX.
 
 =back
 
+=head1 HIERARCHICAL VERILATION
+
+Large designs may take long (e.g. 10+ minutes) and huge memory (e.g. 100+GB)
+to Verilate. One workaround is hierarchical Verilation, it is to Verilate
+each moderate size of building blocks and finally combine the building blocks.
+The building block will be called "hierarchy block" later.
+
+The current hierarchical Verilation is based on protect-lib. Each hierarchy
+block is Verilated to protect-lib. User modules of the hierarchy blocks will see
+a tiny wrapper generated by protect-lib instead of the actual design.
+
+=head2 Usage
+
+All user need to do is mark moderate size of module as hierarchy block and pass
+--hierarchical option to verilator command.
+There are two ways to mark a module:
+
+  a) Write /* verilator hier_block */ metacomment in HDL code
+      See L</"LANGUAGE EXTENSIONS"> for more detail.
+  b) add hier_block line in the configuration file.
+     See C<hier_block> in L</"CONFIGURATION FILES"> for example.
+
+You don't have to take care of hierarchical blocks when compiling
+Verilated C++ code. You can compile as usual.
+    make -C obj_dir -f Vtop_module_name.mk
+
+See also "Overlapping Verilation and compilation" to get executable quickly.
+
+=head2 Limitations
+
+Because hierarchy blocks are Verilated to protect-lib, they have some
+ limitations such as:
+
+   The block cannot be accessed using dot (.) from upper module.
+   Signals in the block cannot be traced.
+   Modport cannot be used at the hirarchical block boundary.
+
+On the other hand, the following usage is supported.
+
+    - Nested hierarchy block. A hierarchy block may instantiate other
+      hierarchy blocks.
+    - Parameterized hierarchy block. Parameters of a hierarchy block can be
+      overridden using #(.param_name(value)) construct.
+
+The simulation speed may not be as fast as flat Verilation, in which
+all modules are globally scheduled.
+
+=head2 Overlapping Verilation and compilation
+
+Verilator needs to run N + 2 times in hierarchical Verilation, where N is
+the number of hierarchy blocks.
+1 of 2 is for the top module which refers wrappers of all other hierarchy
+blocks.
+The other 1 of 2 is the initial run that searches modules marked with
+/*verilator hier_block*/ metacomment and creates a plan and write in
+(prefix)_hier.mk.
+This initial run internally invokes other N + 1 runs, so you don't have
+to care about these N + 1 times of run.
+
+If -j <jobs> option is specified, Verilation for hierarchy blocks
+runs in parallel.
+
+If --build option is also specified, C++ compilation also runs as soon as
+a hierarchy block is Verilated. C++ compilation and Verilation for
+other hierarchy blocks run simultaneously.
 
 =head1 MULTITHREADING
 
@@ -3002,8 +3128,8 @@ Enable/disable waveform tracing for all future signals declared in the
 specified filename (or wildcard with '*' or '?', or all files if omitted)
 and range of line numbers (or all lines if omitted).
 
-For tracing_off, cells below any module in the files/ranges specified will
-also not be traced.
+For tracing_off, instances below any module in the files/ranges specified
+will also not be traced.
 
 =item clock_enable -module "<modulename>" -var "<signame>"
 
@@ -3049,6 +3175,12 @@ formally prove the directive to be true, or failing that, will insert
 the appropriate code to detect failing cases at simulation runtime and
 print an "Assertion failed" error message.
 
+=item hier_block -module "<modulename>"
+
+Specifies that the module is a unit of hierarchical Verilation.
+Note that the setting is ignored unless --hierachical option is specified.
+See L</"HIERARCHICAL VERILATION"> for more information.
+
 =item inline -module "<modulename>"
 
 Specifies the module may be inlined into any modules that use this module.
@@ -3397,6 +3529,17 @@ Specifies that following lines of code should have coverage re-enabled (if
 appropriate --coverage flags are passed) after being disabled earlier with
 /*verilator coverage_off*/.
 
+=item /*verilator hier_block*/
+
+Specifies that the module is a unit of hierarchical Verilation.
+This metacomment must be between
+ "module module_name(...);" and "endmodule".
+The module will not be inlined nor uniquified for each instance in
+hierarchical Verilation.
+Note that the metacomment is ignored unless --hierachical option is specified.
+
+See L</"HIERARCHICAL VERILATION"> for more information.
+
 =item /*verilator inline_module*/
 
 Specifies the module the comment appears in may be inlined into any modules
@@ -3591,10 +3734,11 @@ for more information.
 
 =item /*verilator sc_clock*/
 
-Deprecated.  Used after an input declaration to indicate the signal
-should be declared in SystemC as a sc_clock instead of a bool.  This was
-needed in SystemC 1.1 and 1.2 only; versions 2.0 and later do not require
-clock pins to be sc_clocks and this is no longer needed.
+Deprecated and ignored.  Previously used after an input declaration to
+indicate the signal should be declared in SystemC as a sc_clock instead of
+a bool.  This was needed in SystemC 1.1 and 1.2 only; versions 2.0 and
+later do not require clock pins to be sc_clocks and this is no longer
+needed and is ignored.
 
 =item /*verilator sc_bv*/
 
@@ -3657,13 +3801,13 @@ for use by downstream applications.
 =item /*verilator tracing_off*/
 
 Disable waveform tracing for all future signals that are declared in this
-module, or cells below this module.  Often this is placed just after a
-primitive's module statement, so that the entire module and cells below it
-are not traced.
+module, or instances below this module.  Often this is placed just after a
+primitive's module statement, so that the entire module and instances below
+it are not traced.
 
 =item /*verilator tracing_on*/
 
-Re-enable waveform tracing for all future signals or cells that are
+Re-enable waveform tracing for all future signals or instances that are
 declared.
 
 =back
@@ -3717,8 +3861,8 @@ for example a[2].b is acceptable, while a[x].b is generally not.
 
 References into generated and arrayed instances use the instance names
 specified in the Verilog standard; arrayed instances are named
-{cellName}[{instanceNumber}] in Verilog, which becomes
-{cellname}__BRA__{instanceNumber}__KET__ inside the generated C++ code.
+{instanceName}[{instanceNumber}] in Verilog, which becomes
+{instanceName}__BRA__{instanceNumber}__KET__ inside the generated C++ code.
 
 =head2 Latches
 
@@ -3975,9 +4119,10 @@ is ignored, only a single trace file may be active at once.
 $dumpall/$dumpportsall, $dumpon/$dumpportson, $dumpoff/$dumpportsoff, and
 $dumplimit/$dumpportlimit are currently ignored.
 
-=item $finish, $stop
+=item $exit, $finish, $stop
 
-The rarely used optional parameter to $finish and $stop is ignored.
+The rarely used optional parameter to $finish and $stop is ignored. $exit
+is aliased to $finish.
 
 =item $fopen, $fclose, $fdisplay, $ferror, $feof, $fflush, $fgetc, $fgets,
 $fscanf, $fwrite, $fscanf, $sscanf
@@ -3989,16 +4134,12 @@ $setup, $setuphold, $skew, $timeskew, $width
 
 All specify blocks and timing checks are ignored.
 
-=item $monitor, $strobe
+=item $random, $urandom, $urandom_range
 
-Monitor and strobe are not supported, convert to always_comb $display or
-similar.
-
-=item $random
-
-$random does not support the optional argument to set the seed.  Use the
-srand function in C to accomplish this, and note there is only one random
-number generator (not one per module).
+Use +verilator+seed argument to set the seed if there is no $random or
+$urandom optional argument to set the seed.  There is one random seed per C
+thread, not per module for $random, nor per object for random stability of
+$urandom/$urandom_range.
 
 =item $readmemb, $readmemh
 
@@ -4099,17 +4240,7 @@ default as a code style warning.
 =item BLKANDNBLK
 
 BLKANDNBLK is an error that a variable comes from a mix of blocking and
-non-blocking assignments.  Generally, this is caused by a register driven
-by both combo logic and a flop:
-
-      always @ (posedge clk)  foo[0] <= ...
-      always @* foo[1] = ...
-
-Simply use a different register for the flop:
-
-      always @ (posedge clk)  foo_flopped[0] <= ...
-      always @* foo[0] = foo_flopped[0];
-      always @* foo[1] = ...
+non-blocking assignments.
 
 This is not illegal in SystemVerilog, but a violation of good coding
 practice. Verilator reports this as an error, because ignoring this warning
@@ -4120,6 +4251,24 @@ BLKANDNBLK" metacomment or the -Wno-BLKANDNBLK option) when one of the
 assignments is inside a public task, or when the blocking and non-blocking
 assignments have non-overlapping bits and structure members.
 
+Generally, this is caused by a register driven by both combo logic and a
+flop:
+
+      logic [1:0] foo;
+      always @ (posedge clk)  foo[0] <= ...
+      always @* foo[1] = ...
+
+Simply use a different register for the flop:
+
+      logic [1:0] foo;
+      always @ (posedge clk)  foo_flopped[0] <= ...
+      always @* foo[0] = foo_flopped[0];
+      always @* foo[1] = ...
+
+Or, this may also avoid the error:
+
+      logic [1:0] foo /*verilator split_var*/;
+
 =item BLKSEQ
 
 This indicates that a blocking assignment (=) is used in a sequential
@@ -4192,15 +4341,6 @@ not overlap.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
 
-=item CASEX
-
-Warns that it is simply better style to use casez, and C<?> in place of
-C<x>'s.  See
-L<http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase_rev1_1.pdf>
-
-Ignoring this warning will only suppress the lint check, it will simulate
-correctly.
-
 =item CASEWITHX
 
 Warns that a case statement contains a constant with a C<x>.  Verilator is
@@ -4211,6 +4351,25 @@ instead intended is to use a casez with C<?>.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
 
+=item CASEX
+
+Warns that it is simply better style to use casez, and C<?> in place of
+C<x>'s.  See
+L<http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase_rev1_1.pdf>
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
+=item CASTCONST
+
+Warns that a dynamic cast ($cast) is unnecessary as the $cast will always
+succeed or fail.  If it will always fail, the $cast is useless. If it will
+always succeed a static cast may be preferred.
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.  On other simulators, not fixing CASTCONST may result in
+decreased performance.
+
 =item CDCRSTLOGIC
 
 With --cdc only, warns that asynchronous flop reset terms come from other
@@ -4348,6 +4507,10 @@ Deprecated and no longer used as a warning.  Used to indicate that the
 specified signal was is generated inside the model, and also being used as
 a clock.
 
+=item HIERBLOCK
+
+Warns that the top module is marked as a hierarchy block
+by hier_block metacomment, which is not legal.  This setting on the top module will be ignored.
 =item IFDEPTH
 
 Warns that if/if else statements have exceeded the depth specified with
@@ -4384,9 +4547,9 @@ top module statement is processed.
 Warns that a wire is being implicitly declared (it is a single bit wide
 output from a sub-module.)  While legal in Verilog, implicit declarations
 only work for single bit wide signals (not buses), do not allow using a
-signal before it is implicitly declared by a cell, and can lead to dangling
-nets.  A better option is the /*AUTOWIRE*/ feature of Verilog-Mode for
-Emacs, available from L<https://www.veripool.org/verilog-mode>
+signal before it is implicitly declared by an instance, and can lead to
+dangling nets.  A better option is the /*AUTOWIRE*/ feature of Verilog-Mode
+for Emacs, available from L<https://www.veripool.org/verilog-mode>
 
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
@@ -4452,6 +4615,16 @@ exposed is acceptable.
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
 
+=item LATCH
+
+Warns that a signal is not assigned in all control paths of a combinational
+always block, resulting in the inference of a latch. For intentional
+latches, consider using the always_latch (SystemVerilog) keyword instead.
+The warning may be disabled with a lint_off pragma around the always block.
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
 =item LITENDIAN
 
 Warns that a packed vector is declared with little endian bit numbering
@@ -4459,10 +4632,10 @@ Warns that a packed vector is declared with little endian bit numbering
 and little numbering is now thus often due to simple oversight instead of
 intent.
 
-Also warns that a cell is declared with little endian range (i.e. [0:7] or
-[7]) and is connected to a N-wide signal. Based on IEEE the bits will
-likely be backwards from what you expect (i.e. cell [0] will connect to
-signal bit [N-1] not bit [0]).
+Also warns that an instance is declared with little endian range
+(i.e. [0:7] or [7]) and is connected to a N-wide signal. Based on IEEE the
+bits will likely be backwards from what you expect (i.e. instance [0] will
+connect to signal bit [N-1] not bit [0]).
 
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
@@ -4494,18 +4667,18 @@ instantiated by any other module, and both modules were put on the command
 line (not in a library). Three likely cases:
 
 1. A single module is intended to be the top. This warning then occurs
-because some low level cell is being read in, but is not really needed as
-part of the design.  The best solution for this situation is to ensure that
-only the top module is put on the command line without any flags, and all
-remaining library files are read in as libraries with -v, or are
+because some low level instance is being read in, but is not really needed
+as part of the design.  The best solution for this situation is to ensure
+that only the top module is put on the command line without any flags, and
+all remaining library files are read in as libraries with -v, or are
 automatically resolved by having filenames that match the module names.
 
 2. A single module is intended to be the top, the name of it is known, and
 all other modules should be ignored if not part of the design.  The best
-solution is to use the --top-module option to specify the top module's
-name. All other modules that are not part of the design will be for the
-most part ignored (they must be clean in syntax and their contents will be
-removed as part of the Verilog module elaboration process.)
+solution is to use the --top option to specify the top module's name. All
+other modules that are not part of the design will be for the most part
+ignored (they must be clean in syntax and their contents will be removed as
+part of the Verilog module elaboration process.)
 
 3. Multiple modules are intended to be design tops, e.g. when linting a
 library file.  As multiple modules are desired, disable the MULTITOP
@@ -4515,38 +4688,57 @@ based on the top module name followed by __02E (a Verilator-encoded ASCII
 ".').  This renaming is done even if the two modules' signals seem
 identical, e.g. multiple modules with a "clk" input.
 
+=item NOLATCH
+
+Warns that no latch was detected in an always_latch block. The warning may
+be disabled with a lint_off pragma around the always block, but recoding
+using a regular always may be more appropriate.
+
+Ignoring this warning will only suppress the lint check, it will simulate
+correctly.
+
 =item PINCONNECTEMPTY
 
-Warns that a cell instantiation has a pin which is connected to
-.pin_name(), e.g. not another signal, but with an explicit mention of the
-pin.  It may be desirable to disable PINCONNECTEMPTY, as this indicates
-intention to have a no-connect.
+Warns that an instance has a pin which is connected to .pin_name(),
+e.g. not another signal, but with an explicit mention of the pin.  It may
+be desirable to disable PINCONNECTEMPTY, as this indicates intention to
+have a no-connect.
 
 Disabled by default as this is a code style warning; it will simulate
 correctly.
 
 =item PINMISSING
 
-Warns that a module has a pin which is not mentioned in a cell
-instantiation.  If a pin is not missing it should still be specified on the
-cell declaration with a empty connection, using "(.pin_name())".
+Warns that a module has a pin which is not mentioned in an instance.  If a
+pin is not missing it should still be specified on the instance declaration
+with a empty connection, using "(.pin_name())".
 
 Ignoring this warning will only suppress the lint check, it will simulate
 correctly.
 
 =item PINNOCONNECT
 
-Warns that a cell instantiation has a pin which is not connected to another
-signal.
+Warns that an instance has a pin which is not connected to another signal.
 
 Disabled by default as this is a code style warning; it will simulate
 correctly.
 
+=item PKGNODECL
+
+Error that a package/class appears to have been referenced that has not yet
+been declared.  According to IEEE 1800-2017 26.3 all packages must be
+declared before being used.
+
 =item PROCASSWIRE
 
 Error that a procedural assignment is setting a wire. According to IEEE, a
 var/reg must be used as the target of procedural assignments.
 
+=item RANDC
+
+Warns that the 'randc' keyword is currently unsupported, and that it is
+being converted to 'rand'.
+
 =item REALCVT
 
 Warns that a real number is being implicitly rounded to an integer, with
@@ -4650,12 +4842,12 @@ correctly.
 
 =item TASKNSVAR
 
-Error when a call to a task or function has a output from that task tied to
+Error when a call to a task or function has an inout from that task tied to
 a non-simple signal.  Instead connect the task output to a temporary signal
 of the appropriate width, and use that signal to set the appropriate
 expression as the next statement.  For example:
 
-      task foo; output sig; ... endtask
+      task foo(inout sig); ... endtask
       always @* begin
            foo(bus_we_select_from[2]);  // Will get TASKNSVAR error
       end
@@ -4769,7 +4961,7 @@ potentially resolving the conflict. If you run with --report-unoptflat
 Verilator will suggest possible candidates for C<split_var>.
 
 The UNOPTFLAT warning may also be due to clock enables, identified from the
-reported path going through a clock gating cell.  To fix these, use the
+reported path going through a clock gating instance.  To fix these, use the
 clock_enable meta comment described above.
 
 The UNOPTFLAT warning may also occur where outputs from a block of logic
@@ -4828,10 +5020,10 @@ design simulate incorrectly; see the details under --bbox-unsup.
 
 =item UNUSED
 
-Warns that the specified signal is never used/consumed.  Verilator is
-fairly liberal in the usage calculations; making a signal public, a signal
-matching --unused-regexp ("*unused*") or accessing only a single array
-element marks the entire signal as used.
+Warns that the specified signal or parameter is never used/consumed.
+Verilator is fairly liberal in the usage calculations; making a signal
+public, a signal matching --unused-regexp ("*unused*") or accessing only a
+single array element marks the entire signal as used.
 
 Disabled by default as this is a code style warning; it will simulate
 correctly.
@@ -4932,19 +5124,15 @@ The following deprecated items are scheduled for future removal:
 
 =over 4
 
-=item Pre-C++11 compiler support
+=item C++11 compiler support
 
-Verilator supports pre-C++11 compilers for non-threaded models when
-configured with --enable-prec11/--enable-prec11-final.  This flag will be
-removed and C++11 compilers will be required for both compiling Verilator
-and compiling Verilated models no sooner than September 2020.
+Verilator currently requires C++11 or newer compilers.  Verilator will
+require C++14 or newer compilers for both compiling Verilator and compiling
+Verilated models no sooner than January 2022.
 
-=item SystemC 2.2 and earlier support
+=item --inhibit-sim
 
-Support for SystemC versions 2.2 and earlier including the related sc_clock
-variable attribute will be removed no sooner than September 2020.  The
-supported versions will be SystemC 2.3.0 (SYSTEMC_VERSION 20111121) and
-later (presently 2.3.0, 2.3.1, 2.3.2, 2.3.3).
+The --inhibit-sim option is planned for removal no sooner than July 2021.
 
 =item Configuration File -msg
 
@@ -5069,7 +5257,7 @@ want all data to land in the same output file.
         topp->trace(tfp, 99);  // Trace 99 levels of hierarchy
         tfp->open("obj_dir/t_trace_ena_cc/simx.vcd");
         ...
-        while (sc_time_stamp() < sim_time && !Verilated::gotFinish()) {
+        while (vl_time_stamp64() < sim_time && !Verilated::gotFinish()) {
             main_time += #;
             tfp->dump(main_time);
         }
@@ -5233,8 +5421,14 @@ controlled by --assert are disabled.
 
 =item Why do I get "undefined reference to `sc_time_stamp()'"?
 
-In C++ (non SystemC) code you need to define this function so that the
-simulator knows the current time.  See the "CONNECTING TO C++" examples.
+In 4.200 and later, using the timeInc function is recommended instead.  See
+the "CONNECTING TO C++" examples.  Some linkers (MSVC++) still require
+sc_time_stamp() to be defined, either define this with ("double
+sc_time_stamp() { return 0; }") or compile the Verilated code with
+-DVL_TIME_CONTEXT.
+
+Prior to Verilator 4.200, the sc_time_stamp function needs to be defined in
+C++ (non SystemC) to return the current simulation time.
 
 =item Why do I get "undefined reference to `VL_RAND_RESET_I' or `Verilated::...'"?
 
@@ -5352,21 +5546,21 @@ by your code or you'll get strange results.
 
 =item Should a module be in Verilog or SystemC?
 
-Sometimes there is a block that just interconnects cells, and have a choice
-as to if you write it in Verilog or SystemC.  Everything else being equal,
-best performance is when Verilator sees all of the design.  So, look at the
-hierarchy of your design, labeling cells as to if they are SystemC or
-Verilog.  Then:
+Sometimes there is a block that just interconnects instances, and have a
+choice as to if you write it in Verilog or SystemC.  Everything else being
+equal, best performance is when Verilator sees all of the design.  So, look
+at the hierarchy of your design, labeling instances as to if they are
+SystemC or Verilog.  Then:
 
-A module with only SystemC cells below must be SystemC.
+A module with only SystemC instances below must be SystemC.
 
-A module with a mix of Verilog and SystemC cells below must be SystemC. (As
-Verilator cannot connect to lower-level SystemC cells.)
+A module with a mix of Verilog and SystemC instances below must be
+SystemC. (As Verilator cannot connect to lower-level SystemC instances.)
 
-A module with only Verilog cells below can be either, but for best
+A module with only Verilog instances below can be either, but for best
 performance should be Verilog.  (The exception is if you have a design that
 is instantiated many times; in this case Verilating one of the lower
-modules and instantiating that Verilated cells multiple times into a
+modules and instantiating that Verilated instances multiple times into a
 SystemC module *may* be faster.)
 
 =back
@@ -5555,7 +5749,7 @@ remain anonymous.
 
 The latest version is available from L<https://verilator.org>.
 
-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 the Verilator internals under the terms of
 either the GNU Lesser General Public License Version 3 or the Perl Artistic
 License Version 2.0.
@@ -5572,7 +5766,7 @@ L<verilator_coverage>, L<verilator_gantt>, L<verilator_profcfunc>, L<make>,
 
 L<verilator --help> which is the source for this document,
 
-and docs/internals.adoc in the distribution.
+and docs/internals.rst in the distribution.
 
 =cut
 

bin/verilator_coverage

@@ -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.
@@ -158,22 +158,25 @@ verilator_coverage - Verilator coverage analyzer
 
     verilator_coverage  -write-info merged.info -read <datafiles>...
 
-Verilator_coverage processes Verilator coverage reports.
+Verilator_coverage processes Verilated model-generated coverage reports.
 
-With --anotate, it reads the specified data file and generates annotated
-source code with coverage metrics annotated.  If multiple coverage points
-exist on the same line, additional lines will be inserted to report the
-additional points.
+With --annotate, it reads the specified coverage data file and generates
+annotated source code with coverage metrics annotated.  If multiple
+coverage points exist on the same source code line, additional lines will
+be inserted to report the additional points.
 
-Additional Verilog-standard arguments specify the search paths necessary to
-find the source code that the coverage analysis was performed on.
+Additional Verilog-XL-style standard arguments specify the search paths
+necessary to find the source code that the coverage analysis was performed
+on.
 
-To get correct coverage percentages, you may wish to read logs/coverage.dat
-into Emacs and do a M-x keep-lines to include only those statistics of
-interest.
+To filter those items to be included in coverage, you may read
+logs/coverage.dat into an editor and do a M-x keep-lines to include only
+those statistics of interest and save to a new .dat file.
 
-For Verilog conditions that should never occur, you should add a $stop
-statement.  This will remove the coverage during the next build.
+For Verilog conditions that should never occur, either add a $stop
+statement to the appropriate statement block, or see the Verilator
+documentation on "// verilator coverage_off" and "coverage_off".  This will
+remove the coverage points after the model is re-Verilated.
 
 =head1 ARGUMENTS
 
@@ -181,12 +184,12 @@ statement.  This will remove the coverage during the next build.
 
 =item I<filename>
 
-Specify input data file, may be repeated to read multiple inputs.  If no
+Specify input data file. May be repeated to read multiple inputs.  If no
 data file is specified, by default coverage.dat is read.
 
 =item --annotate I<output_directory>
 
-Sprcifies the directory name that source files with annotated coverage data
+Specifies the directory name that source files with annotated coverage data
 should be written to.
 
 =item --annotate-all
@@ -278,7 +281,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.

bin/verilator_difftree

@@ -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.

bin/verilator_gantt

@@ -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);
@@ -465,9 +544,9 @@ scale printed, i.e. a certain about of time for each character width.  The
 Y-axis shows threads, each thread's execution is shown on one line.  That
 line shows "[" at the position in time when it executes.
 
-Following the "[" is the cpu number the task executed on, followed by zero
+Following the "[" is the CPU number the task executed on, followed by zero
 or more "-" to make the width of the characters match the scaled execution
-time, followed by a "]".  If the scale is too small, the cpu number and
+time, followed by a "]".  If the scale is too small, the CPU number and
 mtask number will not be printed.  If the scale is very small, a "&"
 indicates multiple mtasks started at that time position.
 
@@ -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.

bin/verilator_includer

@@ -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.

bin/verilator_profcfunc

@@ -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.

ci/ci-ccache-maint.bash

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# DESCRIPTION: Verilator: Travis CI ccache maintenance
+# 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
@@ -19,8 +19,8 @@ set -x
 ccache --version
 
 # Flush ccache if requested in commit message
-COMMIT="${TRAVIS_PULL_REQUEST_SHA:-$TRAVIS_COMMIT}"
-if git log --format=%B -n 1 "$COMMIT" | grep -q -i '\[travis\s\+ccache\s\+clear\]'; then
+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

ci/ci-install.bash

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# DESCRIPTION: Verilator: Travis CI dependency install script
+# 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
@@ -14,25 +14,23 @@
 # required by the particular build stage.
 ################################################################################
 
-# Note that Travis runs "apt-get update" when "apt-get install" is used in the
-# .travis.yml file directly, but since we invoke it via this script, we need to
-# run it manually where requried, otherwise some packages cannot be found.
-
 set -e
 set -x
 
+cd $(dirname "$0")/..
+
 fatal() {
   echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
 }
 
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+if [ "$CI_OS_NAME" = "linux" ]; then
   MAKE=make
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+elif [ "$CI_OS_NAME" = "osx" ]; then
   MAKE=make
-elif [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
+elif [ "$CI_OS_NAME" = "freebsd" ]; then
   MAKE=gmake
 else
-  fatal "Unknown os: '$TRAVIS_OS_NAME'"
+  fatal "Unknown os: '$CI_OS_NAME'"
 fi
 
 install-vcddiff() {
@@ -43,62 +41,71 @@ install-vcddiff() {
   sudo cp "${TMP_DIR}/vcddiff" /usr/local/bin
 }
 
-if [ "$TRAVIS_BUILD_STAGE_NAME" = "build" ]; then
+if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
   ##############################################################################
   # Dependencies of jobs in the 'build' stage, i.e.: packages required to
   # build Verilator
 
-  if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+  if [ "$CI_OS_NAME" = "linux" ]; then
     sudo apt-get update
-    sudo apt-get install libfl-dev
-    sudo apt-get install libgoogle-perftools-dev
+    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 Unix::Processors Parallel::Forker
+      yes yes | sudo cpan -fi Parallel::Forker
     fi
     if [ "$M32" = 1 ]; then
       sudo apt-get install gcc-multilib g++-multilib
     fi
-  elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+  elif [ "$CI_OS_NAME" = "osx" ]; then
     brew update
     brew install ccache perl gperftools
-  elif [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
+  elif [ "$CI_OS_NAME" = "freebsd" ]; then
     sudo pkg install -y autoconf bison ccache gmake perl5
   else
-    fatal "Unknown os: '$TRAVIS_OS_NAME'"
+    fatal "Unknown os: '$CI_OS_NAME'"
   fi
-elif [ "$TRAVIS_BUILD_STAGE_NAME" = "test" ]; then
+
+  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 [ "$TRAVIS_OS_NAME" = "linux" ]; then
+  if [ "$CI_OS_NAME" = "linux" ]; then
     sudo apt-get update
-    sudo apt-get install gdb gtkwave lcov
-    if [ "$TRAVIS_DIST" = "focal" ]; then
+    # 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 [ "$TRAVIS_OS_NAME" = "osx" ]; then
+  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 [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
+  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: '$TRAVIS_OS_NAME'"
+    fatal "Unknown os: '$CI_OS_NAME'"
   fi
   # Common installs
-  if [ "$TRAVIS_DIST" != "trusty" ]; then
-    TRAVIS_CPAN_REPO=https://cpan.org
+  if [ "$CI_RUNS_ON" != "ubuntu-14.04" ]; then
+    CI_CPAN_REPO=https://cpan.org
   fi
-  # Not listing Bit::Vector as slow to install, and only skips one test
-  yes yes | sudo cpan -M $TRAVIS_CPAN_REPO -fi Unix::Processors Parallel::Forker
+  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: '$TRAVIS_BUILD_STAGE_NAME'"
+  fatal "Unknown build stage: '$CI_BUILD_STAGE_NAME'"
 fi

ci/ci-script.bash

@@ -0,0 +1,177 @@
+#!/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/10
+      ;;
+    coverage-vlt-1)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=1/10
+      ;;
+    coverage-vlt-2)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=2/10
+      ;;
+    coverage-vlt-3)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=3/10
+      ;;
+    coverage-vlt-4)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=4/10
+      ;;
+    coverage-vlt-5)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=5/10
+      ;;
+    coverage-vlt-6)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=6/10
+      ;;
+    coverage-vlt-7)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=7/10
+      ;;
+    coverage-vlt-8)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=8/10
+      ;;
+    coverage-vlt-9)
+      nodist/code_coverage --stages 1- --scenarios=--vlt --hashset=9/10
+      ;;
+    coverage-vltmt-0)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=0/10
+      ;;
+    coverage-vltmt-1)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=1/10
+      ;;
+    coverage-vltmt-2)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=2/10
+      ;;
+    coverage-vltmt-3)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=3/10
+      ;;
+    coverage-vltmt-4)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=4/10
+      ;;
+    coverage-vltmt-5)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=5/10
+      ;;
+    coverage-vltmt-6)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=6/10
+      ;;
+    coverage-vltmt-7)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=7/10
+      ;;
+    coverage-vltmt-8)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=8/10
+      ;;
+    coverage-vltmt-9)
+      nodist/code_coverage --stages 1- --scenarios=--vltmt --hashset=9/10
+      ;;
+    *)
+      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

ci/docker/buildenv/Dockerfile

@@ -40,7 +40,7 @@ RUN apt-get update \
 
 WORKDIR /tmp
 
-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 && \

ci/docker/buildenv/README.adoc

@@ -1,49 +0,0 @@
-= Verilator Docker Build Environment
-
-This Verilator Build container is set up to compile and test a Verilator
-build. It uses the following parameters:
-
-* Source repository (default: https://github.com/verilator/verilator)
-* Source revision (default: master)
-* 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].
-
-To run the basic build using the current Verilator master:
-
-    docker run -ti verilator/verilator-buildenv
-
-To also run tests:
-
-    docker run -ti verilator/verilator-buildenv test
-
-To change the compiler:
-
-    docker run -ti -e CC=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 -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
-working copy on the local filesystem. Mount the local working copy path as
-a volume and use that in place of git. When doing this be careful to have
-all changes committed to the local git area. To build the current HEAD from
-top of a repository:
-
-....
-docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
-....
-
-== Rebuilding
-
-To rebuild the Verilator-buildenv docker image, run:
-
-    docker build .
-
-This will also build SystemC under all supported compiler variants to
-reduce the SystemC testing time.

ci/docker/buildenv/README.rst

@@ -0,0 +1,64 @@
+================================
+Verilator Build Docker Container
+================================
+
+This Verilator Build Docker Container is set up to compile and test a
+Verilator build. It uses the following parameters:
+
+-  Source repository (default: https://github.com/verilator/verilator)
+
+-  Source revision (default: master)
+
+-  Compiler (GCC 9.3.0, clang 10.0.0, default: 9.3.0)
+
+The container is published as ``verilator/verilator-buildenv`` on `docker
+hub
+<https://hub.docker.com/repository/docker/verilator/verilator-buildenv>`__.
+
+To run the basic build using the current Verilator master:
+
+::
+
+   docker run -ti verilator/verilator-buildenv
+
+To also run tests:
+
+::
+
+   docker run -ti verilator/verilator-buildenv test
+
+To change the compiler:
+
+::
+
+   docker run -ti -e CC=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 -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
+working copy on the local filesystem. Mount the local working copy path as
+a volume and use that in place of git. When doing this be careful to have
+all changes committed to the local git area. To build the current HEAD from
+top of a repository:
+
+::
+
+   docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
+
+
+Rebuilding
+==========
+
+To rebuild the Verilator-buildenv docker image, run:
+
+::
+
+   docker build .
+
+This will also build SystemC under all supported compiler variants to
+reduce the SystemC testing time.

ci/docker/run/README.adoc

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

ci/docker/run/README.rst

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

ci/docker/run/verilator-wrap.sh

@@ -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

ci/travis-ccache-size.bash

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-# DESCRIPTION: Verilator: Travis CI ccache sizer
-#
-# 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 computes the size of the ccache to be used for a job. We want the
-# ccache to be just big enough to be able to hold a whole build so a re-build
-# of the same does not miss in the cache due to capacity, but we don't want the
-# ccache too big as pulling it down from the network takes time, and it is
-# unlikely objects from much earlier builds would be useful.
-################################################################################
-
-fatal() {
-  echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
-}
-
-if [ "$TRAVIS_BUILD_STAGE_NAME" = "build" ]; then
-  if [ "$COVERAGE" == 1 ]; then
-    echo "1024M"
-  else
-    echo "768M"
-  fi
-elif [ "$TRAVIS_BUILD_STAGE_NAME" = "test" ]; then
-  if [[ $TESTS == coverage-* ]]; then
-    echo "1536M"
-  else
-    echo "256M"
-  fi
-else
-  fatal "Unknown build stage: '$TRAVIS_BUILD_STAGE_NAME'"
-fi

ci/travis-script.bash

@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-# DESCRIPTION: Verilator: Travis 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 .travis.yml spec simple. We pass job parameters via
-# environment variables using 'env' keys. Having different 'env' keys in jobs
-# ensures they use different Travis build caches.
-################################################################################
-
-set -e
-set -x
-
-fatal() {
-  echo "ERROR: $(basename "$0"): $1" >&2; exit 1;
-}
-
-if [ "$TRAVIS_OS_NAME" = "linux" ]; then
-  export MAKE=make
-  NPROC=$(nproc)
-elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
-  export MAKE=make
-  NPROC=$(sysctl -n hw.logicalcpu)
-elif [ "$TRAVIS_OS_NAME" = "freebsd" ]; then
-  export MAKE=gmake
-  NPROC=$(sysctl -n hw.ncpu)
-else
-  fatal "Unknown os: '$TRAVIS_OS_NAME'"
-fi
-
-if [ "$TRAVIS_BUILD_STAGE_NAME" = "build" ]; then
-  ##############################################################################
-  # Build verilator
-
-  if [ "$COVERAGE" != 1 ]; then
-    autoconf
-    ./configure --enable-longtests --enable-ccwarn
-    "$MAKE" -j "$NPROC"
-    if [ "$TRAVIS_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 1-2
-  fi
-elif [ "$TRAVIS_BUILD_STAGE_NAME" = "test" ]; then
-  ##############################################################################
-  # Run tests
-
-  if [ "$TRAVIS_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
-    # one for Travis. Remove the file and re-link...
-    rm bin/verilator_bin_dbg
-    "$MAKE" -j "$NPROC"
-  elif [ "$TRAVIS_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 the specified test
-  case $TESTS in
-    dist-vlt-0)
-      "$MAKE" -C test_regress SCENARIOS="--dist --vlt" DRIVER_HASHSET=--hashset=0/2
-      ;;
-    dist-vlt-1)
-      "$MAKE" -C test_regress SCENARIOS="--dist --vlt" 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-dist)
-      nodist/code_coverage --stages 3- --scenarios=--dist
-      ;;
-    coverage-vlt-0)
-      nodist/code_coverage --stages 3- --scenarios=--vlt --hashset=0/4
-      ;;
-    coverage-vlt-1)
-      nodist/code_coverage --stages 3- --scenarios=--vlt --hashset=1/4
-      ;;
-    coverage-vlt-2)
-      nodist/code_coverage --stages 3- --scenarios=--vlt --hashset=2/4
-      ;;
-    coverage-vlt-3)
-      nodist/code_coverage --stages 3- --scenarios=--vlt --hashset=3/4
-      ;;
-    coverage-vltmt-0)
-      nodist/code_coverage --stages 3- --scenarios=--vltmt --hashset=0/4
-      ;;
-    coverage-vltmt-1)
-      nodist/code_coverage --stages 3- --scenarios=--vltmt --hashset=1/4
-      ;;
-    coverage-vltmt-2)
-      nodist/code_coverage --stages 3- --scenarios=--vltmt --hashset=2/4
-      ;;
-    coverage-vltmt-3)
-      nodist/code_coverage --stages 3- --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: '$TRAVIS_BUILD_STAGE_NAME'"
-fi

codecov.yml

@@ -1,6 +1,6 @@
 # DESCRIPTION: codecov.io config
 #
-# Copyright 2020-2020 by Wilson Snyder. This program is free software; you
+# 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.
@@ -15,7 +15,7 @@ codecov:
 coverage:
   precision: 2
   round: down
-  range: "70...100"
+  range: "50...100"
   ignore:
     - "ci"
     - "docs"

configure.ac

@@ -1,13 +1,13 @@
 # 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.040 2020-08-15],
+AC_INIT([Verilator],[4.200 2021-03-12],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 # When releasing, also update header of Changes file
@@ -113,22 +113,6 @@ 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-final],
-              [AS_HELP_STRING([--enable-prec11-final],
-                              [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-final]) ;;
-               esac],
-              [CFG_WITH_PREC11=no;]
-              )
-AC_SUBST(CFG_WITH_PREC11)
-AC_MSG_RESULT($CFG_WITH_PREC11)
-
 # Compiler flags (ensure they are not empty to avoid configure defaults)
 CFLAGS+=" "
 CPPFLAGS+=" "
@@ -155,6 +139,11 @@ 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])
@@ -410,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
@@ -423,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)
-CXXFLAGS="$ACO_SAVE_CXXFLAGS"
+   ])
 
-# 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 will require a C++11 or newer compiler for all releases starting
-September 2020.  Please investigate a C++11 build environment now so you
-will be ready.  Until then you may rerun configure with the
---enable-prec11-final argument to enable reduced functionality with such
-older compilers. Thanks.]])
+Verilator requires a C++11 or newer compiler.]])
 
-   fi
 fi
 
 # Checks for library functions.

docs/CONTRIBUTING.adoc

@@ -1,82 +0,0 @@
-= How to contribute to Verilator
-
-Thanks for using Verilator!  We welcome your contributions in whatever form.
-
-This contributing document contains some suggestions that may make
-contributions flow more efficiently.
-
-==== Did you find a bug?
-
-* Please **Ensure the bug was not already reported** by searching
-  https://verilator.org/issues[Verilator Issues].
-
-* If you're unable to find an open issue addressing the problem,
-  https://verilator.org/issues/new[open a new Verilator issue].
-
-** Be sure to include a **code sample** or an **executable test case**
-   demonstrating the bug and expected behavior that is not occurring.
-
-** The ideal example works against other simulators, and is in the
-   test_regress/t test format, as described in
-   link:internals.adoc[docs/internals].
-
-==== Did you write a patch that fixes a bug?
-
-* Please https://verilator.org/issues/new[Open a new issue].
-
-* 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
-   keep the tests passing.  See link:internals.adoc[docs/internals].
-
-* Your source-code contributions must be certified as open source, under
-  the https://developercertificate.org/[Developer Certificate of
-  Origin]. On your first contribution, you must either:
-
-** Have your patch include the addition of your name to
-   link:CONTRIBUTORS[docs/CONTRIBUTORS] (preferred).
-
-** Use "git -s" as part of your commit. This adds a "signed-of-by"
-   attribute which will certify your contribution as described in the
-   https://github.com/wking/signed-off-by/blob/master/Documentation/SubmittingPatches[Signed-of-By
-   convention].
-
-** Email, or post in an issue a statement that you certify your
-   contributions.
-
-** In any of these cases your name will be added to
-   link:CONTRIBUTORS[docs/CONTRIBUTORS] and you are agreeing all future
-   contributions are also certified.
-
-** We occasionally accept contributions where people do not want their name
-   published. Please email us; you must still privately certify your
-   contribution.
-
-* Your test contributions are generally considered released into the
-  Creative Commons Public Domain (CC0), unless you request otherwise or put
-  a GNU/Artistic license on your file.
-
-* Most important is we get your patch. If you'd like to clean up
-  indentation and related issues ahead of our feedback, that is
-  appreciated; please see the coding conventions in
-  link:internals.adoc[docs/internals].
-
-==== Do you have questions?
-
-* Please see FAQ section and rest of the
-  https://verilator.org/verilator_doc.html[Verilator manual],
-  or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].
-
-* Ask any question in the
-  https://verilator.org/forum[Verilator forum].
-
-==== Code of Conduct
-
-* Our contributors and participants pledge to make participation in our
-  project and our community a positive experience for everyone.  We follow
-  the https://www.contributor-covenant.org/version/1/4/code-of-conduct.html[Contributor
-  Covenant version 1.4].
-
-Thanks!

docs/CONTRIBUTING.rst

@@ -0,0 +1,93 @@
+=========================
+Contributing to Verilator
+=========================
+
+Thanks for using Verilator! We welcome your contributions in whatever form.
+
+This contributing document contains some suggestions that may make
+contributions flow more efficiently.
+
+
+Did you find a bug?
+===================
+
+- Please **Ensure the bug was not already reported** by searching
+  `Verilator Issues <https://verilator.org/issues>`__.
+
+- If you're unable to find an open issue addressing the problem, `open a
+  new Verilator issue <https://verilator.org/issues/new>`__.
+
+  - Be sure to include a **code sample** or an **executable test case**
+    demonstrating the bug and expected behavior that is not occurring.
+
+  - The ideal example works against other simulators, and is in the
+    test_regress/t test format, as described in `docs/internals
+    <internals.rst>`__.
+
+
+Did you write a patch that fixes a bug?
+=======================================
+
+- Please `Open a new issue <https://verilator.org/issues/new>`__.
+
+- You may attach a patch to the issue, or (preferred) may request a
+  GitHub pull request.
+
+  - 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 `docs/internals <internals.rst>`__.
+
+- Your source-code contributions must be certified as open source,
+  under the `Developer Certificate of
+  Origin <https://developercertificate.org/>`__. On your first
+  contribution, you must either:
+
+  - Have your patch include the addition of your name to `docs/CONTRIBUTORS
+    <CONTRIBUTORS>`__ (preferred).
+
+  - Use "git -s" as part of your commit. This adds a "signed-of-by"
+    attribute which will certify your contribution as described in the
+    `Signed-of-By convention
+    <https://github.com/wking/signed-off-by/blob/master/Documentation/SubmittingPatches>`__.
+
+  - Email, or post in an issue a statement that you certify your
+    contributions.
+
+  - In any of these cases your name will be added to `docs/CONTRIBUTORS
+    <CONTRIBUTORS>`__ and you are agreeing all future contributions are
+    also certified.
+
+  - We occasionally accept contributions where people do not want their
+    name published. Please email us; you must still privately certify your
+    contribution.
+
+- Your test contributions are generally considered released into the
+  Creative Commons Public Domain (CC0), unless you request otherwise or
+  put a GNU/Artistic license on your file.
+
+- Most important is we get your patch. If you’d like to clean up
+  indentation and related issues ahead of our feedback, that is
+  appreciated; please see the coding conventions in `docs/internals
+  <internals.rst>`__.
+
+
+Do you have questions?
+======================
+
+- Please see FAQ section and rest of the `Verilator
+  manual <https://verilator.org/verilator_doc.html>`__, or `Verilator
+  manual (PDF) <https://verilator.org/verilator_doc.pdf>`__.
+
+- Ask any question in the `Verilator forum
+  <https://verilator.org/forum>`__.
+
+
+Code of Conduct
+===============
+
+- Our contributors and participants pledge to make participation in our
+  project and our community a positive experience for everyone. We follow
+  the `Contributor Covenant version 1.4
+  <https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>`__.
+
+Thanks!

docs/CONTRIBUTORS

@@ -5,11 +5,14 @@ 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
+David Turner
 Driss Hafdi
 Edgar E. Iglesias
 Eric Rippey
@@ -25,34 +28,47 @@ 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
@@ -64,6 +80,8 @@ Tobias Wölfel
 Todd Strader
 Tomasz Gorochowik
 Tymoteusz Blazejczyk
+Unai Martinez-Corral
+Victor Besyakov
 Vassilis Papaefstathiou
 Veripool API Bot
 Wilson Snyder
@@ -71,3 +89,5 @@ Yossi Nivin
 Yuri Victorovich
 Yutetsu TAKATSUKASA
 Yves Mathieu
+HyungKi Jeong
+Drew Taussig

docs/Makefile.in

@@ -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.
@@ -19,8 +19,8 @@
 
 #### Start of system configuration section. ####
 
-ASCIIDOCTOR = asciidoctor
 DOXYGEN = doxygen
+RST2HTML = rst2html
 
 #### End of system configuration section. ####
 ######################################################################
@@ -30,8 +30,8 @@ DOXYGEN = doxygen
 default:
 	@echo "error: make not supported here, run 'make docs' from Verilator top-level"
 
-%.html: %.adoc
-	$(ASCIIDOCTOR) $< -n -o $@
+%.html: %.rst
+	$(RST2HTML) $< $@
 
 clean mostlyclean distclean maintainer-clean::
 	rm -f $(SCRIPTS) *.tmp

docs/TODO

@@ -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)

docs/install.adoc

@@ -1,305 +0,0 @@
-= Verilator Installation
-:toc: right
-
-// Github doesn't render unless absolute URL
-image::https://www.veripool.org/img/verilator_256_200_min.png[Logo,256,200,role="right"]
-
-== Introduction
-
-This discusses how to install Verilator.  For more general information
-please see https://verilator.org[verilator.org].
-
-== Quick-start
-
-=== Install From a Package Manager
-
-Using a distribution's package manager is the easiest way to get
-started. (Note packages are unlikely to have the most recent version, so
-Git, below, maybe a better alternative.) To install as a package:
-
-   apt-get install verilator
-
-If this works, skip down to <<Running Verilator>>.
-
-=== Docker
-
-Verilator is available in pre-built Docker containers. See
-https://github.com/verilator/verilator/blob/master/ci/docker/run/README.adoc
-
-=== Git
-
-Installing Verilator with Git provides the most flexibility.
-For additional options and details see the additional sections below.  In
-brief:
-
-// Also update README
-....
-# Prerequisites:
-#sudo apt-get install git make autoconf g++ flex bison
-#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://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:
-unsetenv VERILATOR_ROOT  # For csh; ignore error if on bash
-unset VERILATOR_ROOT  # For bash
-cd verilator
-git pull        # Make sure git repository is up-to-date
-git tag         # See what versions exist
-#git checkout master      # Use development branch (e.g. recent bug fixes)
-#git checkout stable      # Use most recent stable release
-#git checkout v{version}  # Switch to specified release version
-
-autoconf        # Create ./configure script
-./configure
-make
-sudo make install
-# Now see "man verilator" or online verilator.pdf's for the example tutorials
-....
-
-If this works, skip down to <<Running Verilator>>.
-
-== Detailed Build Instructions
-
-This section describes details of the build process, and assumes you are
-building from Git or a tarball.  For using a pre-built binary for your
-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++.
-
-=== Install Prerequisites
-
-To build or run Verilator you need these standard packages:
-
-   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)
-
-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 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 autoconf flex bison
-
-Those developing Verilator itself may also want these (see internals.adoc):
-
-   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
-
-If you will be using SystemC (vs straight C++ output), download
-https://www.accellera.org/downloads/standards/systemc[SystemC].
-Follow their installation instructions.  You will need to set `SYSTEMC_INCLUDE`
-to point to the include directory with `systemc.h` in it, and `SYSTEMC_LIBDIR`
-to points to the directory with `libsystemc.a` in it.  (Older installations
-may set `SYSTEMC` and `SYSTEMC_ARCH` instead.)
-
-==== Install GTKWave
-
-To make use of Verilator FST tracing you will want
-http://gtkwave.sourceforge.net/[GTKwave] installed, however this is not
-required at Verilator build time.
-
-=== Obtain Sources
-
-You may use Git or a tarball for the sources.  Git is the supported option.
-(If using a historical build that uses a tarball, tarballs are obtained
-from https://www.veripool.org/projects/verilator/wiki/Download[Verilator
-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://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:
-
-   cd verilator
-   git pull        # Make sure we're up-to-date
-   git tag         # See what versions exist
-   #git checkout master      # Use development branch (e.g. recent bug fix)
-   #git checkout stable      # Use most recent release
-   #git checkout v{version}  # Switch to specified release version
-
-=== Auto Configure
-
-Create the configuration script:
-
-   autoconf        # Create ./configure script
-
-=== Eventual Installation Options
-
-Before configuring the build, you have to decide how you're going to
-eventually install the kit.  Verilator will be compiling the current value
-of `VERILATOR_ROOT`, `SYSTEMC_INCLUDE`, and `SYSTEMC_LIBDIR` as defaults
-into the executable, so they must be correct before configuring.
-
-These are the options:
-
-==== 1. Run-in-Place from VERILATOR_ROOT
-
-Our personal favorite is to always run Verilator in-place from its Git
-directory.  This allows the easiest experimentation and upgrading, and
-allows many versions of Verilator to co-exist on a system.
-
-   export VERILATOR_ROOT=`pwd`   # if your shell is bash
-   setenv VERILATOR_ROOT `pwd`   # if your shell is csh
-   ./configure
-   # Running will use files from $VERILATOR_ROOT, so no install needed
-
-Note after installing (below steps), a calling program or shell must set
-the environment variable `VERILATOR_ROOT` to point to this Git directory,
-then execute `$VERILATOR_ROOT/bin/verilator`, which will find the path to
-all needed files.
-
-==== 2. Install into a CAD Disk
-
-You may eventually be installing onto a project/company-wide "CAD" tools
-disk that may support multiple versions of every tool.  Target the build to
-a destination directory name that includes the Verilator version name:
-
-   unset VERILATOR_ROOT      # if your shell is bash
-   unsetenv VERILATOR_ROOT   # if your shell is csh
-   # For the tarball, use the version number instead of git describe
-   ./configure --prefix /CAD_DISK/verilator/`git describe | sed "s/verilator_//"`
-
-Note after installing (below steps), if you use
-http://modules.sourceforge.net/[modulecmd], you'll want a module file like
-the following:
-
-.modulecmd's verilator/version file
-----
-set install_root /CAD_DISK/verilator/{version-number-used-above}
-unsetenv VERILATOR_ROOT
-prepend-path PATH $install_root/bin
-prepend-path MANPATH $install_root/man
-prepend-path PKG_CONFIG_PATH $install_root/share/pkgconfig
-----
-
-==== 3. Install into a Specific Path
-
-You may eventually install Verilator into a specific installation prefix,
-as most GNU tools support:
-
-   unset VERILATOR_ROOT      # if your shell is bash
-   unsetenv VERILATOR_ROOT   # if your shell is csh
-   ./configure --prefix /opt/verilator-VERSION
-
-Then after installing (below steps) you will need to add
-`/opt/verilator-VERSION/bin` to `$PATH`.
-
-==== 4. Install System Globally
-
-The final option is to eventually install Verilator globally, using the
-normal system paths:
-
-   unset VERILATOR_ROOT      # if your shell is bash
-   unsetenv VERILATOR_ROOT   # if your shell is csh
-   ./configure
-
-Then after installing (below) the binary directories should already be in
-your `$PATH`.
-
-=== Configure
-
-The command to configure the package was described in the previous step.
-Developers should configure to have more complete developer tests.
-Additional packages may be required for these tests.
-
-   export VERILATOR_AUTHOR_SITE=1    # Put in your .bashrc
-   ./configure --enable-longtests  ...above options...
-
-=== Compile
-
-Compile Verilator:
-
-   make -j
-
-=== Test
-
-Check the compilation by running self-tests:
-
-   make test
-
-=== Install
-
-If you used any but the <<1. Run-in-Place from VERILATOR_ROOT>> scheme,
-install to the OS-standard place:
-
-   make install
-
-== Running Verilator
-
-To run Verilator, see the example sections in the
-https://verilator.org/verilator_doc.html[Verilator manual (HTML)],
-or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].
-
-Also see the `examples/` directory that is part of the kit, and is installed
-(in a OS-specific place, often in e.g. `/usr/local/share/verilator/examples`).
-
-     cd examples/make_hello_c
-     make
-
-Note if you did a `make install` above you should not have `VERILATOR_ROOT`
-set in your environment; it is built into the executable.
-
-== Announcements
-
-To get notified of new releases, go to
-https://github.com/verilator/verilator-announce[Verilator announcement
-repository] and follow the instructions there.
-
-== Directory Structure
-
-Some relevant files and directories in this package are as follows:
-
-   Changes                     => Version history
-   README.adoc                 => This document
-   bin/verilator               => Compiler wrapper invoked to Verilate code
-   docs/                       => Additional documentation
-   examples/make_hello_c       => Example GNU-make simple Verilog->C++ conversion
-   examples/make_hello_sc      => Example GNU-make simple Verilog->SystemC conversion
-   examples/make_tracing_c     => Example GNU-make Verilog->C++ with tracing
-   examples/make_tracing_sc    => Example GNU-make Verilog->SystemC with tracing
-   examples/make_protect_lib   => Example using --protect-lib
-   examples/cmake_hello_c      => Example building make_hello_c with CMake
-   examples/cmake_hello_sc     => Example building make_hello_sc with CMake
-   examples/cmake_tracing_c    => Example building make_tracing_c with CMake
-   examples/cmake_tracing_sc   => Example building make_tracing_sc with CMake
-   examples/cmake_protect_lib  => Example building make_protect_lib with CMake
-   include/                    => Files that should be in your -I compiler path
-   include/verilated*.cpp      => Global routines to link into your simulator
-   include/verilated*.h        => Global headers
-   include/verilated.mk        => Common Makefile
-   src/                        => Translator source code
-   test_regress                => Internal tests
-
-For files created after a design is Verilated, see the
-https://verilator.org/verilator_doc.html[Verilator manual (HTML)],
-or https://verilator.org/verilator_doc.pdf[Verilator manual (PDF)].
-
-== License
-
-Copyright 2008-2020 by Wilson Snyder.  Verilator is free software; you can
-redistribute it and/or modify it under the terms of either the GNU Lesser
-General Public License Version 3 or the Perl Artistic License Version 2.0.
-// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

docs/install.rst

@@ -0,0 +1,397 @@
+|Logo|
+
+======================
+Verilator Installation
+======================
+
+.. contents::
+   :depth: 3
+
+Introduction
+============
+
+This discusses how to install Verilator. For more general information
+please see `verilator.org <https://verilator.org>`__.
+
+
+Quick-start
+===========
+
+
+Install From a Package Manager
+------------------------------
+
+Using a distribution's package manager is the easiest way to get
+started. (Note packages are unlikely to have the most recent version, so
+Git, below, maybe a better alternative.) To install as a package:
+
+::
+
+   apt-get install verilator
+
+If this works, skip down to `Running Verilator <#_running_verilator>`__.
+
+
+Docker
+------
+
+Verilator is available in pre-built Docker containers. See
+https://github.com/verilator/verilator/blob/master/ci/docker/run/README.rst
+
+
+Git
+---
+
+Installing Verilator with Git provides the most flexibility. For
+additional options and details see the additional sections below. In
+brief:
+
+::
+
+   # Prerequisites:
+   #sudo apt-get install git make autoconf g++ flex bison
+   #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://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:
+   unsetenv VERILATOR_ROOT  # For csh; ignore error if on bash
+   unset VERILATOR_ROOT  # For bash
+   cd verilator
+   git pull        # Make sure git repository is up-to-date
+   git tag         # See what versions exist
+   #git checkout master      # Use development branch (e.g. recent bug fixes)
+   #git checkout stable      # Use most recent stable release
+   #git checkout v{version}  # Switch to specified release version
+
+   autoconf        # Create ./configure script
+   ./configure
+   make
+   sudo make install
+   # Now see "man verilator" or online verilator.pdf's for the example tutorials
+
+If this works, skip down to `Running Verilator <#_running_verilator>`__.
+
+
+Detailed Build Instructions
+===========================
+
+This section describes details of the build process, and assumes you are
+building from Git or a tarball. For using a pre-built binary for your
+Linux distribution, see instead `Install From a Package
+Manager <#_install_from_a_package_manager>`__.
+
+
+OS Requirements
+---------------
+
+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 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)
+
+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 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 autoconf flex bison
+
+Those developing Verilator itself may also want these (see internals.rst):
+
+::
+
+   sudo apt-get install gdb asciidoctor graphviz cmake clang clang-format gprof lcov
+   cpan install Pod::Perldoc
+   cpan install Parallel::Forker
+
+
+Install SystemC
+~~~~~~~~~~~~~~~
+
+If you will be using SystemC (vs straight C++ output), download `SystemC
+<https://www.accellera.org/downloads/standards/systemc>`__.  Follow their
+installation instructions. You will need to set ``SYSTEMC_INCLUDE`` to
+point to the include directory with ``systemc.h`` in it, and
+``SYSTEMC_LIBDIR`` to points to the directory with ``libsystemc.a`` in
+it. (Older installations may set ``SYSTEMC`` and ``SYSTEMC_ARCH`` instead.)
+
+
+Install GTKWave
+~~~~~~~~~~~~~~~
+
+To make use of Verilator FST tracing you will want `GTKwave
+<http://gtkwave.sourceforge.net/>`__ installed, however this is not
+required at Verilator build time.
+
+
+Obtain Sources
+--------------
+
+You may use Git or a tarball for the sources. Git is the supported
+option. (If using a historical build that uses a tarball, tarballs are
+obtained from `Verilator Downloads
+<https://www.veripool.org/projects/verilator/wiki/Download>`__; 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://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:
+
+::
+
+   cd verilator
+   git pull        # Make sure we're up-to-date
+   git tag         # See what versions exist
+   #git checkout master      # Use development branch (e.g. recent bug fix)
+   #git checkout stable      # Use most recent release
+   #git checkout v{version}  # Switch to specified release version
+
+
+Auto Configure
+--------------
+
+Create the configuration script:
+
+::
+
+   autoconf        # Create ./configure script
+
+
+Eventual Installation Options
+-----------------------------
+
+Before configuring the build, you have to decide how you're going to
+eventually install the kit. Verilator will be compiling the current value
+of ``VERILATOR_ROOT``, ``SYSTEMC_INCLUDE``, and ``SYSTEMC_LIBDIR`` as
+defaults into the executable, so they must be correct before configuring.
+
+These are the options:
+
+
+1. Run-in-Place from VERILATOR_ROOT
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Our personal favorite is to always run Verilator in-place from its Git
+directory. This allows the easiest experimentation and upgrading, and
+allows many versions of Verilator to co-exist on a system.
+
+::
+
+   export VERILATOR_ROOT=`pwd`   # if your shell is bash
+   setenv VERILATOR_ROOT `pwd`   # if your shell is csh
+   ./configure
+   # Running will use files from $VERILATOR_ROOT, so no install needed
+
+Note after installing (below steps), a calling program or shell must set
+the environment variable ``VERILATOR_ROOT`` to point to this Git directory,
+then execute ``$VERILATOR_ROOT/bin/verilator``, which will find the path to
+all needed files.
+
+
+2. Install into a CAD Disk
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You may eventually be installing onto a project/company-wide "CAD" tools
+disk that may support multiple versions of every tool. Target the build to
+a destination directory name that includes the Verilator version name:
+
+::
+
+   unset VERILATOR_ROOT      # if your shell is bash
+   unsetenv VERILATOR_ROOT   # if your shell is csh
+   # For the tarball, use the version number instead of git describe
+   ./configure --prefix /CAD_DISK/verilator/`git describe | sed "s/verilator_//"`
+
+Note after installing (below steps), if you use `modulecmd
+<http://modules.sourceforge.net/>`__, you'll want a module file like the
+following:
+
+**modulecmd's verilator/version file.**
+
+::
+
+   set install_root /CAD_DISK/verilator/{version-number-used-above}
+   unsetenv VERILATOR_ROOT
+   prepend-path PATH $install_root/bin
+   prepend-path MANPATH $install_root/man
+   prepend-path PKG_CONFIG_PATH $install_root/share/pkgconfig
+
+
+3. Install into a Specific Path
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+You may eventually install Verilator into a specific installation prefix,
+as most GNU tools support:
+
+::
+
+   unset VERILATOR_ROOT      # if your shell is bash
+   unsetenv VERILATOR_ROOT   # if your shell is csh
+   ./configure --prefix /opt/verilator-VERSION
+
+Then after installing (below steps) you will need to add
+``/opt/verilator-VERSION/bin`` to ``$PATH``.
+
+
+4. Install System Globally
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The final option is to eventually install Verilator globally, using the
+normal system paths:
+
+::
+
+   unset VERILATOR_ROOT      # if your shell is bash
+   unsetenv VERILATOR_ROOT   # if your shell is csh
+   ./configure
+
+Then after installing (below) the binary directories should already be
+in your ``$PATH``.
+
+
+Configure
+---------
+
+The command to configure the package was described in the previous step.
+Developers should configure to have more complete developer tests.
+Additional packages may be required for these tests.
+
+::
+
+   export VERILATOR_AUTHOR_SITE=1    # Put in your .bashrc
+   ./configure --enable-longtests  ...above options...
+
+
+Compile
+-------
+
+Compile Verilator:
+
+::
+
+   make -j
+
+
+Test
+----
+
+Check the compilation by running self-tests:
+
+::
+
+   make test
+
+
+Install
+-------
+
+If you used any but the `1. Run-in-Place from VERILATOR_ROOT
+<#_1_run_in_place_from_verilator_root>`__ scheme, install to the
+OS-standard place:
+
+::
+
+   make install
+
+
+Running Verilator
+=================
+
+To run Verilator, see the example sections in the `Verilator manual (HTML)
+<https://verilator.org/verilator_doc.html>`__, or `Verilator manual (PDF)
+<https://verilator.org/verilator_doc.pdf>`__.
+
+Also see the ``examples/`` directory that is part of the kit, and is
+installed (in a OS-specific place, often in e.g.
+``/usr/local/share/verilator/examples``).
+
+::
+
+   cd examples/make_hello_c
+   make
+
+Note if you did a ``make install`` above you should not have
+``VERILATOR_ROOT`` set in your environment; it is built into the
+executable.
+
+
+Announcements
+=============
+
+To get notified of new releases, go to `Verilator announcement repository
+<https://github.com/verilator/verilator-announce>`__ and follow the
+instructions there.
+
+
+Directory Structure
+===================
+
+Some relevant files and directories in this package are as follows:
+
+::
+
+   Changes                     => Version history
+   README.rst                 => This document
+   bin/verilator               => Compiler wrapper invoked to Verilate code
+   docs/                       => Additional documentation
+   examples/make_hello_c       => Example GNU-make simple Verilog->C++ conversion
+   examples/make_hello_sc      => Example GNU-make simple Verilog->SystemC conversion
+   examples/make_tracing_c     => Example GNU-make Verilog->C++ with tracing
+   examples/make_tracing_sc    => Example GNU-make Verilog->SystemC with tracing
+   examples/make_protect_lib   => Example using --protect-lib
+   examples/cmake_hello_c      => Example building make_hello_c with CMake
+   examples/cmake_hello_sc     => Example building make_hello_sc with CMake
+   examples/cmake_tracing_c    => Example building make_tracing_c with CMake
+   examples/cmake_tracing_sc   => Example building make_tracing_sc with CMake
+   examples/cmake_protect_lib  => Example building make_protect_lib with CMake
+   include/                    => Files that should be in your -I compiler path
+   include/verilated*.cpp      => Global routines to link into your simulator
+   include/verilated*.h        => Global headers
+   include/verilated.mk        => Common Makefile
+   src/                        => Translator source code
+   test_regress                => Internal tests
+
+For files created after a design is Verilated, see the `Verilator manual
+(HTML) <https://verilator.org/verilator_doc.html>`__, or `Verilator
+manual (PDF) <https://verilator.org/verilator_doc.pdf>`__.
+
+
+License
+=======
+
+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.
+
+.. |Logo| image:: https://www.veripool.org/img/verilator_256_200_min.png

docs/xml.adoc

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

docs/xml.rst

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

examples/cmake_hello_c/Makefile

@@ -54,7 +54,7 @@ run:
 
 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j
 
 	@echo
 	@echo "-- RUN ---------------------"

examples/cmake_hello_sc/Makefile

@@ -90,7 +90,7 @@ run:
 
 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j
 
 	@echo
 	@echo "-- RUN ---------------------"

examples/cmake_protect_lib/Makefile

@@ -54,7 +54,7 @@ run:
 
 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j
 
 	@echo
 	@echo "-- RUN ---------------------"

examples/cmake_tracing_c/Makefile

@@ -54,7 +54,7 @@ run:
 
 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j
 
 	@echo
 	@echo "-- RUN ---------------------"

examples/cmake_tracing_sc/Makefile

@@ -90,7 +90,7 @@ run:
 
 	@echo
 	@echo "-- BUILD -------------------"
-	cmake --build build
+	cmake --build build -j
 
 	@echo
 	@echo "-- RUN ---------------------"

examples/make_hello_c/sim_main.cpp

@@ -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;
 }

examples/make_hello_sc/sc_main.cpp

@@ -26,27 +26,20 @@ int sc_main(int argc, char* argv[]) {
     if (false && argc && argv) {}
 
     // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
-    Vtop* top = new Vtop("top");
+    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;
 }

examples/make_protect_lib/secret_impl.v

@@ -17,7 +17,7 @@ module secret_impl
    logic [31:0]        accum_q = 0;
    logic [31:0]        secret_value = 9;
 
-   initial $display("%m: initialized");
+   initial $display("[%0t] %m: initialized", $time);
 
    always @(posedge clk) begin
       accum_q <= accum_q + a;

examples/make_protect_lib/sim_main.cpp

@@ -13,28 +13,27 @@
 #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 (false && argc && argv && env) {}
 
-    Verilated::debug(0);
-    Verilated::randReset(2);
-    Verilated::commandArgs(argc, argv);
+    // Construct context to hold simulation time, etc
+    VerilatedContext* contextp = new VerilatedContext;
+    contextp->debug(0);
+    contextp->randReset(2);
+    contextp->commandArgs(argc, argv);
 
     // Construct the Verilated model, including the secret module
-    Vtop* top = new Vtop;
+    Vtop* top = new Vtop{contextp};
 
 #if VM_TRACE
     // When tracing, the contents of the secret module will not be seen
-    VerilatedVcdC* tfp = NULL;
-    const char* flag = Verilated::commandArgsPlusMatch("trace");
+    VerilatedVcdC* tfp = nullptr;
+    const char* flag = contextp->commandArgsPlusMatch("trace");
     if (flag && 0 == strcmp(flag, "+trace")) {
-        Verilated::traceEverOn(true);
+        contextp->traceEverOn(true);
         VL_PRINTF("Enabling waves into logs/vlt_dump.vcd...\n");
         tfp = new VerilatedVcdC;
         top->trace(tfp, 99);
@@ -46,12 +45,12 @@ int main(int argc, char** argv, char** env) {
     top->clk = 0;
 
     // Simulate until $finish
-    while (!Verilated::gotFinish()) {
-        main_time++;
+    while (!contextp->gotFinish()) {
+        contextp->timeInc(1);
         top->clk = ~top->clk & 0x1;
         top->eval();
 #if VM_TRACE
-        if (tfp) tfp->dump(main_time);
+        if (tfp) tfp->dump(contextp->time());
 #endif
     }
 
@@ -62,14 +61,17 @@ 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;
+    delete contextp;
+    contextp = nullptr;
 
-    // Fin
-    exit(0);
+    // Return good completion status
+    // Don't use exit() or destructor won't get called
+    return 0;
 }

examples/make_tracing_c/sim_main.cpp

@@ -5,47 +5,54 @@
 // SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
+// For std::unique_ptr
+#include <memory>
+
 // Include common routines
 #include <verilated.h>
 
 // Include model header, generated from Verilating "top.v"
 #include "Vtop.h"
 
-// Current simulation time (64-bit unsigned)
-vluint64_t main_time = 0;
-// Called by $time in Verilog
-double sc_time_stamp() {
-    return main_time;  // Note does conversion to real, to match SystemC
-}
-
 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 (false && argc && argv && env) {}
 
-    // Set debug level, 0 is off, 9 is highest presently used
-    // May be overridden by commandArgs
-    Verilated::debug(0);
-
-    // Randomization reset policy
-    // May be overridden by commandArgs
-    Verilated::randReset(2);
-
-    // Verilator must compute traced signals
-    Verilated::traceEverOn(true);
-
-    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
-    // This needs to be called before you create any model
-    Verilated::commandArgs(argc, argv);
-
     // Create logs/ directory in case we have traces to put under it
     Verilated::mkdir("logs");
 
-    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v"
-    Vtop* top = new Vtop;  // Or use a const unique_ptr, or the VL_UNIQUE_PTR wrapper
+    // Construct a VerilatedContext to hold simulation time, etc.
+    // Multiple modules (made later below with Vtop) may share the same
+    // context to share time, or modules may have different contexts if
+    // they should be independent from each other.
 
-    // Set some inputs
+    // Using unique_ptr is similar to
+    // "VerilatedContext* contextp = new VerilatedContext" then deleting at end.
+    const std::unique_ptr<VerilatedContext> contextp{new VerilatedContext};
+
+    // Set debug level, 0 is off, 9 is highest presently used
+    // May be overridden by commandArgs argument parsing
+    contextp->debug(0);
+
+    // Randomization reset policy
+    // May be overridden by commandArgs argument parsing
+    contextp->randReset(2);
+
+    // Verilator must compute traced signals
+    contextp->traceEverOn(true);
+
+    // Pass arguments so Verilated code can see them, e.g. $value$plusargs
+    // This needs to be called before you create any model
+    contextp->commandArgs(argc, argv);
+
+    // Construct the Verilated model, from Vtop.h generated from Verilating "top.v".
+    // Using unique_ptr is similar to "Vtop* top = new Vtop" then deleting at end.
+    // "TOP" will be the hierarchical name of the module.
+    const std::unique_ptr<Vtop> top{new Vtop{contextp.get(), "TOP"}};
+
+    // Set Vtop's input signals
     top->reset_l = !0;
     top->clk = 0;
     top->in_small = 1;
@@ -55,8 +62,19 @@ int main(int argc, char** argv, char** env) {
     top->in_wide[2] = 0x3;
 
     // Simulate until $finish
-    while (!Verilated::gotFinish()) {
-        main_time++;  // Time passes...
+    while (!contextp->gotFinish()) {
+        // Historical note, before Verilator 4.200 Verilated::gotFinish()
+        // was used above in place of contextp->gotFinish().
+        // Most of the contextp-> calls can use Verilated:: calls instead;
+        // the Verilated:: versions simply assume there's a single context
+        // being used (per thread).  It's faster and clearer to use the
+        // newer contextp-> versions.
+
+        contextp->timeInc(1);  // 1 timeprecision period passes...
+        // Historical note, before Verilator 4.200 a sc_time_stamp()
+        // function was required instead of using timeInc.  Once timeInc()
+        // is called (with non-zero), the Verilated libraries assume the
+        // new API, and sc_time_stamp() will no longer work.
 
         // Toggle a fast (time/2 period) clock
         top->clk = !top->clk;
@@ -66,7 +84,7 @@ int main(int argc, char** argv, char** env) {
         // this only on a negedge of clk, because we know
         // reset is not sampled there.
         if (!top->clk) {
-            if (main_time > 1 && main_time < 10) {
+            if (contextp->time() > 1 && contextp->time() < 10) {
                 top->reset_l = !1;  // Assert reset
             } else {
                 top->reset_l = !0;  // Deassert reset
@@ -78,29 +96,26 @@ int main(int argc, char** argv, char** env) {
         // Evaluate model
         // (If you have multiple models being simulated in the same
         // timestep then instead of eval(), call eval_step() on each, then
-        // eval_end_step() on each.)
+        // eval_end_step() on each. See the manual.)
         top->eval();
 
         // Read outputs
         VL_PRINTF("[%" VL_PRI64 "d] clk=%x rstl=%x iquad=%" VL_PRI64 "x"
                   " -> oquad=%" VL_PRI64 "x owide=%x_%08x_%08x\n",
-                  main_time, top->clk, top->reset_l, top->in_quad, top->out_quad, top->out_wide[2],
-                  top->out_wide[1], top->out_wide[0]);
+                  contextp->time(), top->clk, top->reset_l, top->in_quad, top->out_quad,
+                  top->out_wide[2], top->out_wide[1], top->out_wide[0]);
     }
 
     // Final model cleanup
     top->final();
 
-    //  Coverage analysis (since test passed)
+    // Coverage analysis (calling write only after the test is known to pass)
 #if VM_COVERAGE
     Verilated::mkdir("logs");
-    VerilatedCov::write("logs/coverage.dat");
+    contextp->coveragep()->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;
 }

examples/make_tracing_sc/sc_main.cpp

@@ -6,6 +6,9 @@
 // SPDX-License-Identifier: CC0-1.0
 //======================================================================
 
+// For std::unique_ptr
+#include <memory>
+
 // SystemC global header
 #include <systemc.h>
 
@@ -26,52 +29,47 @@ int sc_main(int argc, char* argv[]) {
     // Prevent unused variable warnings
     if (false && argc && argv) {}
 
+    // Create logs/ directory in case we have traces to put under it
+    Verilated::mkdir("logs");
+
     // Set debug level, 0 is off, 9 is highest presently used
-    // May be overridden by commandArgs
+    // May be overridden by commandArgs argument parsing
     Verilated::debug(0);
 
     // Randomization reset policy
-    // May be overridden by commandArgs
+    // May be overridden by commandArgs argument parsing
     Verilated::randReset(2);
 
+#if VM_TRACE
+    // Before any evaluation, need to know to calculate those signals only used for tracing
+    Verilated::traceEverOn(true);
+#endif
+
     // Pass arguments so Verilated code can see them, e.g. $value$plusargs
     // This needs to be called before you create any model
     Verilated::commandArgs(argc, argv);
 
-    // Create logs/ directory in case we have traces to put under it
-    Verilated::mkdir("logs");
-
     // 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");
-    // Attach signals to the model
+    // Using unique_ptr is similar to "Vtop* top = new Vtop" then deleting at end
+    const std::unique_ptr<Vtop> top{new Vtop{"top"}};
+
+    // Attach Vtop's signals to this upper model
     top->clk(clk);
     top->fastclk(fastclk);
     top->reset_l(reset_l);
@@ -82,23 +80,14 @@ int sc_main(int argc, char* argv[]) {
     top->out_quad(out_quad);
     top->out_wide(out_wide);
 
-#if VM_TRACE
-    // Before any evaluation, need to know to calculate those signals only used for tracing
-    Verilated::traceEverOn(true);
-#endif
-
     // 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,20 +124,16 @@ int sc_main(int argc, char* argv[]) {
 #if VM_TRACE
     if (tfp) {
         tfp->close();
-        tfp = NULL;
+        tfp = nullptr;
     }
 #endif
 
-    //  Coverage analysis (since test passed)
+    // Coverage analysis (calling write only after the test is known to pass)
 #if VM_COVERAGE
     Verilated::mkdir("logs");
     VerilatedCov::write("logs/coverage.dat");
 #endif
 
-    // Destroy model
-    delete top;
-    top = NULL;
-
-    // Fin
+    // Return good completion status
     return 0;
 }

examples/xml_py/Makefile

@@ -22,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})
@@ -45,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
 
 ######################################################################

examples/xml_py/vl_file_copy

@@ -1,35 +1,41 @@
 #!/usr/bin/env python3
 # -*- Python -*- See copyright, etc below
+# pylint: disable=C0114,C0115,R0903
 ######################################################################
 
 import argparse
 import os
 import re
 import subprocess
-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 += verilator_args
-        self.run_verilator(args)
+        vargs = [
+            '--xml-output',
+            xml_temp.name,
+            '--bbox-sys',  # Parse some stuff can't translate
+            '--bbox-unsup',
+            '--prefix vlxml'
+        ]  # So we know name of .xml output
+        vargs += verilator_args
+        self.run_verilator(vargs)
         self.tree = ET.parse(xml_temp.name)
 
         os.makedirs(output_dir, 0o777, True)
@@ -44,27 +50,29 @@ class VlFileCopy:
                     print("\tcp %s %s" % (filename, output_dir))
                 copy2(filename, output_dir)
 
-    def run_verilator(self, args):
+    def run_verilator(self, vargs):
         """Run Verilator command, check errors"""
         if os.getenv("VERILATOR_ROOT"):
             command = os.getenv("VERILATOR_ROOT") + "/bin/verilator"
         else:
             command = "verilator"
-        command += ' ' + ' '.join(args)
+        command += ' ' + ' '.join(vargs)
         if self.debug:
             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 +80,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,28 +94,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('-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:
-### compile-command: "./vl_file_copy -h ; VERILATOR_ROOT=$V4 ./vl_file_copy +define+thru top.v"
-### End:
+# Local Variables:
+# compile-command: "./vl_file_copy -h ; VERILATOR_ROOT=$V4 ./vl_file_copy +define+thru top.v"
+# End:

examples/xml_py/vl_hier_graph

@@ -1,37 +1,40 @@
 #!/usr/bin/env python3
 # -*- Python -*- See copyright, etc below
+# pylint: disable=C0103,C0114,C0115,C0115,C0116,R0914
 ######################################################################
 
 import argparse
 import os
-import re
 import subprocess
-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 += verilator_args
-        self.run_verilator(args)
+        vargs = [
+            '--xml-output',
+            xml_temp.name,
+            '--bbox-sys',  # Parse some stuff can't translate
+            '--bbox-unsup',
+            '--prefix vlxml'
+        ]  # So we know name of .xml output
+        vargs += verilator_args
+        self.run_verilator(vargs)
         self.tree = ET.parse(xml_temp.name)
 
         with open(output_filename, "w") as fh:
@@ -39,7 +42,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 +53,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,46 +62,47 @@ 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")
 
     def name_to_vertex_number(self, name):
-        if not name in self.name_to_number:
+        if name not in self.name_to_number:
             self.next_vertex_number += 1
             self.name_to_number[name] = self.next_vertex_number
         return self.name_to_number[name]
 
-    def run_verilator(self, args):
+    def run_verilator(self, vargs):
         """Run Verilator command, check errors"""
         if os.getenv("VERILATOR_ROOT"):
             command = os.getenv("VERILATOR_ROOT") + "/bin/verilator"
         else:
             command = "verilator"
-        command += ' ' + ' '.join(args)
+        command += ' ' + ' '.join(vargs)
         if self.debug:
             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,28 +116,34 @@ 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:
-### compile-command: "./vl_hier_graph -h ; VERILATOR_ROOT=$V4 ./vl_hier_graph +define+thru top.v"
-### End:
+# Local Variables:
+# compile-command: "./vl_hier_graph -h ; VERILATOR_ROOT=$V4 ./vl_hier_graph +define+thru top.v"
+# End:

include/gtkwave/fstapi.c

@@ -1806,6 +1806,7 @@ 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);
@@ -1816,10 +1817,11 @@ free(xc->curval_mem);
 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->xc_parent->in_pthread = 0;
-pthread_mutex_unlock(&(xc->xc_parent->mutex));
+xc_parent->in_pthread = 0;
+pthread_mutex_unlock(&(xc_parent->mutex));
 
 return(NULL);
 }

include/verilated.mk.in

@@ -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
@@ -200,9 +201,29 @@ else
   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

include/verilated.v

@@ -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.

include/verilated_config.h.in

@@ -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.

include/verilated_cov.cpp

@@ -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.
@@ -26,10 +26,10 @@
 #include <map>
 
 //=============================================================================
-// VerilatedCovImpBase
-/// Implementation base class for constants
+// VerilatedCovConst
+// Implementation constants
 
-struct VerilatedCovImpBase {
+struct VerilatedCovConst VL_NOT_FINAL {
     // TYPES
     enum { MAX_KEYS = 33 };  /// Maximum user arguments + filename+lineno
     enum { KEY_UNDEF = 0 };  /// Magic key # for unspecified values
@@ -39,20 +39,20 @@ struct VerilatedCovImpBase {
 // VerilatedCovImpItem
 /// Implementation class for a VerilatedCov item
 
-class VerilatedCovImpItem : VerilatedCovImpBase {
+class VerilatedCovImpItem VL_NOT_FINAL {
 public:  // But only local to this file
     // MEMBERS
-    int m_keys[MAX_KEYS];  ///< Key
-    int m_vals[MAX_KEYS];  ///< Value for specified key
+    int m_keys[VerilatedCovConst::MAX_KEYS];  ///< Key
+    int m_vals[VerilatedCovConst::MAX_KEYS];  ///< Value for specified key
     // CONSTRUCTORS
     // Derived classes should call zero() in their constructor
     VerilatedCovImpItem() {
-        for (int i = 0; i < MAX_KEYS; ++i) {
-            m_keys[i] = KEY_UNDEF;
+        for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
+            m_keys[i] = VerilatedCovConst::KEY_UNDEF;
             m_vals[i] = 0;
         }
     }
-    virtual ~VerilatedCovImpItem() {}
+    virtual ~VerilatedCovImpItem() = default;
     virtual vluint64_t count() const = 0;
     virtual void zero() const = 0;
 };
@@ -63,34 +63,36 @@ 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;
 };
 
 //=============================================================================
 // VerilatedCovImp
-/// Implementation class for VerilatedCov.  See that class for public method information.
-/// All value and keys are indexed into a unique number.  Thus we can greatly reduce
-/// the storage requirements for otherwise identical keys.
+///
+/// Implementation class for VerilatedCovContext.  See that class for
+/// public method information.  All value and keys are indexed into a
+/// unique number.  Thus we can greatly reduce the storage requirements for
+/// otherwise identical keys.
 
-class VerilatedCovImp : VerilatedCovImpBase {
+class VerilatedCovImp final : public VerilatedCovContext {
 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;
 
@@ -99,21 +101,21 @@ private:
     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)
+        = (VerilatedCovConst::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
-
-    // CONSTRUCTORS
-    VerilatedCovImp() {
-        m_insertp = NULL;
-        m_insertFilenamep = NULL;
-        m_insertLineno = 0;
-    }
-    VL_UNCOPYABLE(VerilatedCovImp);
+    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
 
 public:
-    ~VerilatedCovImp() { clearGuts(); }
+    // CONSTRUCTORS
+    VerilatedCovImp() = default;
+    VL_UNCOPYABLE(VerilatedCovImp);
+
+protected:
+    friend class VerilatedCovContext;
+    virtual ~VerilatedCovImp() override { clearGuts(); }
     static VerilatedCovImp& imp() VL_MT_SAFE {
         static VerilatedCovImp s_singleton;
         return s_singleton;
@@ -122,14 +124,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
@@ -137,7 +138,7 @@ private:
         for (const char* pos = text.c_str(); *pos; ++pos) {
             if (!isprint(*pos) || *pos == '%' || *pos == '"') {
                 char hex[10];
-                sprintf(hex, "%%%02X", pos[0]);
+                VL_SNPRINTF(hex, 10, "%%%02X", pos[0]);
                 rtn += hex;
             } else {
                 rtn += *pos;
@@ -207,8 +208,8 @@ private:
     }
     bool itemMatchesString(VerilatedCovImpItem* itemp, const std::string& match)
         VL_REQUIRES(m_mutex) {
-        for (int i = 0; i < MAX_KEYS; ++i) {
-            if (itemp->m_keys[i] != KEY_UNDEF) {
+        for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
+            if (itemp->m_keys[i] != VerilatedCovConst::KEY_UNDEF) {
                 // We don't compare keys, only values
                 std::string val = m_indexValues[itemp->m_vals[i]];
                 if (std::string::npos != val.find(match)) {  // Found
@@ -235,29 +236,26 @@ private:
 #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 = VerilatedCovConst::KEY_UNDEF + 1;
     }
 
 public:
     // PUBLIC METHODS
-    void clear() VL_EXCLUDES(m_mutex) {
+    void clear() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock(m_mutex);
         clearGuts();
     }
-    void clearNonMatch(const char* matchp) VL_EXCLUDES(m_mutex) {
+    void clearNonMatch(const char* matchp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         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 {
@@ -267,26 +265,25 @@ public:
             m_items = newlist;
         }
     }
-    void zero() VL_EXCLUDES(m_mutex) {
+    void zero() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock(m_mutex);
-        for (ItemList::const_iterator it = m_items.begin(); it != m_items.end(); ++it) {
-            (*it)->zero();
-        }
+        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) {
+    void inserti(VerilatedCovImpItem* itemp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         const VerilatedLockGuard lock(m_mutex);
         assert(!m_insertp);
         m_insertp = itemp;
     }
-    void insertf(const char* filenamep, int lineno) VL_EXCLUDES(m_mutex) {
+    void insertf(const char* filenamep, int lineno) VL_MT_SAFE_EXCLUDES(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) {
+    void insertp(const char* ckeyps[VerilatedCovConst::MAX_KEYS],
+                 const char* valps[VerilatedCovConst::MAX_KEYS]) VL_MT_SAFE_EXCLUDES(m_mutex) {
         const VerilatedLockGuard lock(m_mutex);
         assert(m_insertp);
         // First two key/vals are filename
@@ -305,14 +302,14 @@ public:
         valps[2] = page_default.c_str();
 
         // Keys -> strings
-        std::string keys[MAX_KEYS];
-        for (int i = 0; i < MAX_KEYS; ++i) {
-            if (ckeyps[i] && ckeyps[i][0]) { keys[i] = ckeyps[i]; }
+        std::string keys[VerilatedCovConst::MAX_KEYS];
+        for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
+            if (ckeyps[i] && ckeyps[i][0]) keys[i] = ckeyps[i];
         }
         // Ignore empty keys
-        for (int i = 0; i < MAX_KEYS; ++i) {
+        for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
             if (!keys[i].empty()) {
-                for (int j = i + 1; j < MAX_KEYS; ++j) {
+                for (int j = i + 1; j < VerilatedCovConst::MAX_KEYS; ++j) {
                     if (keys[i] == keys[j]) {  // Duplicate key.  Keep the last one
                         keys[i] = "";
                         break;
@@ -322,7 +319,7 @@ public:
         }
         // Insert the values
         int addKeynum = 0;
-        for (int i = 0; i < MAX_KEYS; ++i) {
+        for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
             const std::string key = keys[i];
             if (!keys[i].empty()) {
                 const std::string val = valps[i];
@@ -340,10 +337,10 @@ public:
         }
         m_items.push_back(m_insertp);
         // Prepare for next
-        m_insertp = NULL;
+        m_insertp = nullptr;
     }
 
-    void write(const char* filename) VL_EXCLUDES(m_mutex) {
+    void write(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock(m_mutex);
 #ifndef VM_COVERAGE
@@ -360,16 +357,15 @@ 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;
 
-            for (int i = 0; i < MAX_KEYS; ++i) {
-                if (itemp->m_keys[i] != KEY_UNDEF) {
+            for (int i = 0; i < VerilatedCovConst::MAX_KEYS; ++i) {
+                if (itemp->m_keys[i] != VerilatedCovConst::KEY_UNDEF) {
                     std::string key = VerilatedCovKey::shortKey(m_indexValues[itemp->m_keys[i]]);
                     std::string val = m_indexValues[itemp->m_vals[i]];
                     if (key == VL_CIK_PER_INSTANCE) {
@@ -394,86 +390,84 @@ 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';
         }
     }
 };
 
 //=============================================================================
-// VerilatedCov
+// VerilatedCovContext
 
-void VerilatedCov::clear() VL_MT_SAFE { VerilatedCovImp::imp().clear(); }
-void VerilatedCov::clearNonMatch(const char* matchp) VL_MT_SAFE {
-    VerilatedCovImp::imp().clearNonMatch(matchp);
+void VerilatedCovContext::clear() VL_MT_SAFE { impp()->clear(); }
+void VerilatedCovContext::clearNonMatch(const char* matchp) VL_MT_SAFE {
+    impp()->clearNonMatch(matchp);
 }
-void VerilatedCov::zero() VL_MT_SAFE { VerilatedCovImp::imp().zero(); }
-void VerilatedCov::write(const char* filenamep) VL_MT_SAFE {
-    VerilatedCovImp::imp().write(filenamep);
+void VerilatedCovContext::zero() VL_MT_SAFE { impp()->zero(); }
+void VerilatedCovContext::write(const char* filenamep) VL_MT_SAFE { impp()->write(filenamep); }
+void VerilatedCovContext::_inserti(vluint32_t* itemp) VL_MT_SAFE {
+    impp()->inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp));
 }
-void VerilatedCov::_inserti(vluint32_t* itemp) VL_MT_SAFE {
-    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint32_t>(itemp));
+void VerilatedCovContext::_inserti(vluint64_t* itemp) VL_MT_SAFE {
+    impp()->inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp));
 }
-void VerilatedCov::_inserti(vluint64_t* itemp) VL_MT_SAFE {
-    VerilatedCovImp::imp().inserti(new VerilatedCoverItemSpec<vluint64_t>(itemp));
-}
-void VerilatedCov::_insertf(const char* filename, int lineno) VL_MT_SAFE {
-    VerilatedCovImp::imp().insertf(filename, lineno);
+void VerilatedCovContext::_insertf(const char* filename, int lineno) VL_MT_SAFE {
+    impp()->insertf(filename, lineno);
 }
 
 #define K(n) const char* key##n
 #define A(n) const char *key##n, const char *valp##n  // Argument list
 #define C(n) key##n, valp##n  // Calling argument list
 #define N(n) "", ""  // Null argument list
-void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9), A(10),
-                            A(11), A(12), A(13), A(14), A(15), A(16), A(17), A(18), A(19), A(20),
-                            A(21), A(22), A(23), A(24), A(25), A(26), A(27), A(28),
-                            A(29)) VL_MT_SAFE {
-    const char* keyps[VerilatedCovImpBase::MAX_KEYS]
-        = {NULL,  NULL,  NULL,  // filename,lineno,page
-           key0,  key1,  key2,  key3,  key4,  key5,  key6,  key7,  key8,  key9,
-           key10, key11, key12, key13, key14, key15, key16, key17, key18, key19,
-           key20, key21, key22, key23, key24, key25, key26, key27, key28, key29};
-    const char* valps[VerilatedCovImpBase::MAX_KEYS]
-        = {NULL,   NULL,   NULL,  // filename,lineno,page
-           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);
+void VerilatedCovContext::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9),
+                                   A(10), A(11), A(12), A(13), A(14), A(15), A(16), A(17), A(18),
+                                   A(19), A(20), A(21), A(22), A(23), A(24), A(25), A(26), A(27),
+                                   A(28), A(29)) VL_MT_SAFE {
+    const char* keyps[VerilatedCovConst::MAX_KEYS]
+        = {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[VerilatedCovConst::MAX_KEYS]
+        = {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};
+    impp()->insertp(keyps, valps);
 }
 
 // And versions with fewer arguments  (oh for a language with named parameters!)
-void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8),
-                            A(9)) VL_MT_SAFE {
+void VerilatedCovContext::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8),
+                                   A(9)) VL_MT_SAFE {
     _insertp(C(0), C(1), C(2), C(3), C(4), C(5), C(6), C(7), C(8), C(9), N(10), N(11), N(12),
              N(13), N(14), N(15), N(16), N(17), N(18), N(19), N(20), N(21), N(22), N(23), N(24),
              N(25), N(26), N(27), N(28), N(29));
 }
-void VerilatedCov::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9), A(10),
-                            A(11), A(12), A(13), A(14), A(15), A(16), A(17), A(18),
-                            A(19)) VL_MT_SAFE {
+void VerilatedCovContext::_insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9),
+                                   A(10), A(11), A(12), A(13), A(14), A(15), A(16), A(17), A(18),
+                                   A(19)) VL_MT_SAFE {
     _insertp(C(0), C(1), C(2), C(3), C(4), C(5), C(6), C(7), C(8), C(9), C(10), C(11), C(12),
              C(13), C(14), C(15), C(16), C(17), C(18), C(19), N(20), N(21), N(22), N(23), N(24),
              N(25), N(26), N(27), N(28), N(29));
 }
 // Backward compatibility for Verilator
-void VerilatedCov::_insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4),
-                            const std::string& val4, A(5), A(6), A(7)) VL_MT_SAFE {
+void VerilatedCovContext::_insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4),
+                                   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),
@@ -484,3 +478,26 @@ void VerilatedCov::_insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4),
 #undef C
 #undef N
 #undef K
+
+//=============================================================================
+// VerilatedCov
+
+#ifndef VL_NO_LEGACY
+VerilatedCovContext* VerilatedCov::threadCovp() VL_MT_SAFE {
+    return Verilated::threadContextp()->coveragep();
+}
+#endif
+
+//=============================================================================
+// VerilatedContext
+
+VerilatedCovContext* VerilatedContext::coveragep() VL_MT_SAFE {
+    static VerilatedMutex s_mutex;
+    if (VL_UNLIKELY(!m_coveragep)) {
+        const VerilatedLockGuard lock(s_mutex);
+        if (VL_LIKELY(!m_coveragep)) {  // Not redundant, prevents race
+            m_coveragep.reset(new VerilatedCovImp);
+        }
+    }
+    return reinterpret_cast<VerilatedCovContext*>(m_coveragep.get());
+}

include/verilated_cov.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.
@@ -16,15 +16,18 @@
 ///
 //=============================================================================
 
-#ifndef _VERILATED_COV_H_
-#define _VERILATED_COV_H_ 1
+#ifndef VERILATOR_VERILATED_COV_H_
+#define VERILATOR_VERILATED_COV_H_
 
 #include "verilatedos.h"
+#include "verilated.h"
 
 #include <iostream>
 #include <sstream>
 #include <string>
 
+class VerilatedCovImp;
+
 //=============================================================================
 /// Conditionally compile coverage code
 
@@ -68,9 +71,9 @@
 ///             VL_COVER_INSERT(&m_cases[i], "comment", "Coverage Case", "i", cvtToNumStr(i));
 ///     }
 
-#define VL_COVER_INSERT(countp, ...) \
-    VL_IF_COVER(VerilatedCov::_inserti(countp); VerilatedCov::_insertf(__FILE__, __LINE__); \
-                VerilatedCov::_insertp("hier", name(), __VA_ARGS__))
+#define VL_COVER_INSERT(covcontextp, countp, ...) \
+    VL_IF_COVER(covcontextp->_inserti(countp); covcontextp->_insertf(__FILE__, __LINE__); \
+                covcontextp->_insertp("hier", name(), __VA_ARGS__))
 
 //=============================================================================
 /// Convert VL_COVER_INSERT value arguments to strings
@@ -83,55 +86,101 @@ template <class T> std::string vlCovCvtToStr(const T& t) VL_PURE {
 
 //=============================================================================
 //  VerilatedCov
-///  Verilator coverage global class
-////
-/// Global class with methods affecting all coverage data.
+///  Verilator coverage per-context structure
 /// All public methods in this class are thread safe.
 
-class VerilatedCov {
-    VL_UNCOPYABLE(VerilatedCov);
+class VerilatedCovContext VL_NOT_FINAL : public VerilatedVirtualBase {
+    VL_UNCOPYABLE(VerilatedCovContext);
 
 public:
-    // GLOBAL METHODS
+    // METHODS
     /// Return default filename
     static const char* defaultFilename() VL_PURE { return "coverage.dat"; }
     /// Write all coverage data to a file
-    static void write(const char* filenamep = defaultFilename()) VL_MT_SAFE;
+    void write(const char* filenamep = defaultFilename()) VL_MT_SAFE;
+    /// Clear coverage points (and call delete on all items)
+    void clear() VL_MT_SAFE;
+    /// Clear items not matching the provided string
+    void clearNonMatch(const char* matchp) VL_MT_SAFE;
+    /// Zero coverage points
+    void zero() VL_MT_SAFE;
+
+public:  // But Internal use only
     /// Insert a coverage item
     /// We accept from 1-30 key/value pairs, all as strings.
     /// Call _insert1, followed by _insert2 and _insert3
     /// Do not call directly; use VL_COVER_INSERT or higher level macros instead
     // _insert1: Remember item pointer with count.  (Not const, as may add zeroing function)
-    static void _inserti(vluint32_t* itemp) VL_MT_SAFE;
-    static void _inserti(vluint64_t* itemp) VL_MT_SAFE;
+    void _inserti(vluint32_t* itemp) VL_MT_SAFE;
+    void _inserti(vluint64_t* itemp) VL_MT_SAFE;
     // _insert2: Set default filename and line number
-    static void _insertf(const char* filename, int lineno) VL_MT_SAFE;
+    void _insertf(const char* filename, int lineno) VL_MT_SAFE;
     // _insert3: Set parameters
     // We could have just the maximum argument version, but this compiles
     // much slower (nearly 2x) than having smaller versions also.  However
     // there's not much more gain in having a version for each number of args.
 #define K(n) const char* key##n
 #define A(n) const char *key##n, const char *valp##n  // Argument list
-#define D(n) const char *key##n = NULL, const char *valp##n = NULL  // Argument list
-    static void _insertp(D(0), D(1), D(2), D(3), D(4), D(5), D(6), D(7), D(8), D(9));
-    static void _insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9), A(10), D(11),
-                         D(12), D(13), D(14), D(15), D(16), D(17), D(18), D(19));
-    static void _insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9), A(10), A(11),
-                         A(12), A(13), A(14), A(15), A(16), A(17), A(18), A(19), A(20), D(21),
-                         D(22), D(23), D(24), D(25), D(26), D(27), D(28), D(29));
+#define D(n) const char *key##n = nullptr, const char *valp##n = nullptr  // Argument list
+    void _insertp(D(0), D(1), D(2), D(3), D(4), D(5), D(6), D(7), D(8), D(9));
+    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));
+    void _insertp(A(0), A(1), A(2), A(3), A(4), A(5), A(6), A(7), A(8), A(9), A(10), A(11), A(12),
+                  A(13), A(14), A(15), A(16), A(17), A(18), A(19), A(20), D(21), D(22), D(23),
+                  D(24), D(25), D(26), D(27), D(28), D(29));
     // Backward compatibility for Verilator
-    static void _insertp(A(0), A(1), K(2), int val2, K(3), int val3, K(4), const std::string& val4,
-                         A(5), A(6), A(7));
+    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(7));
 
 #undef K
 #undef A
 #undef D
-    /// Clear coverage points (and call delete on all items)
-    static void clear() VL_MT_SAFE;
-    /// Clear items not matching the provided string
-    static void clearNonMatch(const char* matchp) VL_MT_SAFE;
-    /// Zero coverage points
-    static void zero() VL_MT_SAFE;
+
+protected:
+    friend class VerilatedCovImp;
+    // CONSTRUCTORS
+    // Internal: Only made as part of VerilatedCovImp
+    VerilatedCovContext() {}
+    virtual ~VerilatedCovContext() {}
+
+    // METHODS
+    // Internal: access to implementation class
+    VerilatedCovImp* impp() { return reinterpret_cast<VerilatedCovImp*>(this); }
 };
 
+//=============================================================================
+//  VerilatedCov
+///  Verilator coverage global class
+///
+/// Global class that accesses via current thread's context.  These are
+/// provided for backward-compatibility, use VerilatedContext->coveragep()
+/// instead.
+
+#ifndef VL_NO_LEGACY
+class VerilatedCov final {
+    VL_UNCOPYABLE(VerilatedCov);
+
+public:
+    // METHODS
+    /// Return default filename for the current thread
+    static const char* defaultFilename() VL_PURE { return VerilatedCovContext::defaultFilename(); }
+    /// Write all coverage data to a file for the current thread
+    static void write(const char* filenamep = defaultFilename()) VL_MT_SAFE {
+        threadCovp()->write(filenamep);
+    }
+    /// Clear coverage points (and call delete on all items) for the current thread
+    static void clear() VL_MT_SAFE { threadCovp()->clear(); }
+    /// Clear items not matching the provided string for the current thread
+    static void clearNonMatch(const char* matchp) VL_MT_SAFE {
+        threadCovp()->clearNonMatch(matchp);
+    }
+    /// Zero coverage points for the current thread
+    static void zero() VL_MT_SAFE { threadCovp()->zero(); }
+
+private:
+    /// Current thread's coverage structure
+    static VerilatedCovContext* threadCovp() VL_MT_SAFE;
+};
+#endif
+
 #endif  // Guard

include/verilated_cov_key.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.
@@ -16,8 +16,8 @@
 ///
 //=============================================================================
 
-#ifndef _VERILATED_COV_KEY_H_
-#define _VERILATED_COV_KEY_H_ 1
+#ifndef VERILATOR_VERILATED_COV_KEY_H_
+#define VERILATOR_VERILATED_COV_KEY_H_
 
 #include "verilatedos.h"
 
@@ -29,69 +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=>'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=>'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"
@@ -102,38 +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;

include/verilated_dpi.cpp

@@ -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.
@@ -19,7 +19,7 @@
 ///
 //=========================================================================
 
-#define _VERILATED_DPI_CPP_
+#define VERILATOR_VERILATED_DPI_CPP_
 
 #include "verilatedos.h"
 #include "verilated_dpi.h"
@@ -37,16 +37,11 @@
 //======================================================================
 // 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__)
+#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 " \
+#define VL_SVDPI_CONTEXT_WARN_() \
+    VL_SVDPI_WARN_("%%Warning: DPI C Function called by Verilog DPI import with missing " \
                    "'context' keyword.\n")
 
 //======================================================================
@@ -125,7 +120,7 @@ void svGetPartselLogic(svLogicVecVal* dp, const svLogicVecVal* sp, int lsb, int
     dp[VL_WORDS_I(width) - 1].bval &= VL_MASK_I(width);
 }
 void svPutPartselBit(svBitVecVal* dp, const svBitVecVal s, int lbit, int width) {
-    // See also _VL_INSERT_WI
+    // See also _vl_insert_WI
     int hbit = lbit + width - 1;
     int hoffset = VL_BITBIT_I(hbit);
     int loffset = VL_BITBIT_I(lbit);
@@ -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
@@ -223,56 +218,46 @@ static void* _vl_sv_adjusted_datap(const VerilatedDpiOpenVar* varp, int nargs, i
                                    int indx2, int indx3) {
     void* datap = varp->datap();
     if (VL_UNLIKELY(nargs != varp->udims())) {
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function called on"
+        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);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 1 "
+            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) {
         datap = varp->datapAdjustIndex(datap, 2, indx2);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 2 "
+            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) {
         datap = varp->datapAdjustIndex(datap, 3, indx3);
         if (VL_UNLIKELY(!datap)) {
-            _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function index 3 "
+            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:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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,20 +339,20 @@ 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;
-    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1], s[0]); break;
+    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = VL_SET_QII(s[1], s[0]); break;
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
         for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i];
         return;
     }
-    default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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,22 +361,20 @@ 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;
-    case VLVT_UINT64:
-        *(reinterpret_cast<QData*>(datap)) = _VL_SET_QII(s[1].aval, s[0].aval);
-        break;
+    case VLVT_UINT64: *(reinterpret_cast<QData*>(datap)) = VL_SET_QII(s[1].aval, s[0].aval); break;
     case VLVT_WDATA: {
         WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
         for (int i = 0; i < VL_WORDS_I(varp->packed().elements()); ++i) wdatap[i] = s[i].aval;
         return;
     }
-    default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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 +383,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)) & 1ULL;
-    case VLVT_WDATA: {
-        WDataOutP wdatap = (reinterpret_cast<WDataOutP>(datap));
-        return VL_BITRSHIFT_W(wdatap, lsb) & 1;
-    }
-    default:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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 +399,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:
-        _VL_SVDPI_WARN("%%Warning: DPI svOpenArrayHandle function unsupported datatype (%d).\n",
+    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 +596,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 +629,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 +664,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 +695,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);
@@ -793,8 +718,8 @@ void svPutLogicArrElem3(const svOpenArrayHandle d, svLogic value, int indx1, int
 
 svScope svGetScope() {
     if (VL_UNLIKELY(!Verilated::dpiInContext())) {
-        _VL_SVDPI_CONTEXT_WARN();
-        return NULL;
+        VL_SVDPI_CONTEXT_WARN_();
+        return nullptr;
     }
     // NOLINTNEXTLINE(google-readability-casting)
     return (svScope)(Verilated::dpiScope());
@@ -815,7 +740,7 @@ const char* svGetNameFromScope(const svScope scope) {
 
 svScope svGetScopeFromName(const char* scopeName) {
     // NOLINTNEXTLINE(google-readability-casting)
-    return (svScope)(VerilatedImp::scopeFind(scopeName));
+    return (svScope)(Verilated::threadContextp()->scopeFind(scopeName));
 }
 
 int svPutUserData(const svScope scope, void* userKey, void* userData) {
@@ -829,7 +754,7 @@ void* svGetUserData(const svScope scope, void* userKey) {
 
 int svGetCallerInfo(const char** fileNamepp, int* lineNumberp) {
     if (VL_UNLIKELY(!Verilated::dpiInContext())) {
-        _VL_SVDPI_CONTEXT_WARN();
+        VL_SVDPI_CONTEXT_WARN_();
         return false;
     }
     if (VL_LIKELY(fileNamepp)) *fileNamepp = Verilated::dpiFilenamep();  // thread local

include/verilated_dpi.h

@@ -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.
@@ -20,8 +20,8 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_DPI_H_
-#define _VERILATED_DPI_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_DPI_H_
+#define VERILATOR_VERILATED_DPI_H_  ///< Header Guard
 
 #include "verilatedos.h"
 #include "verilated.h"  // Also presumably included by caller
@@ -32,18 +32,18 @@
 //===================================================================
 // SETTING OPERATORS
 
-/// Convert svBitVecVal to Verilator internal data
+// Convert svBitVecVal to Verilator internal data
 static inline void VL_SET_W_SVBV(int obits, WDataOutP owp, const svBitVecVal* lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
     for (int i = 0; i < words - 1; ++i) owp[i] = lwp[i];
     owp[words - 1] = lwp[words - 1] & VL_MASK_I(obits);
 }
 static inline QData VL_SET_Q_SVBV(const svBitVecVal* lwp) VL_MT_SAFE {
-    return _VL_SET_QII(lwp[1], lwp[0]);
+    return VL_SET_QII(lwp[1], lwp[0]);
 }
 static inline IData VL_SET_I_SVBV(const svBitVecVal* lwp) VL_MT_SAFE { return lwp[0]; }
 
-/// Convert Verilator internal data to svBitVecVal
+// Convert Verilator internal data to svBitVecVal
 static inline void VL_SET_SVBV_W(int obits, svBitVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
     for (int i = 0; i < words - 1; ++i) owp[i] = lwp[i];
@@ -54,20 +54,20 @@ static inline void VL_SET_SVBV_Q(int, svBitVecVal* owp, QData ld) VL_MT_SAFE {
     VL_SET_WQ(owp, ld);
 }
 
-/// Convert svLogicVecVal to Verilator internal data
-/// Note these functions ignore X/Z in svLogicVecVal
+// Convert svLogicVecVal to Verilator internal data
+// Note these functions ignore X/Z in svLogicVecVal
 static inline void VL_SET_W_SVLV(int obits, WDataOutP owp, const svLogicVecVal* lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
     for (int i = 0; i < words - 1; ++i) owp[i] = lwp[i].aval;
     owp[words - 1] = lwp[words - 1].aval & VL_MASK_I(obits);
 }
 static inline QData VL_SET_Q_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE {
-    return _VL_SET_QII(lwp[1].aval, lwp[0].aval);
+    return VL_SET_QII(lwp[1].aval, lwp[0].aval);
 }
 static inline IData VL_SET_I_SVLV(const svLogicVecVal* lwp) VL_MT_SAFE { return lwp[0].aval; }
 
-/// Convert Verilator internal data to svLogicVecVal
-/// Note these functions never create X/Z in svLogicVecVal
+// Convert Verilator internal data to svLogicVecVal
+// Note these functions never create X/Z in svLogicVecVal
 static inline void VL_SET_SVLV_W(int obits, svLogicVecVal* owp, WDataInP lwp) VL_MT_SAFE {
     int words = VL_WORDS_I(obits);
     for (int i = 0; i < words; ++i) owp[i].bval = 0;

include/verilated_fst_c.cpp

@@ -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.
@@ -15,7 +15,6 @@
 /// \brief C++ Tracing in FST Format
 ///
 //=============================================================================
-// SPDIFF_OFF
 
 // clang-format off
 
@@ -58,18 +57,16 @@
 // 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 {
-    m_assertOne.check();
+void VerilatedFst::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
     m_fst = fstWriterCreate(filename, 1);
     fstWriterSetPackType(m_fst, FST_WR_PT_LZ4);
     fstWriterSetTimescaleFromString(m_fst, timeResStr().c_str());  // lintok-begin-on-ref
@@ -82,7 +79,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);
@@ -91,26 +88,24 @@ 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();
+void VerilatedFst::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
+    VerilatedTrace<VerilatedFst>::closeBase();
     fstWriterClose(m_fst);
-    m_fst = NULL;
+    m_fst = nullptr;
 }
 
-void VerilatedFst::flush() {
-    VerilatedTrace<VerilatedFst>::flush();
+void VerilatedFst::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
+    VerilatedTrace<VerilatedFst>::flushBase();
     fstWriterFlushContext(m_fst);
 }
 
@@ -142,8 +137,8 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
     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;
@@ -158,7 +153,7 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
 
     // 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);
     }
@@ -173,7 +168,7 @@ void VerilatedFst::declare(vluint32_t code, const char* name, int dtypenum, fstV
         fstWriterEmitEnumTableRef(m_fst, enumNum);
     }
 
-    Code2SymbolType::const_iterator it = m_code2symbol.find(code);
+    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);

include/verilated_fst_c.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.
@@ -17,8 +17,8 @@
 //=============================================================================
 // SPDIFF_OFF
 
-#ifndef _VERILATED_FST_C_H_
-#define _VERILATED_FST_C_H_ 1
+#ifndef VERILATOR_VERILATED_FST_C_H_
+#define VERILATOR_VERILATED_FST_C_H_
 
 #include "verilated.h"
 #include "verilated_trace.h"
@@ -32,10 +32,10 @@
 
 //=============================================================================
 // VerilatedFst
-/// Base class to create a Verilator FST dump
-/// This is an internally used class - see VerilatedFstC for what to call from applications
+// 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,8 +50,8 @@ 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);
@@ -63,11 +63,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 { 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.
@@ -82,27 +82,28 @@ protected:
 public:
     //=========================================================================
     // External interface to client code
+    // (All must be threadsafe)
 
-    explicit VerilatedFst(void* fst = NULL);
+    explicit VerilatedFst(void* fst = nullptr);
     ~VerilatedFst();
 
-    /// Open the file; call isOpen() to see if errors
-    void open(const char* filename) VL_MT_UNSAFE;
-    /// Close the file
-    void close() VL_MT_UNSAFE;
-    /// Flush any remaining data to this file
-    void flush() VL_MT_UNSAFE;
-    /// Is file open?
-    bool isOpen() const { return m_fst != NULL; }
+    // Open the file; call isOpen() to see if errors
+    void open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Close the file
+    void close() VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Flush any remaining data to this file
+    void flush() VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Return if file is open
+    bool isOpen() const VL_MT_SAFE { return m_fst != nullptr; }
 
     //=========================================================================
     // Internal interface to Verilator generated code
 
-    /// Inside dumping routines, declare a data type
+    // Inside dumping routines, declare a data type
     void declDTypeEnum(int dtypenum, const char* name, vluint32_t elements,
                        unsigned int minValbits, const char** itemNamesp, const char** itemValuesp);
 
-    /// Inside dumping routines, declare a signal
+    // Inside dumping routines, declare a signal
     void declBit(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
                  fstVarType vartype, bool array, int arraynum);
     void declBus(vluint32_t code, const char* name, int dtypenum, fstVarDir vardir,
@@ -126,31 +127,30 @@ template <> void VerilatedTrace<VerilatedFst>::set_time_resolution(const std::st
 // VerilatedFstC
 /// Create a FST dump file in C standalone (no SystemC) simulations.
 /// 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) {}
+    /// Construct the dump. Optional argument is ignored.
+    explicit VerilatedFstC(void* filep = nullptr)
+        : m_sptrace{filep} {}
+    /// Destruct, flush, and close the dump
     ~VerilatedFstC() { close(); }
-    /// Routines can only be called from one thread; allow next call from different thread
-    void changeThread() { spTrace()->changeThread(); }
 
-    // ACCESSORS
-    /// Is file open?
-    bool isOpen() const { return m_sptrace.isOpen(); }
-    // METHODS
+    // METHODS - User called
+
+    /// Return if file is open
+    bool isOpen() const VL_MT_SAFE { return m_sptrace.isOpen(); }
     /// Open a new FST file
-    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
+    void open(const char* filename) VL_MT_SAFE { m_sptrace.open(filename); }
     /// Close dump
-    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
+    void close() VL_MT_SAFE { m_sptrace.close(); }
     /// Flush dump
-    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
+    void flush() VL_MT_SAFE { m_sptrace.flush(); }
     /// Write one cycle of dump data
     void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
     /// Write one cycle of dump data - backward compatible and to reduce
@@ -158,16 +158,26 @@ public:
     void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
-    /// Set time units (s/ms, defaults to ns)
-    /// For Verilated models, these propage from the Verilated default --timeunit
-    void set_time_unit(const char* unitp) { m_sptrace.set_time_unit(unitp); }
-    void set_time_unit(const std::string& unit) { m_sptrace.set_time_unit(unit); }
-    /// Set time resolution (s/ms, defaults to ns)
-    /// For Verilated models, these propage from the Verilated default --timeunit
-    void set_time_resolution(const char* unitp) { m_sptrace.set_time_resolution(unitp); }
-    void set_time_resolution(const std::string& unit) { m_sptrace.set_time_resolution(unit); }
 
-    /// Internal class access
+    // METHODS - Internal/backward compatible
+    // \protectedsection
+
+    // Set time units (s/ms, defaults to ns)
+    // Users should not need to call this, as for Verilated models, these
+    // propage from the Verilated default timeunit
+    void set_time_unit(const char* unitp) VL_MT_SAFE { m_sptrace.set_time_unit(unitp); }
+    void set_time_unit(const std::string& unit) VL_MT_SAFE { m_sptrace.set_time_unit(unit); }
+    // Set time resolution (s/ms, defaults to ns)
+    // Users should not need to call this, as for Verilated models, these
+    // propage from the Verilated default timeprecision
+    void set_time_resolution(const char* unitp) VL_MT_SAFE {
+        m_sptrace.set_time_resolution(unitp);
+    }
+    void set_time_resolution(const std::string& unit) VL_MT_SAFE {
+        m_sptrace.set_time_resolution(unit);
+    }
+
+    // Internal class access
     inline VerilatedFst* spTrace() { return &m_sptrace; };
 };
 

include/verilated_heavy.h

@@ -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.
@@ -21,15 +21,18 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_HEAVY_H_
-#define _VERILATED_HEAVY_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_HEAVY_H_
+#define VERILATOR_VERILATED_HEAVY_H_  ///< Header Guard
 
 #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,13 +69,13 @@ 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
@@ -69,28 +83,38 @@ class VlWriteMem {
 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 {
@@ -108,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
@@ -254,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;
@@ -269,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()
@@ -328,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 {
@@ -339,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 + "} ";
@@ -374,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) {
@@ -394,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
 
@@ -404,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);
@@ -440,8 +900,8 @@ extern IData VL_SSCANF_INX(int lbits, const std::string& ld, const char* formatp
 extern void VL_SFORMAT_X(int obits_ignored, std::string& output, const char* formatp,
                          ...) VL_MT_SAFE;
 extern std::string VL_SFORMATF_NX(const char* formatp, ...) VL_MT_SAFE;
-extern void VL_TIMEFORMAT_IINI(int units, int precision, const std::string& suffix,
-                               int width) VL_MT_SAFE;
+extern void VL_TIMEFORMAT_IINI(int units, int precision, const std::string& suffix, int width,
+                               VerilatedContext* contextp) VL_MT_SAFE;
 extern IData VL_VALUEPLUSARGS_INW(int rbits, const std::string& ld, WDataOutP rwp) VL_MT_SAFE;
 inline IData VL_VALUEPLUSARGS_INI(int rbits, const std::string& ld, CData& rdr) VL_MT_SAFE {
     WData rwp[2];  // WData must always be at least 2
@@ -485,21 +945,15 @@ 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;
 
-//======================================================================
-// Dumping
-
-extern const char* vl_dumpctl_filenamep(bool setit = false,
-                                        const std::string& filename = "") VL_MT_SAFE;
+extern IData VL_FGETS_NI(std::string& dest, IData fpi);
 
 #endif  // Guard

include/verilated_imp.h

@@ -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.
@@ -16,11 +16,12 @@
 ///
 //=========================================================================
 
-#ifndef _VERILATED_IMP_H_
-#define _VERILATED_IMP_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_IMP_H_
+#define VERILATOR_VERILATED_IMP_H_  ///< Header Guard
 
 // clang-format off
-#if !defined(_VERILATED_CPP_) && !defined(_VERILATED_DPI_CPP_) && !defined(_VERILATED_VPI_CPP_)
+#if !defined(VERILATOR_VERILATED_CPP_) && !defined(VERILATOR_VERILATED_DPI_CPP_) \
+    && !defined(VERILATOR_VERILATED_VPI_CPP_) && !defined(VERILATOR_VERILATED_SAVE_CPP_)
 # error "verilated_imp.h only to be included by verilated*.cpp internals"
 #endif
 
@@ -46,7 +47,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 {
@@ -61,10 +62,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
@@ -74,7 +79,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)
@@ -84,10 +89,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,13 +100,13 @@ private:
 public:
     // METHODS
     //// Add message to queue (called by producer)
-    void post(const VerilatedMsg& msg) VL_EXCLUDES(m_mutex) {
+    void post(const VerilatedMsg& msg) VL_MT_SAFE_EXCLUDES(m_mutex) {
         const VerilatedLockGuard lock(m_mutex);
         m_queue.insert(msg);  // Pass by value to copy the message into queue
         ++m_depth;
     }
     /// Service queue until completion (called by consumer)
-    void process() VL_EXCLUDES(m_mutex) {
+    void process() VL_MT_SAFE_EXCLUDES(m_mutex) {
         // Tracking m_depth is redundant to e.g. getting the mutex and looking at queue size,
         // but on the reader side it's 4x faster to test an atomic then getting a mutex
         while (m_depth) {
@@ -112,7 +117,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();
@@ -126,7 +131,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:
@@ -170,14 +175,13 @@ public:
 #endif  // VL_THREADED
 
 // FILE* list constructed from a file-descriptor
-class VerilatedFpList {
+class VerilatedFpList final {
     FILE* m_fp[31];
-    std::size_t m_sz;
+    std::size_t m_sz = 0;
 
 public:
     typedef FILE* const* const_iterator;
-    explicit VerilatedFpList()
-        : m_sz(0) {}
+    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; }
@@ -187,217 +191,331 @@ public:
     }
 };
 
+//======================================================================
+// VerilatedContextImpData
+
+/// Class for hidden implementation members inside VerilatedContext
+// Avoids needing std::unordered_map inside verilated.h
+class VerilatedContextImpData final {
+    friend class VerilatedContext;
+    friend class VerilatedContextImp;
+
+protected:
+    /// Map of <scope_name, scope pointer>
+    // Used by scopeInsert, scopeFind, scopeErase, scopeNameMap
+    mutable VerilatedMutex m_nameMutex;  ///< Protect m_nameMap
+    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);
+};
+
+//======================================================================
+// VerilatedContextImp
+// Class to "add" implementation-only methods to VerilatedContext
+
+class VerilatedContextImp final : VerilatedContext {
+    friend class VerilatedContext;
+
+    // MEMBERS - non-static not allowed, use only VerilatedContext
+    // Select initial value of otherwise uninitialized signals.
+    // Internal note: Globals may multi-construct, see verilated.cpp top.
+
+    // Medium speed, so uses singleton accessing
+    struct Statics {
+        VerilatedMutex s_randMutex;  // Mutex protecting s_randSeedEpoch
+        // Number incrementing on each reseed, 0=illegal
+        int s_randSeedEpoch = 1;  // Reads ok, wish had a VL_WRITE_GUARDED_BY(s_randMutex)
+    };
+    static Statics& s() {
+        static Statics s_s;
+        return s_s;
+    }
+
+private:
+    // CONSTRUCTORS - no data can live here, use only VerilatedContext
+    VerilatedContextImp() = delete;
+    ~VerilatedContextImp() = delete;
+
+public:  // But only for verilated*.cpp
+    // METHODS - extending into VerilatedContext, call via impp()->
+
+    // Random seed handling
+    vluint64_t randSeedDefault64() const VL_MT_SAFE;
+    static vluint32_t randSeedEpoch() VL_MT_SAFE { return s().s_randSeedEpoch; }
+
+    // METHODS - timeformat
+    int timeFormatUnits() VL_MT_SAFE {
+        if (m_s.m_timeFormatUnits == VerilatedContext::Serialized::UNITS_NONE)
+            return timeprecision();
+        return m_s.m_timeFormatUnits;
+    }
+    void timeFormatUnits(int value) VL_MT_SAFE { m_s.m_timeFormatUnits = value; }
+    int timeFormatPrecision() const VL_MT_SAFE { return m_s.m_timeFormatPrecision; }
+    void timeFormatPrecision(int value) VL_MT_SAFE { m_s.m_timeFormatPrecision = value; }
+    int timeFormatWidth() const VL_MT_SAFE { return m_s.m_timeFormatWidth; }
+    void timeFormatWidth(int value) VL_MT_SAFE { m_s.m_timeFormatWidth = value; }
+    std::string timeFormatSuffix() VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
+        const VerilatedLockGuard lock(m_timeDumpMutex);
+        return m_timeFormatSuffix;
+    }
+    void timeFormatSuffix(const std::string& value) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex) {
+        const VerilatedLockGuard lock(m_timeDumpMutex);
+        m_timeFormatSuffix = value;
+    }
+
+    // METHODS - arguments
+    std::string argPlusMatch(const char* prefixp) VL_MT_SAFE_EXCLUDES(m_argMutex);
+    std::pair<int, char**> argc_argv() VL_MT_SAFE_EXCLUDES(m_argMutex);
+
+public:  // But only for verilated*.cpp
+    // METHODS - scope name
+    void scopeInsert(const VerilatedScope* scopep) VL_MT_SAFE;
+    void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE;
+
+public:  // But only for verilated*.cpp
+    // METHODS - file IO
+    IData fdNewMcd(const char* filenamep) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(m_fdMutex);
+        if (m_fdFreeMct.empty()) return 0;
+        IData idx = m_fdFreeMct.back();
+        m_fdFreeMct.pop_back();
+        m_fdps[idx] = fopen(filenamep, "w");
+        if (VL_UNLIKELY(!m_fdps[idx])) return 0;
+        return (1 << idx);
+    }
+    IData fdNew(const char* filenamep, const char* modep) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        FILE* fp = fopen(filenamep, modep);
+        if (VL_UNLIKELY(!fp)) return 0;
+        // Bit 31 indicates it's a descriptor not a MCD
+        const VerilatedLockGuard lock(m_fdMutex);
+        if (m_fdFree.empty()) {
+            // Need to create more space in m_fdps and m_fdFree
+            const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, m_fdps.size());
+            const std::size_t excess = 10;
+            m_fdps.resize(start + excess);
+            std::fill(m_fdps.begin() + start, m_fdps.end(), (FILE*)0);
+            m_fdFree.resize(excess);
+            for (std::size_t i = 0, id = start; i < m_fdFree.size(); ++i, ++id) {
+                m_fdFree[i] = id;
+            }
+        }
+        IData idx = m_fdFree.back();
+        m_fdFree.pop_back();
+        m_fdps[idx] = fp;
+        return (idx | (1UL << 31));  // bit 31 indicates not MCD
+    }
+    void fdFlush(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        for (const auto& i : fdlist) fflush(i);
+    }
+    IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(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)));
+    }
+    IData fdTell(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        if (VL_UNLIKELY(fdlist.size() != 1)) return 0;
+        return static_cast<IData>(ftell(*fdlist.begin()));
+    }
+    void fdWrite(IData fdi, const std::string& output) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(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);
+        }
+    }
+    void fdClose(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(m_fdMutex);
+        if ((fdi & (1 << 31)) != 0) {
+            // Non-MCD case
+            IData idx = VL_MASK_I(31) & fdi;
+            if (VL_UNLIKELY(idx >= m_fdps.size())) return;
+            if (VL_UNLIKELY(!m_fdps[idx])) return;  // Already free
+            fclose(m_fdps[idx]);
+            m_fdps[idx] = (FILE*)0;
+            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(m_fdps[i]);
+                    m_fdps[i] = nullptr;
+                    m_fdFreeMct.push_back(i);
+                }
+            }
+        }
+    }
+    inline FILE* fdToFp(IData fdi) VL_MT_SAFE_EXCLUDES(m_fdMutex) {
+        const VerilatedLockGuard lock(m_fdMutex);
+        const VerilatedFpList fdlist = fdToFpList(fdi);
+        if (VL_UNLIKELY(fdlist.size() != 1)) return nullptr;
+        return *fdlist.begin();
+    }
+
+private:
+    VerilatedFpList fdToFpList(IData fdi) VL_REQUIRES(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 < m_fdps.size())) fp.push_back(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(m_fdps[i]);
+            }
+        }
+        return fp;
+    }
+
+protected:
+    // METHODS - protected
+    void commandArgsAddGuts(int argc, const char** argv);
+    void commandArgVl(const std::string& arg);
+    bool commandArgVlValue(const std::string& arg, const std::string& prefix, std::string& valuer);
+    void commandArgDump() const VL_MT_SAFE_EXCLUDES(m_argMutex);
+};
+
 //======================================================================
 // VerilatedImp
 
-class VerilatedImp {
+class VerilatedImpData final {
     // Whole class is internal use only - Global information shared between verilated*.cpp files.
+    // All only medium-speed, so use singleton function
 protected:
     friend class Verilated;
+    friend class VerilatedImp;
 
     // TYPES
-    typedef std::vector<std::string> ArgVec;
     typedef std::map<std::pair<const void*, void*>, void*> UserMap;
     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
-        enum { UNITS_NONE = 99 };  // Default based on precision
-        Serialized()
-            : m_timeFormatUnits(UNITS_NONE)
-            , m_timeFormatPrecision(0)
-            , m_timeFormatWidth(20) {}
-        ~Serialized() {}
-    } m_ser;
-
-    VerilatedMutex m_sergMutex;  ///< Protect m_ser
-    struct SerializedG {  // All these members serialized/deserialized and guarded
-        std::string m_timeFormatSuffix;  // $timeformat printf format
-    } m_serg VL_GUARDED_BY(m_sergMutex);
-
     // Nothing below here is save-restored; users expected to re-register appropriately
 
-    VerilatedMutex m_argMutex;  ///< Protect m_argVec, m_argVecLoaded
-    /// Argument list (NOT save-restored, may want different results)
-    ArgVec m_argVec VL_GUARDED_BY(m_argMutex);
-    bool m_argVecLoaded VL_GUARDED_BY(m_argMutex);  ///< Ever loaded argument list
-
     VerilatedMutex m_userMapMutex;  ///< Protect m_userMap
+    // For userInsert, userFind.  As indexed by pointer is common across contexts.
     UserMap m_userMap VL_GUARDED_BY(m_userMapMutex);  ///< Map of <(scope,userkey), userData>
 
-    VerilatedMutex m_nameMutex;  ///< Protect m_nameMap
-    /// Map of <scope_name, scope pointer>
-    VerilatedScopeNameMap m_nameMap VL_GUARDED_BY(m_nameMutex);
-
     VerilatedMutex m_hierMapMutex;  ///< Protect m_hierMap
-    /// Map the represents scope hierarchy
+    /// Map that represents scope hierarchy
+    // Used by hierarchyAdd, hierarchyRemove, hierarchyMap
     VerilatedHierarchyMap m_hierMap VL_GUARDED_BY(m_hierMapMutex);
 
     // Slow - somewhat static:
     VerilatedMutex m_exportMutex;  ///< Protect m_nameMap
     /// Map of <export_func_proto, func number>
+    // Used by exportInsert, exportFind, exportName.
+    // Export numbers same across all contexts as just a string-to-number conversion
     ExportNameMap m_exportMap VL_GUARDED_BY(m_exportMutex);
-    int m_exportNext VL_GUARDED_BY(m_exportMutex);  ///< Next export funcnum
+    int m_exportNext VL_GUARDED_BY(m_exportMutex) = 0;  ///< Next export funcnum
 
-    // File I/O
-    VerilatedMutex m_fdMutex;  ///< Protect m_fdps, m_fdFree
-    std::vector<FILE*> m_fdps VL_GUARDED_BY(m_fdMutex);  ///< File descriptors
-    /// List of free descriptors (SLOW - FOPEN/CLOSE only)
-    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() = default;
+};
+
+class VerilatedImp final {
+    // Whole class is internal use only - Global information shared between verilated*.cpp files.
+protected:
+    friend class Verilated;
+
+    // MEMBERS
+    static VerilatedImpData& s() {  // Singleton
+        static VerilatedImpData s_s;
+        return s_s;
+    }
 
 public:  // But only for verilated*.cpp
     // CONSTRUCTORS
-    VerilatedImp()
-        : m_argVecLoaded(false)
-        , m_exportNext(0) {
-        s_s.m_fdps.resize(31);
-        std::fill(s_s.m_fdps.begin(), s_s.m_fdps.end(), (FILE*)0);
-        s_s.m_fdFreeMct.resize(30);
-        for (std::size_t i = 0, id = 1; i < s_s.m_fdFreeMct.size(); ++i, ++id) {
-            s_s.m_fdFreeMct[i] = id;
-        }
-    }
-    ~VerilatedImp() {}
+    VerilatedImp() = default;
+    ~VerilatedImp() = default;
 
 private:
     VL_UNCOPYABLE(VerilatedImp);
 
 public:
     // METHODS - debug
-    static void internalsDump() VL_MT_SAFE;
     static void versionDump() VL_MT_SAFE;
 
-    // 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) {
-        const VerilatedLockGuard lock(s_s.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
-            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;
-            }
-        }
-        return "";
-    }
-
-private:
-    static void commandArgsAddGuts(int argc, const char** argv) VL_REQUIRES(s_s.m_argMutex);
-    static void commandArgVl(const std::string& arg);
-    static bool commandArgVlValue(const std::string& arg, const std::string& prefix,
-                                  std::string& valuer);
-
 public:
     // METHODS - user scope tracking
-    // We implement this as a single large map instead of one map per scope
+    // We implement this as a single large map instead of one map per scope.
     // There's often many more scopes than userdata's and thus having a ~48byte
     // per map overhead * N scopes would take much more space and cache thrashing.
+    // As scopep's are pointers, this implicitly handles multiple Context's
     static inline void userInsert(const void* scopep, void* userKey, void* userData) VL_MT_SAFE {
-        const 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().m_userMapMutex);
+        const auto it = s().m_userMap.find(std::make_pair(scopep, userKey));
+        if (it != s().m_userMap.end()) {
             it->second = userData;
         } else {
-            s_s.m_userMap.insert(it, std::make_pair(std::make_pair(scopep, userKey), userData));
+            s().m_userMap.emplace(std::make_pair(scopep, userKey), userData);
         }
     }
     static inline void* userFind(const void* scopep, void* userKey) VL_MT_SAFE {
-        const 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().m_userMapMutex);
+        const auto& it = vlstd::as_const(s().m_userMap).find(std::make_pair(scopep, userKey));
+        if (VL_UNLIKELY(it == s().m_userMap.end())) return nullptr;
         return it->second;
     }
 
-private:
+public:  // But only for verilated.cpp
     /// 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.
-        const 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().m_userMapMutex);
+        for (auto it = s().m_userMap.begin(); it != s().m_userMap.end();) {
             if (it->first.first == scopep) {
-                s_s.m_userMap.erase(it++);
+                s().m_userMap.erase(it++);
             } else {
                 ++it;
             }
         }
     }
     static void userDump() VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_userMapMutex);  // Avoid it changing in middle of dump
+        const VerilatedLockGuard lock(s().m_userMapMutex);  // Avoid it changing in middle of dump
         bool first = true;
-        for (UserMap::const_iterator it = s_s.m_userMap.begin(); it != s_s.m_userMap.end(); ++it) {
+        for (const auto& i : s().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);
         }
     }
 
-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
-        const 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));
-        }
-    }
-    static inline const VerilatedScope* scopeFind(const char* namep) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_nameMutex);
-        // If too slow, can assume this is only VL_MT_SAFE_POSINIT
-        VerilatedScopeNameMap::const_iterator it = s_s.m_nameMap.find(namep);
-        if (VL_UNLIKELY(it == s_s.m_nameMap.end())) return NULL;
-        return it->second;
-    }
-    static void scopeErase(const VerilatedScope* scopep) VL_MT_SAFE {
-        // Slow ok - called once/scope at destruction
-        const VerilatedLockGuard lock(s_s.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);
-    }
-    static void scopesDump() VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.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;
-            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;
-    }
-
 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
-        const VerilatedLockGuard lock(s_s.m_hierMapMutex);
-        s_s.m_hierMap[fromp].push_back(top);
+        const VerilatedLockGuard lock(s().m_hierMapMutex);
+        s().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().m_hierMapMutex);
+        VerilatedHierarchyMap& map = s().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().m_hierMap;
     }
 
 public:  // But only for verilated*.cpp
@@ -411,19 +529,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
-        const 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().m_exportMutex);
+        const auto it = s().m_exportMap.find(namep);
+        if (it == s().m_exportMap.end()) {
+            s().m_exportMap.emplace(namep, s().m_exportNext++);
+            return s().m_exportNext++;
         } else {
             return it->second;
         }
     }
     static int exportFind(const char* namep) VL_MT_SAFE {
-        const 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().m_exportMutex);
+        const auto& it = s().m_exportMap.find(namep);
+        if (VL_LIKELY(it != s().m_exportMap.end())) return it->second;
         std::string msg = (std::string("%Error: Testbench C called ") + namep
                            + " but no such DPI export function name exists in ANY model");
         VL_FATAL_MT("unknown", 0, "", msg.c_str());
@@ -431,154 +549,25 @@ 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
-        const 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().m_exportMutex);
+        for (const auto& i : s().m_exportMap) {
+            if (i.second == funcnum) return i.first;
         }
         return "*UNKNOWN*";
     }
     static void exportsDump() VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_exportMutex);
+        const VerilatedLockGuard lock(s().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().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
     // what other models are using the assigned funcnum's.
-
-public:  // But only for verilated*.cpp
-    // METHODS - timeformat
-    static std::string timeFormatSuffix() VL_MT_SAFE;
-    static void timeFormatSuffix(const std::string& value) VL_MT_SAFE;
-    static int timeFormatUnits() VL_MT_SAFE {
-        if (s_s.m_ser.m_timeFormatUnits == Serialized::UNITS_NONE) {
-            return Verilated::timeprecision();
-        }
-        return s_s.m_ser.m_timeFormatUnits;
-    }
-    static int timeFormatPrecision() VL_MT_SAFE { return s_s.m_ser.m_timeFormatPrecision; }
-    static int timeFormatWidth() VL_MT_SAFE { return s_s.m_ser.m_timeFormatWidth; }
-    static void timeFormatUnits(int value) VL_MT_SAFE;
-    static void timeFormatPrecision(int value) VL_MT_SAFE;
-    static void timeFormatWidth(int value) VL_MT_SAFE;
-
-public:  // But only for verilated*.cpp
-    // METHODS - file IO
-    static IData fdNewMcd(const char* filenamep) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_fdMutex);
-        if (s_s.m_fdFreeMct.empty()) return 0;
-        IData idx = s_s.m_fdFreeMct.back();
-        s_s.m_fdFreeMct.pop_back();
-        s_s.m_fdps[idx] = fopen(filenamep, "w");
-        if (VL_UNLIKELY(!s_s.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
-        const VerilatedLockGuard lock(s_s.m_fdMutex);
-        if (s_s.m_fdFree.empty()) {
-            // Need to create more space in m_fdps and m_fdFree
-            const std::size_t start = std::max<std::size_t>(31UL + 1UL + 3UL, s_s.m_fdps.size());
-            const std::size_t excess = 10;
-            s_s.m_fdps.resize(start + excess);
-            std::fill(s_s.m_fdps.begin() + start, s_s.m_fdps.end(), (FILE*)0);
-            s_s.m_fdFree.resize(excess);
-            for (std::size_t i = 0, id = start; i < s_s.m_fdFree.size(); ++i, ++id) {
-                s_s.m_fdFree[i] = id;
-            }
-        }
-        IData idx = s_s.m_fdFree.back();
-        s_s.m_fdFree.pop_back();
-        s_s.m_fdps[idx] = fp;
-        return (idx | (1UL << 31));  // bit 31 indicates not MCD
-    }
-    static void fdFlush(IData fdi) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_fdMutex);
-        const VerilatedFpList fdlist = fdToFpList(fdi);
-        for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) {
-            fflush(*it);
-        }
-    }
-    static IData fdSeek(IData fdi, IData offset, IData origin) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.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.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.m_fdMutex);
-        const VerilatedFpList fdlist = fdToFpList(fdi);
-        for (VerilatedFpList::const_iterator it = fdlist.begin(); it != fdlist.end(); ++it) {
-            if (VL_UNLIKELY(!*it)) continue;
-            fwrite(output.c_str(), 1, output.size(), *it);
-        }
-    }
-    static void fdClose(IData fdi) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_fdMutex);
-        if ((fdi & (1 << 31)) != 0) {
-            // Non-MCD case
-            IData idx = VL_MASK_I(31) & fdi;
-            if (VL_UNLIKELY(idx >= s_s.m_fdps.size())) return;
-            if (VL_UNLIKELY(!s_s.m_fdps[idx])) return;  // Already free
-            fclose(s_s.m_fdps[idx]);
-            s_s.m_fdps[idx] = (FILE*)0;
-            s_s.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.m_fdps[i]);
-                    s_s.m_fdps[i] = NULL;
-                    s_s.m_fdFreeMct.push_back(i);
-                }
-            }
-        }
-    }
-    static inline FILE* fdToFp(IData fdi) VL_MT_SAFE {
-        const VerilatedLockGuard lock(s_s.m_fdMutex);
-        const VerilatedFpList fdlist = fdToFpList(fdi);
-        if (VL_UNLIKELY(fdlist.size() != 1)) return NULL;
-        return *fdlist.begin();
-    }
-
-private:
-    static inline VerilatedFpList fdToFpList(IData fdi) VL_REQUIRES(s_s.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.m_fdps.size())) fp.push_back(s_s.m_fdps[idx]);
-                break;
-            }
-        } else {
-            // MCD Case
-            for (int i = 0; (fdi != 0) && (i < fp.capacity()); ++i, fdi >>= 1) {
-                if (fdi & VL_MASK_I(1)) fp.push_back(s_s.m_fdps[i]);
-            }
-        }
-        return fp;
-    }
 };
 
 //======================================================================

include/verilated_intrinsics.h

@@ -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.
@@ -19,13 +19,13 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_INTRINSICS_H_
-#define _VERILATED_INTRINSICS_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_INTRINSICS_H_
+#define VERILATOR_VERILATED_INTRINSICS_H_  ///< Header Guard
 
 // 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>

include/verilated_save.cpp

@@ -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.
@@ -16,9 +16,12 @@
 ///
 //=============================================================================
 
+#define VERILATOR_VERILATED_SAVE_CPP_
+
 #include "verilatedos.h"
 #include "verilated.h"
 #include "verilated_save.h"
+#include "verilated_imp.h"
 
 #include <cerrno>
 #include <fcntl.h>
@@ -42,9 +45,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 = "verilatorsave02\n";
+/// Value of last bytes of each file (must be multiple of 8 bytes)
+static const char* const VLTSAVE_TRAILER_STR = "vltsaved";
 
 //=============================================================================
 //=============================================================================
@@ -64,10 +68,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
 }
@@ -76,11 +80,6 @@ void VerilatedSerialize::header() VL_MT_UNSAFE_ONE {
     VerilatedSerialize& os = *this;  // So can cut and paste standard << code below
     assert((strlen(VLTSAVE_HEADER_STR) & 7) == 0);  // Keep aligned
     os.write(VLTSAVE_HEADER_STR, strlen(VLTSAVE_HEADER_STR));
-
-    // Verilated doesn't do it itself, as if we're not using save/restore
-    // it doesn't need to compile this stuff in
-    os.write(Verilated::serialized1Ptr(), Verilated::serialized1Size());
-    os.write(Verilated::serialized2Ptr(), Verilated::serialized2Size());
 }
 
 void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
@@ -88,12 +87,12 @@ 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());
 }
 
 void VerilatedSerialize::trailer() VL_MT_UNSAFE_ONE {
@@ -109,7 +108,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
     }
 }
 
@@ -246,3 +245,19 @@ void VerilatedRestore::fill() VL_MT_UNSAFE_ONE {
 
 //=============================================================================
 // Serialization of types
+
+VerilatedSerialize& operator<<(VerilatedSerialize& os, VerilatedContext* rhsp) {
+    os.write(rhsp->serialized1Ptr(), rhsp->serialized1Size());
+    os << rhsp->impp()->timeFormatSuffix();
+    os << rhsp->dumpfile();
+    return os;
+}
+VerilatedDeserialize& operator>>(VerilatedDeserialize& os, VerilatedContext* rhsp) {
+    os.read(rhsp->serialized1Ptr(), rhsp->serialized1Size());
+    std::string s;
+    os >> s;
+    rhsp->impp()->timeFormatSuffix(s);
+    os >> s;
+    rhsp->dumpfile(s);
+    return os;
+}

include/verilated_save.h

@@ -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.
@@ -16,8 +16,8 @@
 ///
 //=============================================================================
 
-#ifndef _VERILATED_SAVE_C_H_
-#define _VERILATED_SAVE_C_H_ 1
+#ifndef VERILATOR_VERILATED_SAVE_C_H_
+#define VERILATOR_VERILATED_SAVE_C_H_
 
 #include "verilatedos.h"
 #include "verilated_heavy.h"
@@ -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,20 +49,19 @@ 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; }
     std::string filename() const { return m_filename; }
     virtual void close() VL_MT_UNSAFE_ONE { flush(); }
     virtual void flush() VL_MT_UNSAFE_ONE {}
-    inline VerilatedSerialize& write(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+    VerilatedSerialize& write(const void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
         const vluint8_t* __restrict dp = (const vluint8_t* __restrict)datap;
         while (size) {
             bufferCheck();
@@ -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,21 +110,19 @@ 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; }
     std::string filename() const { return m_filename; }
     virtual void close() VL_MT_UNSAFE_ONE { flush(); }
     virtual void flush() VL_MT_UNSAFE_ONE {}
-    inline VerilatedDeserialize& read(void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
+    VerilatedDeserialize& read(void* __restrict datap, size_t size) VL_MT_UNSAFE_ONE {
         vluint8_t* __restrict dp = static_cast<vluint8_t* __restrict>(datap);
         while (size) {
             bufferCheck();
@@ -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;
 };
 
 //=============================================================================
@@ -241,7 +236,7 @@ inline VerilatedSerialize& operator<<(VerilatedSerialize& os, float& rhs) {
 inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, float& rhs) {
     return os.read(&rhs, sizeof(rhs));
 }
-inline VerilatedSerialize& operator<<(VerilatedSerialize& os, std::string& rhs) {
+inline VerilatedSerialize& operator<<(VerilatedSerialize& os, const std::string& rhs) {
     vluint32_t len = rhs.length();
     os << len;
     return os.write(rhs.data(), len);
@@ -252,15 +247,17 @@ inline VerilatedDeserialize& operator>>(VerilatedDeserialize& os, std::string& r
     rhs.resize(len);
     return os.read((void*)rhs.data(), len);
 }
+VerilatedSerialize& operator<<(VerilatedSerialize& os, VerilatedContext* rhsp);
+VerilatedDeserialize& operator>>(VerilatedDeserialize& os, VerilatedContext* rhsp);
+
 template <class T_Key, class T_Value>
 VerilatedSerialize& operator<<(VerilatedSerialize& os, VlAssocArray<T_Key, T_Value>& rhs) {
     os << rhs.atDefault();
     vluint32_t len = rhs.size();
     os << len;
-    for (typename VlAssocArray<T_Key, T_Value>::const_iterator it = rhs.begin(); it != rhs.end();
-         ++it) {
-        T_Key index = it->first;  // Copy to get around const_iterator
-        T_Value value = it->second;
+    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;

include/verilated_sc.h

@@ -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.
@@ -19,8 +19,8 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_SC_H_
-#define _VERILATED_SC_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_SC_H_
+#define VERILATOR_VERILATED_SC_H_  ///< Header Guard
 
 #include "verilatedos.h"
 
@@ -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();

include/verilated_sym_props.h

@@ -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 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_SYM_PROPS_H_
-#define _VERILATED_SYM_PROPS_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_SYM_PROPS_H_
+#define VERILATOR_VERILATED_SYM_PROPS_H_  ///< Header Guard
 
 #include "verilatedos.h"
 
@@ -36,26 +36,24 @@
 /// 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; }
@@ -70,75 +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 };
+    static constexpr vluint32_t MAGIC = 0xddc4f829UL;
     // 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
     std::vector<VerilatedRange> m_unpacked;  // Unpacked array ranges
     void initUnpacked(const int* ulims) {
         for (int i = 0; i < m_udims; ++i) {
-            const int left = ulims ? ulims[2 * i + 0] : 0;
-            const int right = ulims ? ulims[2 * i + 1] : 0;
-            m_unpacked.push_back(VerilatedRange(left, right));
+            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) {
-        initUnpacked(NULL);
+        : 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) {}
+        : 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))
-        , m_pdims(0)
-        , m_udims(udims) {
+        : 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 udims, const int* ulims)
-        : m_magic(MAGIC)
-        , m_vltype(vltype)
-        , m_vlflags(VerilatedVarFlags(vlflags))
-        , m_pdims(1)
-        , m_udims(udims)
-        , 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{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,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
@@ -227,7 +225,7 @@ 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
@@ -237,13 +235,13 @@ protected:
     // CONSTRUCTORS
     VerilatedVar(const char* namep, void* datap, VerilatedVarType vltype,
                  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) {}
+        : 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

include/verilated_syms.h

@@ -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.
@@ -23,14 +23,15 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATED_SYMS_H_
-#define _VERILATED_SYMS_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_SYMS_H_
+#define VERILATOR_VERILATED_SYMS_H_  ///< Header Guard
 
 #include "verilatedos.h"
 #include "verilated_heavy.h"
 #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

include/verilated_threads.cpp

@@ -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.
@@ -19,30 +19,33 @@
 
 #include <cstdio>
 
+//=============================================================================
+// Globals
+
+// Internal note: Globals may multi-construct, see verilated.cpp top.
+
 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));
 }
 
 //=============================================================================
 // 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) {}
+VlWorkerThread::VlWorkerThread(VlThreadPool* poolp, VerilatedContext* contextp, bool profiling)
+    : 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}
+    , m_contextp{contextp} {}
 
 VlWorkerThread::~VlWorkerThread() {
     m_exiting.store(true, std::memory_order_release);
@@ -55,7 +58,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,20 +68,23 @@ 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;
         }
     }
 
     if (VL_UNLIKELY(m_profiling)) m_poolp->tearDownProfilingClientThread();
 }
 
-void VlWorkerThread::startWorker(VlWorkerThread* workerp) { workerp->workerLoop(); }
+void VlWorkerThread::startWorker(VlWorkerThread* workerp) {
+    Verilated::threadContextp(workerp->m_contextp);
+    workerp->workerLoop();
+}
 
 //=============================================================================
 // VlThreadPool
 
-VlThreadPool::VlThreadPool(int nThreads, bool profiling)
-    : m_profiling(profiling) {
+VlThreadPool::VlThreadPool(VerilatedContext* contextp, int nThreads, bool profiling)
+    : m_profiling{profiling} {
     // --threads N passes nThreads=N-1, as the "main" threads counts as 1
     unsigned cpus = std::thread::hardware_concurrency();
     if (cpus < nThreads + 1) {
@@ -91,7 +97,7 @@ VlThreadPool::VlThreadPool(int nThreads, bool profiling)
     }
     // Create'em
     for (int i = 0; i < nThreads; ++i) {
-        m_workers.push_back(new VlWorkerThread(this, profiling));
+        m_workers.push_back(new VlWorkerThread(this, contextp, profiling));
     }
     // Set up a profile buffer for the current thread too -- on the
     // assumption that it's the same thread that calls eval and may be
@@ -100,20 +106,18 @@ 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() {
+void VlThreadPool::setupProfilingClientThread() VL_MT_SAFE_EXCLUDES(m_mutex) {
     assert(!t_profilep);
     t_profilep = new ProfileTrace;
     // Reserve some space in the thread-local profiling buffer;
@@ -125,15 +129,16 @@ void VlThreadPool::setupProfilingClientThread() {
     }
 }
 
-void VlThreadPool::profileAppendAll(const VlProfileRec& rec) {
+void VlThreadPool::profileAppendAll(const VlProfileRec& rec) VL_MT_SAFE_EXCLUDES(m_mutex) {
     const VerilatedLockGuard lk(m_mutex);
-    for (ProfileSet::iterator it = m_allProfiles.begin(); it != m_allProfiles.end(); ++it) {
+    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) {
+void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed)
+    VL_MT_SAFE_EXCLUDES(m_mutex) {
     const VerilatedLockGuard lk(m_mutex);
     VL_DEBUG_IF(VL_DBG_MSGF("+prof+threads writing to '%s'\n", filenamep););
 
@@ -141,7 +146,7 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
     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
@@ -149,18 +154,18 @@ void VlThreadPool::profileDump(const char* filenamep, vluint64_t ticksElapsed) {
     fprintf(fp, "VLPROFTHREAD 1.0 # Verilator thread profile dump version 1.0\n");
     fprintf(fp, "VLPROF arg --threads %" VL_PRI64 "u\n", vluint64_t(m_workers.size() + 1));
     fprintf(fp, "VLPROF arg +verilator+prof+threads+start+%" VL_PRI64 "u\n",
-            Verilated::profThreadsStart());
-    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n", Verilated::profThreadsWindow());
+            Verilated::threadContextp()->profThreadsStart());
+    fprintf(fp, "VLPROF arg +verilator+prof+threads+window+%u\n",
+            Verilated::threadContextp()->profThreadsWindow());
     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 +175,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
             }

include/verilated_threads.h

@@ -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.
@@ -16,12 +16,21 @@
 ///
 //=============================================================================
 
-#ifndef _VERILATED_THREADS_H_
-#define _VERILATED_THREADS_H_
+#ifndef VERILATOR_VERILATED_THREADS_H_
+#define VERILATOR_VERILATED_THREADS_H_
 
 #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,20 +176,20 @@ 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
     VerilatedMutex m_mutex;
     std::condition_variable_any m_cv;
     // Only notify the condition_variable if the worker is waiting
-    bool m_waiting VL_GUARDED_BY(m_mutex);
+    bool m_waiting VL_GUARDED_BY(m_mutex) = false;
 
     // Why a vector? We expect the pending list to be very short, typically
     // 0 or 1 or 2, so popping from the front shouldn't be
@@ -201,16 +203,17 @@ private:
     bool m_profiling;  // Is profiling enabled?
     std::atomic<bool> m_exiting;  // Worker thread should exit
     std::thread m_cthread;  // Underlying C++ thread record
+    VerilatedContext* m_contextp;  // Context for spawned thread
 
     VL_UNCOPYABLE(VlWorkerThread);
 
 public:
     // CONSTRUCTORS
-    explicit VlWorkerThread(VlThreadPool* poolp, bool profiling);
+    explicit VlWorkerThread(VlThreadPool* poolp, VerilatedContext* contextp, bool profiling);
     ~VlWorkerThread();
 
     // METHODS
-    inline void dequeWork(ExecRec* workp) {
+    inline void dequeWork(ExecRec* workp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         // Spin for a while, waiting for new data
         for (int i = 0; i < VL_LOCK_SPINS; ++i) {
             if (VL_LIKELY(m_ready_size.load(std::memory_order_relaxed))) {  //
@@ -231,7 +234,8 @@ public:
         m_ready_size.fetch_sub(1, std::memory_order_relaxed);
     }
     inline void wakeUp() { addTask(nullptr, false, nullptr); }
-    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym) {
+    inline void addTask(VlExecFnp fnp, bool evenCycle, VlThrSymTab sym)
+        VL_MT_SAFE_EXCLUDES(m_mutex) {
         bool notify;
         {
             const VerilatedLockGuard lk(m_mutex);
@@ -245,7 +249,7 @@ public:
     static void startWorker(VlWorkerThread* workerp);
 };
 
-class VlThreadPool {
+class VlThreadPool final {
     // TYPES
     typedef std::vector<VlProfileRec> ProfileTrace;
     typedef std::set<ProfileTrace*> ProfileSet;
@@ -260,6 +264,7 @@ class VlThreadPool {
     // corrupting the profiling data. It's super cheap to append
     // a VlProfileRec struct on the end of a pre-allocated vector;
     // this is the only cost we pay in real-time during a profiling cycle.
+    // Internal note: Globals may multi-construct, see verilated.cpp top.
     static VL_THREAD_LOCAL ProfileTrace* t_profilep;
     ProfileSet m_allProfiles VL_GUARDED_BY(m_mutex);
     VerilatedMutex m_mutex;
@@ -269,7 +274,7 @@ public:
     // Construct a thread pool with 'nThreads' dedicated threads. The thread
     // pool will create these threads and make them available to execute tasks
     // via this->workerp(index)->addTask(...)
-    VlThreadPool(int nThreads, bool profiling);
+    VlThreadPool(VerilatedContext* contextp, int nThreads, bool profiling);
     ~VlThreadPool();
 
     // METHODS
@@ -283,11 +288,11 @@ public:
         t_profilep->emplace_back();
         return &(t_profilep->back());
     }
-    void profileAppendAll(const VlProfileRec& rec);
-    void profileDump(const char* filenamep, vluint64_t ticksElapsed);
+    void profileAppendAll(const VlProfileRec& rec) VL_MT_SAFE_EXCLUDES(m_mutex);
+    void profileDump(const char* filenamep, vluint64_t ticksElapsed) VL_MT_SAFE_EXCLUDES(m_mutex);
     // In profiling mode, each executing thread must call
     // this once to setup profiling state:
-    void setupProfilingClientThread();
+    void setupProfilingClientThread() VL_MT_SAFE_EXCLUDES(m_mutex);
     void tearDownProfilingClientThread();
 
 private:

include/verilated_trace.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.
@@ -12,13 +12,12 @@
 //=============================================================================
 ///
 /// \file
-/// \brief Tracing functionality common to all formats
+/// \brief Internal tracing functionality common to all formats
 ///
 //=============================================================================
-// SPDIFF_OFF
 
-#ifndef _VERILATED_TRACE_H_
-#define _VERILATED_TRACE_H_ 1
+#ifndef VERILATOR_VERILATED_TRACE_H_
+#define VERILATOR_VERILATED_TRACE_H_
 
 // clang-format off
 
@@ -40,7 +39,7 @@
 // Threaded tracing
 
 // A simple synchronized first in first out queue
-template <class T> class VerilatedThreadQueue {  // LCOV_EXCL_LINE  // lcov bug
+template <class T> class VerilatedThreadQueue final {  // LCOV_EXCL_LINE  // lcov bug
 private:
     VerilatedMutex m_mutex;  // Protects m_queue
     std::condition_variable_any m_cv;
@@ -48,21 +47,21 @@ private:
 
 public:
     // Put an element at the back of the queue
-    void put(T value) {
+    void put(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
         VerilatedLockGuard lock(m_mutex);
         m_queue.push_back(value);
         m_cv.notify_one();
     }
 
     // Put an element at the front of the queue
-    void put_front(T value) {
+    void put_front(T value) VL_MT_SAFE_EXCLUDES(m_mutex) {
         VerilatedLockGuard lock(m_mutex);
         m_queue.push_front(value);
         m_cv.notify_one();
     }
 
     // Get an element from the front of the queue. Blocks if none available
-    T get() {
+    T get() VL_MT_SAFE_EXCLUDES(m_mutex) {
         VerilatedLockGuard lock(m_mutex);
         m_cv.wait(lock, [this]() VL_REQUIRES(m_mutex) { return !m_queue.empty(); });
         assert(!m_queue.empty());
@@ -72,9 +71,9 @@ public:
     }
 
     // Non blocking get
-    bool tryGet(T& result) {
+    bool tryGet(T& result) VL_MT_SAFE_EXCLUDES(m_mutex) {
         const VerilatedLockGuard lockGuard(m_mutex);
-        if (m_queue.empty()) { return false; }
+        if (m_queue.empty()) return false;
         result = m_queue.front();
         m_queue.pop_front();
         return true;
@@ -83,11 +82,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,
@@ -110,7 +109,7 @@ public:
 // 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 {
+template <class T_Derived> class VerilatedTrace VL_NOT_FINAL {
 public:
     //=========================================================================
     // Generic tracing internals
@@ -130,11 +129,11 @@ private:
         };
         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) {}
+            : m_initCb{cb}
+            , m_userp{userp} {}
         CallbackRecord(dumpCb_t cb, void* userp)
-            : m_dumpCb(cb)
-            , m_userp(userp) {}
+            : m_dumpCb{cb}
+            , m_userp{userp} {}
     };
 
     vluint32_t* m_sigs_oldvalp;  ///< Old value store
@@ -152,7 +151,8 @@ 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);
+    void addCallbackRecord(std::vector<CallbackRecord>& cbVec, CallbackRecord& cbRec)
+        VL_MT_SAFE_EXCLUDES(m_mutex);
 
     // Equivalent to 'this' but is of the sub-type 'T_Derived*'. Use 'self()->'
     // to access duck-typed functions to avoid a virtual function call.
@@ -204,7 +204,7 @@ protected:
     //=========================================================================
     // Internals available to format specific implementations
 
-    VerilatedAssertOneThread m_assertOne;  ///< Assert only called from single thread
+    VerilatedMutex m_mutex;  // Ensure dump() etc only called from single thread
 
     vluint32_t nextCode() const { return m_nextCode; }
     vluint32_t numSignals() const { return m_numSignals; }
@@ -216,19 +216,18 @@ 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; }
-    /// Character that splits scopes.  Note whitespace are ALWAYS escapes.
+    // Is this an escape?
+    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; }
 
-    void close();
-    void flush();
+    void closeBase();
+    void flushBase();
 
     //=========================================================================
     // Virtual functions to be provided by the format specific implementation
@@ -249,30 +248,24 @@ public:
     ~VerilatedTrace();
 
     // Set time units (s/ms, defaults to ns)
-    void set_time_unit(const char* unitp);
-    void set_time_unit(const std::string& unit);
+    void set_time_unit(const char* unitp) VL_MT_SAFE;
+    void set_time_unit(const std::string& unit) VL_MT_SAFE;
     // Set time resolution (s/ms, defaults to ns)
-    void set_time_resolution(const char* unitp);
-    void set_time_resolution(const std::string& unit);
+    void set_time_resolution(const char* unitp) VL_MT_SAFE;
+    void set_time_resolution(const std::string& unit) VL_MT_SAFE;
 
     // Call
-    void dump(vluint64_t timeui);
+    void dump(vluint64_t timeui) VL_MT_SAFE_EXCLUDES(m_mutex);
 
     //=========================================================================
     // Non-hot path internal interface to Verilator generated 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 module(const std::string& name) VL_MT_UNSAFE_ONE {
-        m_assertOne.check();
-        m_moduleName = name;
-    }
+    void addInitCb(initCb_t cb, void* userp) VL_MT_SAFE;
+    void addFullCb(dumpCb_t cb, void* userp) VL_MT_SAFE;
+    void addChgCb(dumpCb_t cb, void* userp) VL_MT_SAFE;
+    void addCleanupCb(dumpCb_t cb, void* userp) VL_MT_SAFE;
 
+    void module(const std::string& name) VL_MT_UNSAFE;
     void scopeEscape(char flag) { m_scopeEscape = flag; }
 
     //=========================================================================

include/verilated_trace_imp.cpp

@@ -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.
@@ -15,10 +15,10 @@
 /// \brief Implementation of tracing functionality common to all trace formats
 ///
 //=============================================================================
-// SPDIFF_OFF
 
 // clang-format off
 
+#ifndef VL_CPPCHECK
 #ifndef VL_DERIVED_T
 # error "This file should be included in trace format implementations"
 #endif
@@ -39,14 +39,14 @@
 // Static utility functions
 
 static double timescaleToDouble(const char* unitp) {
-    char* endp = NULL;
+    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,7 +69,7 @@ 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);
+    VL_SNPRINTF(valuestr, 100, "%0.0f%s", value, suffixp);
     return valuestr;  // Gets converted to string, so no ref to stack
 }
 
@@ -236,7 +236,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::shutdownWorker() {
 //=============================================================================
 // Life cycle
 
-template <> void VerilatedTrace<VL_DERIVED_T>::close() {
+template <> void VerilatedTrace<VL_DERIVED_T>::closeBase() {
 #ifdef VL_TRACE_THREADED
     shutdownWorker();
     while (m_numTraceBuffers) {
@@ -246,7 +246,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::close() {
 #endif
 }
 
-template <> void VerilatedTrace<VL_DERIVED_T>::flush() {
+template <> void VerilatedTrace<VL_DERIVED_T>::flushBase() {
 #ifdef VL_TRACE_THREADED
     // Hand an empty buffer to the worker thread
     vluint32_t* const bufferp = getTraceBuffer();
@@ -262,12 +262,12 @@ template <> void VerilatedTrace<VL_DERIVED_T>::flush() {
 // Callbacks to run on global events
 
 template <> void VerilatedTrace<VL_DERIVED_T>::onFlush(void* selfp) {
-    // Note this calls 'flush' on the derived class
+    // This calls 'flush' on the derived classo (which must then get any mutex)
     reinterpret_cast<VL_DERIVED_T*>(selfp)->flush();
 }
 
 template <> void VerilatedTrace<VL_DERIVED_T>::onExit(void* selfp) {
-    // Note this calls 'close' on the derived class
+    // This calls 'close' on the derived class (which must then get any mutex)
     reinterpret_cast<VL_DERIVED_T*>(selfp)->close();
 }
 
@@ -276,29 +276,31 @@ template <> void VerilatedTrace<VL_DERIVED_T>::onExit(void* selfp) {
 
 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());
-    set_time_resolution(Verilated::timeprecisionString());
+    set_time_unit(Verilated::threadContextp()->timeunitString());
+    set_time_resolution(Verilated::threadContextp()->timeprecisionString());
 }
 
 template <> VerilatedTrace<VL_DERIVED_T>::~VerilatedTrace() {
-    if (m_sigs_oldvalp) VL_DO_CLEAR(delete[] m_sigs_oldvalp, m_sigs_oldvalp = NULL);
+    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();
+    closeBase();
 #endif
 }
 
@@ -306,8 +308,6 @@ template <> VerilatedTrace<VL_DERIVED_T>::~VerilatedTrace() {
 // Internals available to format specific implementations
 
 template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
-    m_assertOne.check();
-
     // Note: It is possible to re-open a trace file (VCD in particular),
     // so we must reset the next code here, but it must have the same number
     // of codes on re-open
@@ -352,7 +352,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::traceInit() VL_MT_UNSAFE {
 
 template <>
 void VerilatedTrace<VL_DERIVED_T>::declCode(vluint32_t code, vluint32_t bits, bool tri) {
-    if (!code) {
+    if (VL_UNCOVERABLE(!code)) {
         VL_FATAL_MT(__FILE__, __LINE__, "", "Internal: internal trace problem, code 0 is illegal");
     }
     // Note: The tri-state flag is not used by Verilator, but is here for
@@ -371,31 +371,29 @@ template <> std::string VerilatedTrace<VL_DERIVED_T>::timeResStr() const {
     return doubleToTimescale(m_timeRes);
 }
 
-template <> std::string VerilatedTrace<VL_DERIVED_T>::timeUnitStr() const {
-    return doubleToTimescale(m_timeUnit);
-}
-
 //=========================================================================
 // External interface to client code
 
-template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const char* unitp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const char* unitp) VL_MT_SAFE {
     m_timeUnit = timescaleToDouble(unitp);
 }
-
-template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const std::string& unit) {
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_unit(const std::string& unit) VL_MT_SAFE {
     set_time_unit(unit.c_str());
 }
-
-template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const char* unitp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const char* unitp) VL_MT_SAFE {
     m_timeRes = timescaleToDouble(unitp);
 }
-
-template <> void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const std::string& unit) {
+template <>
+void VerilatedTrace<VL_DERIVED_T>::set_time_resolution(const std::string& unit) VL_MT_SAFE {
     set_time_resolution(unit.c_str());
 }
 
-template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
-    m_assertOne.check();
+template <>
+void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) VL_MT_SAFE_EXCLUDES(m_mutex) {
+    // Not really VL_MT_SAFE but more VL_MT_UNSAFE_ONE.
+    // This does get the mutex, but if multiple threads are trying to dump
+    // chances are the data being dumped will have other problems
+    const VerilatedLockGuard lock(m_mutex);
     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",
@@ -428,7 +426,7 @@ template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
         m_traceBufferWritep += 3;
     } else {
         // Update time point
-        flush();
+        flushBase();
         emitTimeChange(timeui);
     }
 #else
@@ -474,8 +472,9 @@ template <> void VerilatedTrace<VL_DERIVED_T>::dump(vluint64_t timeui) {
 
 template <>
 void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>& cbVec,
-                                                     CallbackRecord& cbRec) {
-    m_assertOne.check();
+                                                     CallbackRecord& cbRec)
+    VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
     if (VL_UNCOVERABLE(timeLastDump() != 0)) {  // LCOV_EXCL_START
         std::string msg = (std::string("Internal: ") + __FILE__ + "::" + __FUNCTION__
                            + " called with already open file");
@@ -484,22 +483,26 @@ void VerilatedTrace<VL_DERIVED_T>::addCallbackRecord(std::vector<CallbackRecord>
     cbVec.push_back(cbRec);
 }
 
-template <> void VerilatedTrace<VL_DERIVED_T>::addInitCb(initCb_t cb, void* userp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::addInitCb(initCb_t cb, void* userp) VL_MT_SAFE {
     CallbackRecord cbr(cb, userp);
     addCallbackRecord(m_initCbs, cbr);
 }
-template <> void VerilatedTrace<VL_DERIVED_T>::addFullCb(dumpCb_t cb, void* userp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::addFullCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
     CallbackRecord cbr(cb, userp);
     addCallbackRecord(m_fullCbs, cbr);
 }
-template <> void VerilatedTrace<VL_DERIVED_T>::addChgCb(dumpCb_t cb, void* userp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::addChgCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
     CallbackRecord cbr(cb, userp);
     addCallbackRecord(m_chgCbs, cbr);
 }
-template <> void VerilatedTrace<VL_DERIVED_T>::addCleanupCb(dumpCb_t cb, void* userp) {
+template <> void VerilatedTrace<VL_DERIVED_T>::addCleanupCb(dumpCb_t cb, void* userp) VL_MT_SAFE {
     CallbackRecord cbr(cb, userp);
     addCallbackRecord(m_cleanupCbs, cbr);
 }
+template <> void VerilatedTrace<VL_DERIVED_T>::module(const std::string& name) VL_MT_UNSAFE {
+    // Called via callbacks way above in call stack, which already hold m_mutex
+    m_moduleName = name;
+}
 
 //=========================================================================
 // Hot path internal interface to Verilator generated code
@@ -556,7 +559,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);
@@ -578,7 +581,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
@@ -614,7 +617,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
@@ -633,9 +636,48 @@ 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("100s");
+    SELF_CHECK_TS("10s");
+    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

include/verilated_unordered_set_map.h

@@ -1,501 +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 _VERILATED_UNORDERED_SET_MAP_H_
-#define _VERILATED_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<int>::operator()(const int& k) const { return k; }
-
-template <> inline bool vl_equal_to<int>::operator()(const int& a, const int& b) const {
-    return a == b;
-}
-
-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(0xFFFFFFFFFFFFFFFFULL, 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) ? 11400714819323198485ULL : 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 (1ULL << 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 = 1ULL << 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

include/verilated_vcd_c.cpp

@@ -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.
@@ -15,7 +15,6 @@
 /// \brief C++ Tracing in VCD Format
 ///
 //=============================================================================
-// SPDIFF_OFF
 
 // clang-format off
 
@@ -34,8 +33,6 @@
 # include <unistd.h>
 #endif
 
-// SPDIFF_ON
-
 #ifndef O_LARGEFILE  // For example on WIN32
 # define O_LARGEFILE 0
 #endif
@@ -51,13 +48,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
@@ -88,31 +86,25 @@ 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) {
-    m_assertOne.check();
+void VerilatedVcd::open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
     if (isOpen()) return;
 
     // Set member variables
     m_filename = filename;  // "" is ok, as someone may overload open
 
-    openNext(m_rolloverMB != 0);
+    openNextImp(m_rolloverMB != 0);
     if (!isOpen()) return;
 
     dumpHeader();
@@ -121,13 +113,17 @@ void VerilatedVcd::open(const char* filename) {
     m_suffixesp = &m_suffixes[0];  // Note: C++11 m_suffixes.data();
 
     // When using rollover, the first chunk contains the header only.
-    if (m_rolloverMB) openNext(true);
+    if (m_rolloverMB) openNextImp(true);
 }
 
-void VerilatedVcd::openNext(bool incFilename) {
+void VerilatedVcd::openNext(bool incFilename) VL_MT_SAFE_EXCLUDES(m_mutex) {
     // Open next filename in concat sequence, mangle filename if
     // incFilename is true.
-    m_assertOne.check();
+    const VerilatedLockGuard lock(m_mutex);
+    openNextImp(incFilename);
+}
+
+void VerilatedVcd::openNextImp(bool incFilename) {
     closePrev();  // Close existing
     if (incFilename) {
         // Find _0000.{ext} in filename
@@ -143,7 +139,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';
+                        }
                     }
                 }
             }
@@ -169,7 +167,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)) openNextImp(true);
     return isOpen();
 }
 
@@ -191,19 +189,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;
@@ -211,21 +209,21 @@ 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);
+    if (m_filep && m_fileNewed) VL_DO_CLEAR(delete m_filep, m_filep = nullptr);
 }
 
 void VerilatedVcd::closePrev() {
     // This function is on the flush() call path
     if (!isOpen()) return;
 
-    VerilatedTrace<VerilatedVcd>::flush();
+    VerilatedTrace<VerilatedVcd>::flushBase();
     bufferFlush();
     m_isOpen = false;
     m_filep->close();
@@ -242,9 +240,9 @@ void VerilatedVcd::closeErr() {
     m_filep->close();  // May get error, just ignore it
 }
 
-void VerilatedVcd::close() {
+void VerilatedVcd::close() VL_MT_SAFE_EXCLUDES(m_mutex) {
     // This function is on the flush() call path
-    m_assertOne.check();
+    const VerilatedLockGuard lock(m_mutex);
     if (!isOpen()) return;
     if (m_evcd) {
         printStr("$vcdclose ");
@@ -254,11 +252,12 @@ void VerilatedVcd::close() {
     closePrev();
     // closePrev() called VerilatedTrace<VerilatedVcd>::flush(), so we just
     // need to shut down the tracing thread here.
-    VerilatedTrace<VerilatedVcd>::close();
+    VerilatedTrace<VerilatedVcd>::closeBase();
 }
 
-void VerilatedVcd::flush() {
-    VerilatedTrace<VerilatedVcd>::flush();
+void VerilatedVcd::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
+    const VerilatedLockGuard lock(m_mutex);
+    VerilatedTrace<VerilatedVcd>::flushBase();
     bufferFlush();
 }
 
@@ -272,7 +271,7 @@ void VerilatedVcd::printStr(const char* str) {
 
 void VerilatedVcd::printQuad(vluint64_t n) {
     char buf[100];
-    sprintf(buf, "%" VL_PRI64 "u", n);
+    VL_SNPRINTF(buf, 100, "%" VL_PRI64 "u", n);
     printStr(buf);
 }
 
@@ -286,7 +285,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);
     }
 }
 
@@ -296,7 +295,6 @@ void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
     // We add output data to m_writep.
     // When it gets nearly full we dump it using this routine which calls write()
     // This is much faster than using buffered I/O
-    m_assertOne.check();
     if (VL_UNLIKELY(!isOpen())) return;
     char* wp = m_wrBufp;
     while (true) {
@@ -350,9 +348,16 @@ void VerilatedVcd::printIndent(int level_change) {
 
 void VerilatedVcd::dumpHeader() {
     printStr("$version Generated by VerilatedVcd $end\n");
-    time_t time_str = time(NULL);
     printStr("$date ");
-    printStr(ctime(&time_str));
+    {
+        time_t tick = time(nullptr);
+        tm ticktm;
+        VL_LOCALTIME_R(&tick, &ticktm);
+        constexpr int bufsize = 50;
+        char buf[bufsize];
+        strftime(buf, bufsize, "%c", &ticktm);
+        printStr(buf);
+    }
     printStr(" $end\n");
 
     printStr("$timescale ");
@@ -373,9 +378,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();
@@ -406,13 +411,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;
                 }
             }
@@ -481,11 +495,12 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
         decl += wirep;  // usually "wire"
     }
 
-    char buf[1000];
-    sprintf(buf, " %2d ", bits);
+    constexpr size_t bufsize = 1000;
+    char buf[bufsize];
+    VL_SNPRINTF(buf, bufsize, " %2d ", bits);
     decl += buf;
     if (m_evcd) {
-        sprintf(buf, "<%u", code);
+        VL_SNPRINTF(buf, bufsize, "<%u", code);
         decl += buf;
     } else {
         // Add string code to decl
@@ -499,7 +514,8 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
         // 1 bit values don't have a ' ' separator between value and string code
         const bool isBit = bits == 1;
         entryp[0] = ' ';  // Separator
-        std::strcpy(entryp + !isBit, buf);  // Code (overwrite separator if isBit)
+        // Use memcpy as we checked size above, and strcpy is flagged unsafe
+        std::memcpy(entryp + !isBit, buf, strlen(buf));  // Code (overwrite separator if isBit)
         entryp[length + !isBit] = '\n';  // Replace '\0' with line termination '\n'
         // Set length of suffix (used to increment write pointer)
         entryp[VL_TRACE_SUFFIX_ENTRY_SIZE - 1] = !isBit + length + 1;
@@ -507,16 +523,16 @@ void VerilatedVcd::declare(vluint32_t code, const char* name, const char* wirep,
     decl += " ";
     decl += basename;
     if (array) {
-        sprintf(buf, "(%d)", arraynum);
+        VL_SNPRINTF(buf, bufsize, "(%d)", arraynum);
         decl += buf;
         hiername += buf;
     }
     if (bussed) {
-        sprintf(buf, " [%d:%d]", msb, lsb);
+        VL_SNPRINTF(buf, bufsize, " [%d:%d]", msb, lsb);
         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) {
@@ -650,8 +666,8 @@ void VerilatedVcd::emitWData(vluint32_t code, const WData* newvalp, int bits) {
 VL_ATTR_ALWINLINE
 void VerilatedVcd::emitDouble(vluint32_t code, double newval) {
     char* wp = m_writep;
-    // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(wp, "r%.16g", newval);
+    // Buffer can't overflow before VL_SNPRINTF; we sized during declaration
+    VL_SNPRINTF(wp, m_wrChunkSize, "r%.16g", newval);
     wp += strlen(wp);
     finishLine(code, wp);
 }
@@ -764,8 +780,8 @@ void VerilatedVcd::fullTriArray(vluint32_t code, const vluint32_t* newvalp,
 void VerilatedVcd::fullDouble(vluint32_t code, const double newval) {
     // cppcheck-suppress invalidPointerCast
     (*(reinterpret_cast<double*>(oldp(code)))) = newval;
-    // Buffer can't overflow before sprintf; we sized during declaration
-    sprintf(m_writep, "r%.16g", newval);
+    // Buffer can't overflow before VL_SNPRINTF; we sized during declaration
+    VL_SNPRINTF(m_writep, m_wrChunkSize, "r%.16g", newval);
     m_writep += strlen(m_writep);
     *m_writep++ = ' ';
     m_writep = writeCode(m_writep, code);
@@ -782,6 +798,8 @@ void VerilatedVcd::fullDouble(vluint32_t code, const double newval) {
 #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];
@@ -848,6 +866,8 @@ void vcdChange(void*, VerilatedVcd* vcdp) {
 
 // clang-format off
 void vcdTestMain(const char* filenamep) {
+    verilated_trace_imp_selftest();
+
     v1 = v2 = s1 = 0;
     s2[0] = s2[1] = s2[2] = 0;
     tri96[2] = tri96[1] = tri96[0] = 0;
@@ -859,6 +879,10 @@ void vcdTestMain(const char* filenamep) {
     {
         VerilatedVcdC* vcdp = new VerilatedVcdC;
         vcdp->evcd(true);
+        vcdp->set_time_unit("1ms");
+        vcdp->set_time_unit(std::string("1ms"));
+        vcdp->set_time_resolution("1ns");
+        vcdp->set_time_resolution(std::string("1ns"));
         vcdp->spTrace()->addInitCb(&vcdInit, 0);
         vcdp->spTrace()->addFullCb(&vcdFull, 0);
         vcdp->spTrace()->addChgCb(&vcdChange, 0);
@@ -894,6 +918,7 @@ void vcdTestMain(const char* filenamep) {
         }
 # endif
         vcdp->close();
+        VL_DO_CLEAR(delete vcdp, vcdp = nullptr);
     }
 }
 #endif

include/verilated_vcd_c.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.
@@ -17,8 +17,8 @@
 //=============================================================================
 // SPDIFF_OFF
 
-#ifndef _VERILATED_VCD_C_H_
-#define _VERILATED_VCD_C_H_ 1
+#ifndef VERILATOR_VERILATED_VCD_C_H_
+#define VERILATOR_VERILATED_VCD_C_H_
 
 #include "verilated.h"
 #include "verilated_trace.h"
@@ -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;
@@ -49,10 +48,10 @@ public:
 
 //=============================================================================
 // VerilatedVcd
-/// Base class to create a Verilator VCD dump
-/// This is an internally used class - see VerilatedVcdC for what to call from applications
+// 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,34 +61,34 @@ 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 openNextImp(bool incFilename);
     void closePrev();
     void closeErr();
-    void openNext();
     void makeNameMap();
     void deleteNameMap();
     void printIndent(int level_change);
@@ -101,7 +100,7 @@ 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);
 
@@ -113,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.
@@ -133,24 +132,24 @@ public:
     //=========================================================================
     // External interface to client code
 
-    explicit VerilatedVcd(VerilatedVcdFile* filep = NULL);
+    explicit VerilatedVcd(VerilatedVcdFile* filep = nullptr);
     ~VerilatedVcd();
 
     // ACCESSORS
-    /// Set size in megabytes after which new file should be created
+    // Set size in megabytes after which new file should be created
     void rolloverMB(vluint64_t rolloverMB) { m_rolloverMB = rolloverMB; }
 
     // METHODS
-    /// Open the file; call isOpen() to see if errors
-    void open(const char* filename) VL_MT_UNSAFE_ONE;
-    /// Open next data-only file
-    void openNext(bool incFilename) VL_MT_UNSAFE_ONE;
-    /// Close the file
-    void close() VL_MT_UNSAFE_ONE;
-    /// Flush any remaining data to this file
-    void flush() VL_MT_UNSAFE_ONE;
-    /// Is file open?
-    bool isOpen() const { return m_isOpen; }
+    // Open the file; call isOpen() to see if errors
+    void open(const char* filename) VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Open next data-only file
+    void openNext(bool incFilename) VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Close the file
+    void close() VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Flush any remaining data to this file
+    void flush() VL_MT_SAFE_EXCLUDES(m_mutex);
+    // Return if file is open
+    bool isOpen() const VL_MT_SAFE { return m_isOpen; }
 
     //=========================================================================
     // Internal interface to Verilator generated code
@@ -212,8 +211,8 @@ public:
         chgDouble(oldp - this->oldp(0), newval);
     }
 
-    /// Inside dumping routines, dump one signal, faster when not inlined
-    /// due to code size reduction.
+    // Inside dumping routines, dump one signal, faster when not inlined
+    // due to code size reduction.
     void fullBit(vluint32_t code, const vluint32_t newval);
     void fullBus(vluint32_t code, const vluint32_t newval, int bits);
     void fullQuad(vluint32_t code, const vluint64_t newval, int bits);
@@ -226,8 +225,8 @@ public:
                       int bits);
     void fullDouble(vluint32_t code, const double newval);
 
-    /// 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.
+    // 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.
     inline void chgBit(vluint32_t code, const vluint32_t newval) {
         vluint32_t diff = oldp(code)[0] ^ newval;
         if (VL_UNLIKELY(diff)) fullBit(code, newval);
@@ -328,57 +327,64 @@ template <> void VerilatedTrace<VerilatedVcd>::set_time_resolution(const std::st
 // VerilatedVcdC
 /// Create a VCD dump file in C standalone (no SystemC) simulations.
 /// 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) {}
+    /// Construct the dump. Optional argument is a preconstructed file.
+    explicit VerilatedVcdC(VerilatedVcdFile* filep = nullptr)
+        : m_sptrace{filep} {}
+    /// Destruct, flush, and close the dump
     ~VerilatedVcdC() { close(); }
-    /// Routines can only be called from one thread; allow next call from different thread
-    void changeThread() { spTrace()->changeThread(); }
 
 public:
-    // ACCESSORS
-    /// Is file open?
-    bool isOpen() const { return m_sptrace.isOpen(); }
-    // METHODS
+    // METHODS - User called
+
+    /// Return if file is open
+    bool isOpen() const VL_MT_SAFE { return m_sptrace.isOpen(); }
     /// Open a new VCD file
     /// This includes a complete header dump each time it is called,
     /// just as if this object was deleted and reconstructed.
-    void open(const char* filename) VL_MT_UNSAFE_ONE { m_sptrace.open(filename); }
+    void open(const char* filename) VL_MT_SAFE { m_sptrace.open(filename); }
     /// Continue a VCD dump by rotating to a new file name
     /// The header is only in the first file created, this allows
     /// "cat" to be used to combine the header plus any number of data files.
-    void openNext(bool incFilename = true) VL_MT_UNSAFE_ONE { m_sptrace.openNext(incFilename); }
+    void openNext(bool incFilename = true) VL_MT_SAFE { m_sptrace.openNext(incFilename); }
     /// Set size in megabytes after which new file should be created
-    void rolloverMB(size_t rolloverMB) { m_sptrace.rolloverMB(rolloverMB); }
+    void rolloverMB(size_t rolloverMB) VL_MT_SAFE { m_sptrace.rolloverMB(rolloverMB); }
     /// Close dump
-    void close() VL_MT_UNSAFE_ONE { m_sptrace.close(); }
+    void close() VL_MT_SAFE { m_sptrace.close(); }
     /// Flush dump
-    void flush() VL_MT_UNSAFE_ONE { m_sptrace.flush(); }
+    void flush() VL_MT_SAFE { m_sptrace.flush(); }
     /// Write one cycle of dump data
-    void dump(vluint64_t timeui) { m_sptrace.dump(timeui); }
+    void dump(vluint64_t timeui) VL_MT_SAFE { m_sptrace.dump(timeui); }
     /// Write one cycle of dump data - backward compatible and to reduce
     /// conversion warnings.  It's better to use a vluint64_t time instead.
     void dump(double timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     void dump(vluint32_t timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
     void dump(int timestamp) { dump(static_cast<vluint64_t>(timestamp)); }
-    /// Set time units (s/ms, defaults to ns)
-    /// For Verilated models, these propage from the Verilated default --timeunit
-    void set_time_unit(const char* unit) { m_sptrace.set_time_unit(unit); }
-    void set_time_unit(const std::string& unit) { m_sptrace.set_time_unit(unit); }
-    /// Set time resolution (s/ms, defaults to ns)
-    /// For Verilated models, these propage from the Verilated default --timeunit
-    void set_time_resolution(const char* unit) { m_sptrace.set_time_resolution(unit); }
-    void set_time_resolution(const std::string& unit) { m_sptrace.set_time_resolution(unit); }
 
-    /// Internal class access
+    // METHODS - Internal/backward compatible
+    // \protectedsection
+
+    // Set time units (s/ms, defaults to ns)
+    // Users should not need to call this, as for Verilated models, these
+    // propage from the Verilated default timeunit
+    void set_time_unit(const char* unit) VL_MT_SAFE { m_sptrace.set_time_unit(unit); }
+    void set_time_unit(const std::string& unit) VL_MT_SAFE { m_sptrace.set_time_unit(unit); }
+    // Set time resolution (s/ms, defaults to ns)
+    // Users should not need to call this, as for Verilated models, these
+    // propage from the Verilated default timeprecision
+    void set_time_resolution(const char* unit) VL_MT_SAFE { m_sptrace.set_time_resolution(unit); }
+    void set_time_resolution(const std::string& unit) VL_MT_SAFE {
+        m_sptrace.set_time_resolution(unit);
+    }
+
+    // Internal class access
     inline VerilatedVcd* spTrace() { return &m_sptrace; }
 
 #ifdef VL_TRACE_VCD_OLD_API
@@ -386,7 +392,8 @@ public:
     // 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
+
+    // Use evcd format
     void evcd(bool flag) VL_MT_UNSAFE_ONE { m_sptrace.evcd(flag); }
 #endif
 };

include/verilated_vcd_sc.cpp

@@ -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.
@@ -15,32 +15,29 @@
 /// \brief Verilator tracing in VCD Format
 ///
 //=============================================================================
-// SPDIFF_OFF
 
 #include "verilatedos.h"
 #include "verilated_vcd_sc.h"
 
-// SPDIFF_ON
 //======================================================================
 //======================================================================
 
 //--------------------------------------------------
-#if (SYSTEMC_VERSION >= 20050714)
 // SystemC 2.1.v1
 // cppcheck-suppress unusedFunction
 void VerilatedVcdSc::write_comment(const std::string&) {}
 void VerilatedVcdSc::trace(const unsigned int&, const std::string&, const char**) {}
 
-// 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 +47,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 +73,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
 

include/verilated_vcd_sc.h

@@ -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.
@@ -15,30 +15,28 @@
 /// This class is not threadsafe, as the SystemC kernel is not threadsafe.
 ///
 //=============================================================================
-// SPDIFF_OFF
 
-#ifndef _VERILATED_VCD_SC_H_
-#define _VERILATED_VCD_SC_H_ 1
+#ifndef VERILATOR_VERILATED_VCD_SC_H_
+#define VERILATOR_VERILATED_VCD_SC_H_
 
 #include "verilatedos.h"
 #include "verilated_sc.h"
 #include "verilated_vcd_c.h"
 
-// SPDIFF_ON
 //=============================================================================
 // VerilatedVcdSc
 ///
-/// This class is passed to the SystemC simulation kernel, just like a
-/// documented SystemC trace format.
+/// This class creates a Verilator-friendly VCD trace format with the
+/// SystemC simulation kernel, just like a SystemC-documented trace format.
 
-class VerilatedVcdSc : sc_trace_file, public VerilatedVcdC {
+class VerilatedVcdSc final : sc_trace_file, public VerilatedVcdC {
     // CONSTRUCTORS
     VL_UNCOPYABLE(VerilatedVcdSc);
 
 public:
+    /// Construct a SC trace object, and register with the SystemC kernel
     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,54 +46,40 @@ 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
     }
+    /// Destruct, flush, and close the dump
     virtual ~VerilatedVcdSc() { close(); }
 
-    // METHODS
-    /// Called by SystemC simulate()
+    // METHODS - for SC kernel
+    // 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:
-    /// Fake outs for linker
+    // METHODS - Fake outs for linker
 
 #ifdef NC_SYSTEMC
     // Cadence Incisive has these as abstract functions so we must create them
     virtual void set_time_unit(int exponent10_seconds) {}  // deprecated
 #endif
-#if defined(NC_SYSTEMC) || (SYSTEMC_VERSION >= 20111100)
     virtual void set_time_unit(double v, sc_time_unit tu) {}  // LCOV_EXCL_LINE
-#endif
 
 //--------------------------------------------------
-#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
 };

include/verilated_vpi.h

@@ -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.
@@ -19,8 +19,8 @@
 ///
 //=========================================================================
 
-#ifndef _VERILATED_VPI_H_
-#define _VERILATED_VPI_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATED_VPI_H_
+#define VERILATOR_VERILATED_VPI_H_  ///< Header Guard
 
 #include "verilatedos.h"
 #include "verilated.h"
@@ -33,21 +33,22 @@
 
 //======================================================================
 
-class VerilatedVpi {
+class VerilatedVpi final {
 public:
     /// Call timed callbacks
     /// Users should call this from their main loops
     static void callTimedCbs() VL_MT_UNSAFE_ONE;
     /// Call value based callbacks
     /// Users should call this from their main loops
-    static void callValueCbs() VL_MT_UNSAFE_ONE;
+    static bool callValueCbs() VL_MT_UNSAFE_ONE;
     /// Call callbacks of arbitrary types
     /// Users can call this from their application code
     static bool callCbs(vluint32_t reason) VL_MT_UNSAFE_ONE;
     /// Returns time of the next registered VPI callback, or
     /// ~(0) if none are registered
     static QData cbNextDeadline() VL_MT_UNSAFE_ONE;
-    /// Self test, for internal use only
+
+    // Self test, for internal use only
     static void selfTest() VL_MT_UNSAFE_ONE;
 };
 

include/verilatedos.h

@@ -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.
@@ -22,8 +22,8 @@
 ///
 //*************************************************************************
 
-#ifndef _VERILATEDOS_H_
-#define _VERILATEDOS_H_ 1  ///< Header Guard
+#ifndef VERILATOR_VERILATEDOS_H_
+#define VERILATOR_VERILATEDOS_H_  ///< Header Guard
 
 // Current clang-format versions botch #ifdef inclusion, so
 // clang-format off
@@ -39,6 +39,9 @@
 # define VL_ATTR_PRINTF(fmtArgNum) __attribute__((format(printf, (fmtArgNum), (fmtArgNum) + 1)))
 # define VL_ATTR_PURE __attribute__((pure))
 # define VL_ATTR_UNUSED __attribute__((unused))
+# if !defined(_WIN32) && !defined(__MINGW32__)
+#  define VL_ATTR_WEAK __attribute__((weak))
+# endif
 # define VL_FUNC __func__
 # if defined(__clang__) && defined(VL_THREADED)
 #  define VL_ACQUIRE(...) __attribute__((acquire_capability(__VA_ARGS__)))
@@ -87,6 +90,9 @@
 #ifndef VL_ATTR_UNUSED
 # define VL_ATTR_UNUSED  ///< Function that may be never used
 #endif
+#ifndef VL_ATTR_WEAK
+# define VL_ATTR_WEAK  ///< Function external that is optionally defined
+#endif
 #ifndef VL_FUNC
 # define VL_FUNC "__func__"  ///< Name of current function for error macros
 #endif
@@ -118,11 +124,11 @@
 # define VL_PREFETCH_RW(p)  ///< Prefetch data with read/write intent
 #endif
 
-#ifdef VL_THREADED
+#if defined(VL_THREADED) && !defined(VL_CPPCHECK)
 # if defined(_MSC_VER) && _MSC_VER >= 1900
 #  define VL_THREAD_LOCAL thread_local
 # elif defined(__GNUC__)
-#  if (__cplusplus < 201103L) && !defined(VL_THREADED_NO_C11_WARNING)
+#  if (__cplusplus < 201103L)
 #   error "VL_THREADED/--threads support requires C++-11 or newer only; use newer compiler"
 #  endif
 # else
@@ -133,18 +139,23 @@
 # define VL_THREAD_LOCAL  ///< Use new C++ static local thread
 #endif
 
-#define VL_THREAD  ///< Deprecated
-#define VL_STATIC_OR_THREAD static  ///< Deprecated
+#ifndef VL_NO_LEGACY
+# define VL_THREAD  ///< Deprecated
+# define VL_STATIC_OR_THREAD static  ///< Deprecated
+#endif
 
 #define VL_PURE  ///< Comment tag that Function is pure (and thus also VL_MT_SAFE)
 #define VL_MT_SAFE  ///< Comment tag that function is threadsafe when VL_THREADED
 #define VL_MT_SAFE_POSTINIT  ///< Comment tag that function is threadsafe when VL_THREADED, only
                              ///< during normal operation (post-init)
+#define VL_MT_SAFE_EXCLUDES(mutex) VL_EXCLUDES(mutex)  ///< Threadsafe and uses given mutex
 #define VL_MT_UNSAFE  ///< Comment tag that function is not threadsafe when VL_THREADED
 #define VL_MT_UNSAFE_ONE  ///< Comment tag that function is not threadsafe when VL_THREADED,
                           ///< protected to make sure single-caller
 
-#define VL_ULL(c) (c##ULL)  ///< Add appropriate suffix to 64-bit constant (deprecated)
+#ifndef VL_NO_LEGACY
+# define VL_ULL(c) (c##ULL)  ///< Add appropriate suffix to 64-bit constant (deprecated)
+#endif
 
 // This is not necessarily the same as #UL, depending on what the IData typedef is.
 #define VL_UL(c) (static_cast<IData>(c##UL))  ///< Add appropriate suffix to 32-bit constant
@@ -152,14 +163,14 @@
 #if defined(VL_CPPCHECK) || defined(__clang_analyzer__) || __cplusplus < 201103L
 # define VL_DANGLING(var)
 #else
-/// After e.g. delete, set variable to NULL to indicate must not use later
+/// After e.g. delete, set variable to nullptr to indicate must not use later
 # define VL_DANGLING(var) \
     do { \
-        *const_cast<const void**>(reinterpret_cast<const void* const*>(&var)) = NULL; \
+        *const_cast<const void**>(reinterpret_cast<const void* const*>(&var)) = nullptr; \
     } while (false)
 #endif
 
-/// Perform an e.g. delete, then set variable to NULL to indicate must not use later.
+/// Perform an e.g. delete, then set variable to nullptr to indicate must not use later.
 /// Unlike VL_DO_CLEAR the setting of the variable is only for debug reasons.
 #define VL_DO_DANGLING(stmt, var) \
     do { \
@@ -169,7 +180,7 @@
         VL_DANGLING(var); \
     } while (false)
 
-/// Perform an e.g. delete, then set variable to NULL as a requirement
+/// Perform an e.g. delete, then set variable to nullptr as a requirement
 #define VL_DO_CLEAR(stmt, stmt2) \
     do { \
         do { \
@@ -184,30 +195,20 @@
 // C++-2011
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) || defined(VL_CPPCHECK)
-# define VL_EQ_DELETE = delete
-# define vl_unique_ptr std::unique_ptr
-// By default we use std:: types in C++11.
-// Define VL_USE_UNORDERED_TYPES to test these pre-C++11 classes
-# ifdef VL_USE_UNORDERED_TYPES
-#  define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
-#  define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
-# else
+# ifndef VL_NO_LEGACY
+// These are deprecated historical defines. We leave them in case users referenced them.
+#  define VL_EQ_DELETE = delete
+#  define vl_unique_ptr std::unique_ptr
 #  define vl_unordered_map std::unordered_map
 #  define vl_unordered_set std::unordered_set
 #  define VL_INCLUDE_UNORDERED_MAP <unordered_map>
 #  define VL_INCLUDE_UNORDERED_SET <unordered_set>
+#  define VL_FINAL final
+#  define VL_MUTABLE mutable
+#  define VL_OVERRIDE override
 # endif
-# define VL_FINAL final
-# define VL_MUTABLE mutable
-# define VL_OVERRIDE override
 #else
-# define VL_EQ_DELETE
-# define vl_unique_ptr std::auto_ptr
-# define VL_INCLUDE_UNORDERED_MAP "verilated_unordered_set_map.h"
-# define VL_INCLUDE_UNORDERED_SET "verilated_unordered_set_map.h"
-# define VL_FINAL
-# define VL_MUTABLE
-# define VL_OVERRIDE
+# error "Verilator requires a C++11 or newer compiler"
 #endif
 
 //=========================================================================
@@ -370,12 +371,15 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 #define VL_BYTESIZE 8  ///< Bits in a CData / byte
 #define VL_SHORTSIZE 16  ///< Bits in a SData / short
 #define VL_IDATASIZE 32  ///< Bits in a IData / word
-#define VL_WORDSIZE VL_IDATASIZE  ///< Legacy define
 #define VL_QUADSIZE 64  ///< Bits in a QData / quadword
 #define VL_EDATASIZE 32  ///< Bits in a EData (WData entry)
 #define VL_EDATASIZE_LOG2 5  ///< log2(VL_EDATASIZE)
 #define VL_CACHE_LINE_BYTES 64  ///< Bytes in a cache line (for alignment)
 
+#ifndef VL_NO_LEGACY
+# define VL_WORDSIZE VL_IDATASIZE  ///< Legacy define
+#endif
+
 /// Bytes this number of bits needs (1 bit=1 byte)
 #define VL_BYTES_I(nbits) (((nbits) + (VL_BYTESIZE - 1)) / VL_BYTESIZE)
 /// Words/EDatas this number of bits needs (1 bit=1 word)
@@ -386,10 +390,13 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 //=========================================================================
 // Class definition helpers
 
-// Used to declare a class as uncopyable; put after a private:
+/// Used to indicate a base class, e.g. cannot label "class final"
+#define VL_NOT_FINAL
+
+/// Used to declare a class as uncopyable; put after a private:
 #define VL_UNCOPYABLE(Type) \
-    Type(const Type& other) VL_EQ_DELETE; \
-    Type& operator=(const Type&) VL_EQ_DELETE
+    Type(const Type& other) = delete; \
+    Type& operator=(const Type&) = delete
 
 //=========================================================================
 // Verilated function size macros
@@ -459,7 +466,7 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 #  define NOMINMAX
 #  include "Windows.h"
 #  define VL_CPU_RELAX() YieldProcessor()
-# elif defined(__i386__) || defined(__x86_64__)
+# elif defined(__i386__) || defined(__x86_64__) || defined(VL_CPPCHECK)
 /// For more efficient busy waiting on SMT CPUs, let the processor know
 /// we're just waiting so it can let another thread run
 #  define VL_CPU_RELAX() asm volatile("rep; nop" ::: "memory")
@@ -475,7 +482,7 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 #endif
 
 //=========================================================================
-// String related OS-specific functions
+// String/time related OS-specific functions
 
 #ifdef _MSC_VER
 # define VL_STRCASECMP _stricmp
@@ -483,6 +490,12 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 # define VL_STRCASECMP strcasecmp
 #endif
 
+#ifdef _MSC_VER
+# define VL_LOCALTIME_R(timep, tmp) localtime_c((tmp), (timep))
+#else
+# define VL_LOCALTIME_R(timep, tmp) localtime_r((timep), (tmp))
+#endif
+
 //=========================================================================
 // Macros controlling target specific optimizations
 
@@ -500,6 +513,14 @@ typedef unsigned long long vluint64_t;  ///< 64-bit unsigned type
 #define VL_STRINGIFY(x) VL_STRINGIFY2(x)
 #define VL_STRINGIFY2(x) #x
 
+//=========================================================================
+// Conversions
+
+namespace vlstd {
+// C++17's std::as_const
+template <class T> T const& as_const(T& v) { return v; }
+};  // namespace vlstd
+
 //=========================================================================
 
 #endif  // Guard

include/vltstd/svdpi.h

@@ -102,7 +102,7 @@ typedef uint32_t svBitVecVal;
  * Because the contents of the unused bits is undetermined,
  * the following macros can be handy.
  */
-#define SV_MASK(N) (~(-1 << (N)))
+#define SV_MASK(N) (~(0xffffffffU << (N)))
 
 #define SV_GET_UNSIGNED_BITS(VALUE, N) \
     ((N) == 32 ? (VALUE) : ((VALUE) & SV_MASK(N)))

nodist/bisondiff

@@ -1,82 +0,0 @@
-#!/usr/bin/env perl
-######################################################################
-#
-# Copyright 2007-2020 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-#
-######################################################################
-
-# DESCRIPTION: Diff bison files
-
-use warnings;
-use Getopt::Long;
-use IO::File;
-use strict;
-
-our $Debug;
-our $Opt_Unsup;
-
-if (! GetOptions (
-          #"help"       => \&usage,
-          "debug"       => sub { $Debug = 1; },
-          "unsup!"      => \$Opt_Unsup,  # Ignore unsupported
-    )) {
-    die "usage();"
-}
-
-diff($ARGV[0],$ARGV[1]);
-
-sub diff {
-    my $a=shift;
-    my $b=shift;
-
-    my $ta = "/tmp/bisondiff.$$.a";
-    my $tb = "/tmp/bisondiff.$$.b";
-
-    prep($a,$ta);
-    prep($b,$tb);
-
-    system("diff -u -w $ta $tb");
-}
-
-sub prep {
-    my $filename = shift;
-    my $wfilename = shift;
-
-    my $fh = IO::File->new("<$filename") or die "%Error: $! $filename";
-    my $fho = IO::File->new(">$wfilename") or die "%Error: $! writing $wfilename";
-
-    my %declared;
-    my %used;
-
-    my $body = 0;
-    my $rule = "";
-    my $skip = 1;
-    while (defined(my $line = $fh->getline)) {
-        if ($skip == 1) {
-            next if $line !~ /%token/;
-            $skip = 2;
-        }
-
-        if ($Opt_Unsup) {
-            $line =~ s!//UNSUP!|!g;
-            $line =~ s!(\s+)\|(\s+)!$1$2!g;  # As "UNSUP" often replaces "|"
-        }
-
-        # %type<foo>
-        $line =~ s/^(%\S+)<(\S+)>/$1/;
-        # rule<foo>
-        $line =~ s/^([a-zA-Z0-9_]+)<\S+>:/$1:/;
-        # Productions
-        $line =~ s/[ \t]{[^}]*?}/\t{}/g;
-
-        $fho->print($line);
-    }
-}
-
-# Local Variables:
-# compile-command: "./bisondiff --unsup $VP/Parser/VParseBison.y ../src/verilog.y"
-# End:

nodist/code_coverage

@@ -1,511 +1,429 @@
-#!/usr/bin/env perl
-# See copyright, etc in below POD section.
+#!/usr/bin/env python3
+# pylint: disable=C0103,C0114,C0115,C0116,R0912,R0914,R0915,W0125,W0621,exec-used
 ######################################################################
 
-use warnings;
-use Cwd;
-use File::Copy qw(cp);
-use File::Path qw(mkpath);
-use File::Spec;
-use FindBin qw($RealBin);
-use Getopt::Long;
-use Parallel::Forker;
-use Unix::Processors;
-use IO::File;
-use Pod::Usage;
-use strict;
-use vars qw($Debug);
+import argparse
+import glob
+import multiprocessing
+import os
+import re
+import subprocess
+import sys
 
-our $Opt_Stop = 1;
-our $Opt_Fastcov = 1;
-our $Exclude_Branch_Regexp;
-our $Exclude_Line_Regexp;
-our $Remove_Gcda_Regexp;
+RealPath = os.path.dirname(os.path.realpath(__file__))
+Exclude_Branch_Regexps = []
+Exclude_Line_Regexps = []
+Remove_Gcda_Regexps = []
+Remove_Sources = []
+Source_Globs = []
 
-our @Remove_Sources;
-our @Source_Globs;
+if 'VERILATOR_ROOT' not in os.environ:
+    os.environ['VERILATOR_ROOT'] = os.getcwd()
 
-our $Fork = new Parallel::Forker(use_sig_child => 1, poll_interval => 10*1000);
-$Fork->max_proc(Unix::Processors->new->max_online * 1.5);
-$SIG{CHLD} = sub { Parallel::Forker::sig_child($Fork); };
-$SIG{TERM} = sub { $Fork->kill_tree_all('TERM') if $Fork && $Fork->in_parent; die "Quitting...\n"; };
+######################################################################
 
-#======================================================================
-# main
 
-our $Opt_Hashset;
-our $opt_stages = '';
-our $Opt_Scenarios;
-our %Opt_Stages;
-our @Opt_Tests;
+def test():
+    if not os.path.exists("nodist/code_coverage.dat"):
+        sys.exit("%Error: Run code_coverage from the top of the verilator kit")
+    exec(open("./nodist/code_coverage.dat").read())
 
-autoflush STDOUT 1;
-autoflush STDERR 1;
-Getopt::Long::config("no_auto_abbrev");
-if (! GetOptions(
-          "debug"       => sub { $Debug = 1; },
-          "hashset=s"   => \$Opt_Hashset,  # driver.pl hashset
-          "<>"          => sub { die "%Error: Unknown parameter: $_[0]\n"; },
-          "fastcov!"    => \$Opt_Fastcov,  # use fastcov, not documented, for debug
-          "scenarios=s" => \$Opt_Scenarios,  # driver.pl scenarios
-          "stage=s"     => \$opt_stages,  # starting stage number
-          "stages=s"    => \$opt_stages,  # starting stage number
-          "stop!"       => \$Opt_Stop,  # stop/do not stop on error in tests
-          "test=s@"     => \@Opt_Tests,  # test name
-    )) {
-    die "%Error: Bad usage, try 'code_coverage --help'\n";
-}
+    if Args.stage_enabled[0]:
+        ci_fold_start("distclean")
+        print("Stage 0: distclean")
+        run("make distclean || true")
+        ci_fold_end()
 
-{
-    my $start = 0;
-    my $end = 99;
-    if ($opt_stages && $opt_stages =~ /^(\d+)$/) {
-        $start = $end = $1;
-    } elsif ($opt_stages && $opt_stages =~ /^(\d+)-(\d+$)$/) {
-        $start = $1; $end = $2;
-    } elsif ($opt_stages && $opt_stages =~ /^-(\d+$)$/) {
-        $end = $1;
-    } elsif ($opt_stages && $opt_stages =~ /^(\d+)-$/) {
-        $start = $1;
-    } elsif ($opt_stages) {
-        die "%Error: --stages not understood: $opt_stages,";
-    }
-    for (my $n = $start; $n <= $end; ++$n) { $Opt_Stages{$n} = 1; }
-}
+    if Args.stage_enabled[1]:
+        ci_fold_start("configure")
+        print("Stage 1: configure (coverage on)")
+        run("autoconf")
+        cxx_flags = (
+            "--coverage"
+            # Otherwise inline may not show as uncovered
+            #  If we use this then e.g. verilated.h functions properly show up
+            #  if unused.
+            #  However, VerilatedSerialize::write then changes from covered
+            #  to uncovered (in G++ 9.3.0) even with all inlining turned off.
+            #  Having false negative coverage is more effort then missing negatives.
+            #  Also this seems to explode the runtime (since a lot more data).
+            #+ " -fkeep-inline-functions"
+            # Otherwise static may not show as uncovered
+            + " -fkeep-static-functions"
+            # Exceptions can pollute the branch coverage data
+            + " -fno-exceptions"
+            # Define-out some impossible stuff
+            + " -DVL_GCOV")
+        run("./configure --enable-longtests CXX='g++ " + cxx_flags + "'")
+        ci_fold_end()
 
-test();
-exit(0);
-
-#######################################################################
-
-sub test {
-    -r "nodist/code_coverage.dat" or die "%Error: Run from the top of the verilator kit,";
-    require "./nodist/code_coverage.dat";
-
-    if ($Opt_Stages{1}) {
-        travis_fold_start("configure");
-        print "Stage 1: configure (coverage on)\n";
-        run("make distclean || true");
-        run("autoconf");
-        # Exceptions can pollute the branch coverage data
-        run("./configure --enable-longtests CXX='g++ --coverage -fno-exceptions -DVL_GCOV'");
-        travis_fold_end();
-    }
-
-    if ($Opt_Stages{2}) {
-        travis_fold_start("build");
-        print "Stage 2: build\n";
-        my $nproc = Unix::Processors->new->max_online;
-        run("make -k -j $nproc VERILATOR_NO_OPT_BUILD=1");
+    if Args.stage_enabled[2]:
+        ci_fold_start("build")
+        print("Stage 2: build")
+        nproc = multiprocessing.cpu_count()
+        run("make -k -j " + str(nproc) + " VERILATOR_NO_OPT_BUILD=1")
         # The optimized versions will not collect good coverage, overwrite them
-        run("cp bin/verilator_bin_dbg bin/verilator_bin");
-        run("cp bin/verilator_coverage_bin_dbg bin/verilator_coverage_bin");
-        travis_fold_end();
-    }
+        run("cp bin/verilator_bin_dbg bin/verilator_bin")
+        run("cp bin/verilator_coverage_bin_dbg bin/verilator_coverage_bin")
+        ci_fold_end()
 
-    if ($Opt_Stages{3}) {
-        travis_fold_start("test");
-        print "Stage 3: make tests (with coverage on)\n";
-        if ($#Opt_Tests < 0) {
-            run("make examples VERILATOR_NO_OPT_BUILD=1")
-                if !$Opt_Scenarios || $Opt_Scenarios =~ /dist/i;
-            run("make test_regress VERILATOR_NO_OPT_BUILD=1"
-                . ($Opt_Scenarios ? " SCENARIOS='".$Opt_Scenarios."'" : "")
-                . ($Opt_Hashset ? " DRIVER_HASHSET='--hashset=".$Opt_Hashset."'" : "")
-                . ($Opt_Stop ? '' : ' || true'));
-        } else {
-            foreach my $test (@Opt_Tests) {
-                if (! -f $test && -f "test_regress/t/${test}") {
-                    $test = "test_regress/t/${test}";
-                }
-                run($test);
-            }
-        }
-        travis_fold_end();
-    }
+    if Args.stage_enabled[3]:
+        ci_fold_start("test")
+        print("Stage 3: make tests (with coverage on)")
+        if not Args.tests:
+            if not Args.scenarios or re.match('dist', Args.scenarios):
+                run("make examples VERILATOR_NO_OPT_BUILD=1")
+            run("make test_regress VERILATOR_NO_OPT_BUILD=1" +
+                (" SCENARIOS='" + Args.scenarios +
+                 "'" if Args.scenarios else "") +
+                (" DRIVER_HASHSET='--hashset=" + Args.hashset +
+                 "'" if Args.hashset else "") +
+                ('' if Args.stop else ' || true'))
+        else:
+            for test in Args.tests:
+                if not os.path.exists(test) and os.path.exists(
+                        "test_regress/t/" + test):
+                    test = "test_regress/t/" + test
+                run(test)
+        ci_fold_end()
 
-    my $cc_dir = "nodist/obj_dir/coverage";
-    if ($Opt_Stages{4}) {
-        travis_fold_start("gcno");
-        print "Stage 4: Create gcno files under $cc_dir\n";
-        mkpath($cc_dir);
-        mkpath("$cc_dir/info");
-        my $dats = `find . -print | grep .gcda`;
-        my %dats;
-        foreach my $dat (split '\n', $dats) {
-            $dats{$dat} = 1;
-        }
-        foreach my $dat (sort keys %dats) {
-            (my $gcno = $dat) =~ s!\.gcda$!.gcno!;
-            if ($dat =~ /$Remove_Gcda_Regexp/) {
-                # Remove .gcda/.gcno for files we don't care about before we slowly
-                # read them
-                unlink $dat;
-                unlink $gcno;
-                delete $dats{$dat};
-                next;
-            }
-        }
-        $dats = `find . -print | grep .gcno`;
-        my %gcnos;
-        foreach my $gcno (split '\n', $dats) {
-            (my $gbase = $gcno) =~ s!.*/!!;
-            $gcnos{$gbase} = File::Spec->rel2abs($gcno);
-        }
+    cc_dir = "nodist/obj_dir/coverage"
+    if Args.stage_enabled[4]:
+        ci_fold_start("gcno")
+        print("Stage 4: Create gcno files under " + cc_dir)
+        os.makedirs(cc_dir, exist_ok=True)
+        os.makedirs(cc_dir + "/info", exist_ok=True)
+
+        sp = subprocess.Popen("find . -print | grep .gcda",
+                              shell=True,
+                              stdout=subprocess.PIPE)
+        datout = sp.stdout.read()
+        dats = {}
+        for dat in datout.splitlines():
+            dat = dat.decode('utf-8')
+            dats[dat] = 1
+        for dat in sorted(dats.keys()):
+            gcno = re.sub(r'\.gcda$', '.gcno', dat)
+            for regexp in Remove_Gcda_Regexps:
+                if re.search(regexp, dat):
+                    # Remove .gcda/.gcno for files we don't care about before we slowly
+                    # read them
+                    unlink_ok(dat)
+                    unlink_ok(gcno)
+                    del dats[dat]
+                    break
+
+        sp = subprocess.Popen("find . -print | grep .gcno",
+                              shell=True,
+                              stdout=subprocess.PIPE)
+        datout = sp.stdout.read()
+        gcnos = {}
+        for gcno in datout.splitlines():
+            gcno = gcno.decode('utf-8')
+            gbase = re.sub(r'.*/', '', gcno, count=1)
+            gcnos[gbase] = os.path.abspath(gcno)
         # We need a matching .gcno for every .gcda, try to find a matching file elsewhere
-        foreach my $dat (sort keys %dats) {
-            (my $gcno = $dat) =~ s!\.gcda$!.gcno!;
-            (my $gbase = $gcno) =~ s!.*/!!;
-            if (!-r $gcno) {
-                if ($gcnos{$gbase}) {
-                    symlink($gcnos{$gbase}, $gcno)
-                        or die "%Error: can't ln -s $gcnos{$gbase} $gcno,";
-                } else {
-                    warn "MISSING .gcno for a .gcda: $gcno\n";
-                }
-            }
-        }
-        travis_fold_end();
-    }
+        for dat in sorted(dats):
+            gcno = re.sub(r'\.gcda$', '.gcno', dat)
+            gbase = re.sub(r'.*/', '', gcno, count=1)
+            if not os.path.exists(gcno):
+                if gbase in gcnos:
+                    os.symlink(gcnos[gbase], gcno)
+                else:
+                    print("MISSING .gcno for a .gcda: " + gcno,
+                          file=sys.stderr)
+        ci_fold_end()
 
-    if ($Opt_Stages{5} && $Opt_Fastcov) {
-        travis_fold_start("fastcov");
+    if Args.stage_enabled[5]:
+        ci_fold_start("fastcov")
         # Must run in root directory to find all files
-        mkpath($cc_dir);
-        #run("${RealBin}/fastcov.py -b -c src/obj_dbg -X".
-        #    " --exclude /usr --exclude test_regress"
-        #    ." -o ${cc_dir}/app_total.json");
-        run("${RealBin}/fastcov.py -b -c src/obj_dbg -X --lcov".
-            " --exclude /usr --exclude test_regress"
-            ." -o ${cc_dir}/app_total.info");
-        travis_fold_end();
-    }
+        os.makedirs(cc_dir, exist_ok=True)
+        run(RealPath + "/fastcov.py -b -c src/obj_dbg -X --lcov" +
+            #            " --exclude /usr --exclude test_regress" + " -o " + cc_dir +
+            " -o " + cc_dir + "/app_total.info")
+        # For debug to convert single .gcna/.gcno in a directory to cov.info:
+        #    lcov -c -d . -o cov.info
+        ci_fold_end()
 
-    if ($Opt_Stages{5} && !$Opt_Fastcov) {
-        travis_fold_start("infos");
-        print "Stage 5: make infos\n";
-        my $dats = `find . -print | grep .gcda`;
-        my %dirs;
-        foreach my $dat (split '\n', $dats) {
-            (my $dir = $dat) =~ s!/[^/]+$!!;
-            $dirs{$dir} = 1;
-        }
-
-        foreach my $dir (sort keys %dirs) {
-            (my $outname = $dir) =~ s![^a-zA-Z0-9]+!_!g;
-            $Fork->schedule(run_on_start => sub {
-                # .info may be empty, so ignore errors (unfortunately)
-                run("cd $cc_dir/info ; lcov -c -d ../../../../$dir --exclude /usr -o app_test_${outname}.info || true");
-                            })->run;
-        }
-        $Fork->wait_all;
-        travis_fold_end();
-    }
-
-    if ($Opt_Stages{6}) {
-        travis_fold_start("clone");
+    if Args.stage_enabled[6]:
+        ci_fold_start("clone")
         # No control file to override single lines, so replicate the sources
         # Also lets us see the insertion markers in the HTML source res
-        print "Stage 6: Clone sources under $cc_dir\n";
-        clone_sources($cc_dir);
-        travis_fold_end();
-    }
+        print("Stage 6: Clone sources under " + cc_dir)
+        clone_sources(cc_dir)
+        ci_fold_end()
 
-    if ($Opt_Stages{8} && !$Opt_Fastcov) {
-        travis_fold_start("copy");
-        print "Stage 8: Copy .gcno files\n";
-        my $dats = `find . -print | grep .gcno`;
-        foreach my $dat (sort (split '\n', $dats)) {
-            next if $dat =~ /$cc_dir/;
-            my $outdat = $cc_dir."/".$dat;
-            #print "cp $dat, $outdat);\n";
-            cp($dat, $outdat);
-        }
-        travis_fold_end();
-    }
+    if Args.stage_enabled[11]:
+        ci_fold_start("dirs")
+        print("Stage 11: Cleanup paths")
+        cleanup_abs_paths_info(cc_dir, cc_dir + "/app_total.info",
+                               cc_dir + "/app_total.info")
+        ci_fold_end()
 
-    if ($Opt_Stages{10} && !$Opt_Fastcov) {
-        travis_fold_start("combine");
-        print "Stage 10: Combine data files\n";
-        {
-            run("cd $cc_dir ; lcov -c -i -d src/obj_dbg -o app_base.info");
-            run("cd $cc_dir ; lcov -a app_base.info -o app_total.info");
-            my $infos = `cd $cc_dir ; find info -print | grep .info`;
-            my $comb = "";
-            my @infos = (sort (split /\n/, $infos));
-            foreach my $info (@infos) {
-                $comb .= " -a $info";
-                # Need to batch them to avoid overrunning shell command length limit
-                if (length($comb) > 10000 || $info eq $infos[$#infos]) {
-                    # .info may be empty, so ignore errors (unfortunately)
-                    run("cd $cc_dir ; lcov -a app_total.info $comb -o app_total.info || true");
-                    $comb = "";
-                }
-            }
-        }
-        travis_fold_end();
-    }
-
-    if ($Opt_Stages{11}) {
-        travis_fold_start("dirs");
-        print "Stage 11: Cleanup paths\n";
-        if ($Opt_Fastcov) {
-            cleanup_abs_paths_info($cc_dir, "$cc_dir/app_total.info", "$cc_dir/app_total.info");
-            #cleanup_abs_paths_json($cc_dir, "$cc_dir/app_total.json", "$cc_dir/app_total.json");
-        } else {
-            cleanup_abs_paths_info($cc_dir, "$cc_dir/app_total.info", "$cc_dir/app_total.info");
-        }
-        travis_fold_end();
-    }
-
-    if ($Opt_Stages{12}) {
-        travis_fold_start("filter");
-        print "Stage 12: Filter processed source files\n";
-        my $inc = '';
-        foreach my $glob (@Source_Globs) {
-            foreach my $infile (glob $glob) {
-                $inc .= " '$infile'";
-            }
-        }
-        my $exc = '';
-        foreach my $glob (@Remove_Sources) {
+    if Args.stage_enabled[12]:
+        ci_fold_start("filter")
+        print("Stage 12: Filter processed source files")
+        inc = ''
+        for globf in Source_Globs:
+            for infile in glob.glob(globf):
+                inc += " '" + infile + "'"
+        exc = ''
+        for globf in Remove_Sources:
             # Fastcov does exact match not globbing at present
             # Lcov requires whole path match so needs the glob
-            $glob =~ s!^\*!! if $Opt_Fastcov;
-            $glob =~ s!\*$!! if $Opt_Fastcov;
-            $exc .= " '$glob'";
-        }
-        if ($Opt_Fastcov) {
-            $inc = "--include ".$inc if $inc ne '';
-            $exc = "--exclude ".$exc if $exc ne '';
-            run("cd $cc_dir ; ${RealBin}/fastcov.py -C app_total.info ${inc} ${exc} -x --lcov -o app_total_f.info");
-        } else {
-            run("cd $cc_dir ; lcov --remove app_total.info $exc -o app_total_f.info");
-        }
-        travis_fold_end();
-    }
+            globf = re.sub(r'^\*', '', globf)
+            globf = re.sub(r'\*$', '', globf)
+            exc += " '" + globf + "'"
+        if inc != '':
+            inc = "--include " + inc
+        if exc != '':
+            exc = "--exclude " + exc
+        run("cd " + cc_dir + " ; " + RealPath +
+            "/fastcov.py -C app_total.info " + inc + " " + exc +
+            " -x --lcov -o app_total_f.info")
+        ci_fold_end()
 
-    if ($Opt_Stages{17}) {
-        travis_fold_start("report");
-        print "Stage 17: Create HTML\n";
-        run("cd $cc_dir ; genhtml app_total_f.info --demangle-cpp"
-            ." --rc lcov_branch_coverage=1 --rc genhtml_hi_limit=100 --output-directory html");
-        travis_fold_end();
-    }
+    if Args.stage_enabled[17]:
+        ci_fold_start("report")
+        print("Stage 17: Create HTML")
+        run("cd " + cc_dir + " ; genhtml app_total_f.info --demangle-cpp" +
+            " --rc lcov_branch_coverage=1 --rc genhtml_hi_limit=100 --output-directory html"
+            )
+        ci_fold_end()
 
-    if ($Opt_Stages{18}) {
-        travis_fold_start("upload");
-        print "Stage 18: Upload\n";
-        my $cmd = "bash <(curl -s https://codecov.io/bash) -f $cc_dir/app_total.info";
-        print "print: Not running: export CODECOV_TOKEN=<hidden>\n";
-        print "print: Not running: $cmd\n";
-        travis_fold_end();
-    }
+    if Args.stage_enabled[18]:
+        ci_fold_start("upload")
+        print("Stage 18: Upload")
+        cmd = "bash <(curl -s https://codecov.io/bash) -f " + cc_dir + "/app_total.info"
+        print("print: Not running: export CODECOV_TOKEN=<hidden>")
+        print("print: Not running: " + cmd)
+        ci_fold_end()
 
-    if ($Opt_Stages{19}) {
-        print "*-* All Finished *-*\n";
-        print "\n";
-        print "* See report in ${cc_dir}/html/index.html\n";
-        print "* Remember to make distclean && ./configure before working on non-coverage\n";
-    }
-}
+    if Args.stage_enabled[19]:
+        print("*-* All Finished *-*")
+        print("")
+        print("* See report in " + cc_dir + "/html/index.html")
+        print(
+            "* Remember to make distclean && ./configure before working on non-coverage"
+        )
 
-sub clone_sources {
-    my $cc_dir = shift;
-    my $excluded_lines = 0;
-    my $excluded_br_lines = 0;
-    foreach my $glob (@Source_Globs) {
-        foreach my $infile (glob $glob) {
-            $infile !~ m!^/!
-                or die "%Error: source globs should be relative not absolute filenames,";
-            my $outfile = $cc_dir."/".$infile;
-            (my $outpath = $outfile) =~ s!/[^/]*$!!;
-            mkpath($outpath);
-            my $fh = IO::File->new("<$infile") or die "%Error: $! $infile,";
-            my $ofh = IO::File->new(">$outfile") or die "%Error: $! $outfile,";
-            my $lineno = 0;
-            while (defined(my $line = $fh->getline)) {
-                $lineno++;
-                chomp $line;
-                if ($line =~ /LCOV_EXCL_LINE/) {
-                    $line .= " LCOV_EXCL_BR_LINE";
-                }
-                elsif ($line =~ /LCOV_EXCL_START/) {
-                    $line .= " LCOV_EXCL_BR_START";
-                }
-                elsif ($line =~ /LCOV_EXCL_STOP/) {
-                    $line .= " LCOV_EXCL_BR_STOP";
-                }
-                elsif ($line =~ /$Exclude_Line_Regexp/) {
-                    $line .= "  //code_coverage: // LCOV_EXCL_LINE LCOV_EXCL_BR_LINE";
-                    $excluded_lines++;
-                    $excluded_br_lines++;
-                    #print "$infile:$lineno: $line";
-                }
-                elsif ($line =~ /$Exclude_Branch_Regexp/) {
-                    $line .= "  //code_coverage: // LCOV_EXCL_BR_LINE";
-                    $excluded_br_lines++;
-                    #print "$infile:$lineno: $line";
-                }
-                $ofh->print("$line\n");
-            }
-        }
-    }
-    print "Number of source lines automatically LCOV_EXCL_LINE'ed: $excluded_lines\n";
-    print "Number of source lines automatically LCOV_EXCL_BR_LINE'ed: $excluded_br_lines\n";
-}
 
-sub cleanup_abs_paths_info {
-    my $cc_dir = shift;
-    my $infile = shift;
-    my $outfile = shift;
-    my $fh = IO::File->new("<$infile") or die "%Error: $! $infile,";
-    my @lines;
-    while (defined(my $line = $fh->getline)) {
-        if ($line =~ m!^SF:!) {
-            $line =~ s!$ENV{VERILATOR_ROOT}/!!;
-            $line =~ s!$cc_dir/!!;
-            $line =~ s!obj_dbg/verilog.y$!verilog.y!;
-            #print "Remaining SF: ",$line;
-        }
-        push @lines, $line;
-    }
-    my $ofh = IO::File->new(">$outfile") or die "%Error: $! $outfile,";
-    $ofh->print(@lines);
-}
+def clone_sources(cc_dir):
+    excluded_lines = 0
+    excluded_br_lines = 0
+    for globf in Source_Globs:
+        for infile in glob.glob(globf):
+            if re.match(r'^/', infile):
+                sys.exit(
+                    "%Error: source globs should be relative not absolute filenames, "
+                    + infile)
+            outfile = cc_dir + "/" + infile
+            outpath = re.sub(r'/[^/]*$', '', outfile, count=1)
+            os.makedirs(outpath, exist_ok=True)
+            with open(infile) as fh:
+                with open(outfile, "w") as ofh:
+                    lineno = 0
+                    for line in fh:
+                        lineno += 1
+                        line = line.rstrip()
+                        done = False
+                        if re.search(r'LCOV_EXCL_LINE', line):
+                            line += " LCOV_EXCL_BR_LINE"
+                            done = True
+                        elif re.search(r'LCOV_EXCL_START', line):
+                            line += " LCOV_EXCL_BR_START"
+                            done = True
+                        elif re.search(r'LCOV_EXCL_STOP', line):
+                            line += " LCOV_EXCL_BR_STOP"
+                            done = True
 
-sub cleanup_abs_paths_json {
-    my $cc_dir = shift;
-    my $infile = shift;
-    my $outfile = shift;
-    # Handcrafted cleanup, alternative would be to deserialize/serialize JSON
-    # But JSON::Parse not installed by default
-    # JSON::PP more likely to be installed, but slower
-    my $fh = IO::File->new("<$infile") or die "%Error: $! $infile,";
-    my @lines;
-    while (defined(my $line = $fh->getline)) {
-        $line =~ s!"$ENV{VERILATOR_ROOT}/!"!g;
-        $line =~ s!"$cc_dir/!"!g;
-        $line =~ s!obj_dbg/verilog.y$!verilog.y!g;
-        push @lines, $line;
-    }
-    my $ofh = IO::File->new(">$outfile") or die "%Error: $! $outfile,";
-    $ofh->print(@lines);
-}
+                        for regexp in Exclude_Line_Regexps:
+                            if done:
+                                break
+                            if re.search(regexp, line):
+                                # print("%s:%d: %s" % (infile, lineno, line)
+                                line += "  //code_coverage: // LCOV_EXCL_LINE LCOV_EXCL_BR_LINE"
+                                excluded_lines += 1
+                                excluded_br_lines += 1
+                                done = True
 
-#######################################################################
+                        for regexp in Exclude_Branch_Regexps:
+                            if done:
+                                break
+                            if re.search(regexp, line):
+                                # print("%s:%d: %s" % (infile, lineno, line)
+                                line += "  //code_coverage: // LCOV_EXCL_BR_LINE"
+                                excluded_br_lines += 1
+                                done = True
+
+                        ofh.write(line + "\n")
+    print("Number of source lines automatically LCOV_EXCL_LINE'ed: %d" %
+          excluded_lines)
+    print("Number of source lines automatically LCOV_EXCL_BR_LINE'ed: %d" %
+          excluded_br_lines)
+
+
+def cleanup_abs_paths_info(cc_dir, infile, outfile):
+    lines = []
+    with open(infile) as fh:
+        for line in fh:
+            if re.search(r'^SF:', line):
+                line = re.sub(os.environ['VERILATOR_ROOT'] + '/',
+                              '',
+                              line,
+                              count=1)
+                line = re.sub(cc_dir + '/', '', line, count=1)
+                line = re.sub(r'obj_dbg/verilog.y$', 'verilog.y', line)
+                # print("Remaining SF: "+line)
+            lines.append(line)
+
+    with open(outfile, "w") as ofh:
+        for line in lines:
+            ofh.write(line)
+
+
+def cleanup_abs_paths_json(cc_dir, infile, outfile):
+    # Handcrafted cleanup, alternative would be to deserialize/serialize JSON,
+    # but this is much faster
+    lines = []
+    with open(infile) as fh:
+        for line in fh:
+            line = re.sub('"' + os.environ['VERILATOR_ROOT'] + '/', '"', line)
+            line = re.sub('"' + cc_dir + '/', '"', line)
+            line = re.sub(r'obj_dbg/verilog.y$', 'verilog.y', line)
+            lines.append(line)
+
+    with open(outfile, "w") as ofh:
+        for line in lines:
+            ofh.write(line)
+
+
+######################################################################
 # .dat file callbacks
 
-sub exclude_branch_regexp {
-    $Exclude_Branch_Regexp = shift;
-}
-sub exclude_line_regexp {
-    $Exclude_Line_Regexp = shift;
-}
-sub remove_gcda_regexp {
-    $Remove_Gcda_Regexp = shift;
-}
-sub remove_source {
-    my @srcs = @_;
-    push @Remove_Sources, @srcs;
-}
-sub source_globs {
-    my @dirs = @_;
-    push @Source_Globs, @dirs;
-}
+
+def exclude_branch_regexp(*regexps):
+    Exclude_Branch_Regexps.extend(regexps)
+
+
+def exclude_line_regexp(*regexps):
+    Exclude_Line_Regexps.extend(regexps)
+
+
+def remove_gcda_regexp(*regexps):
+    Remove_Gcda_Regexps.extend(regexps)
+
+
+def remove_source(*sources):
+    Remove_Sources.extend(sources)
+
+
+def source_globs(*dirs):
+    Source_Globs.extend(dirs)
+
 
 #######################################################################
 
-sub run {
-    # Run a system command, check errors
-    my $command = shift;
-    print "\t$command\n";
-    system "$command";
-    my $status = $?;
-    ($status == 0) or die "%Error: Command Failed $command, $status, stopped";
-}
 
-our $_Travis_Action;
-sub travis_fold_start {
-    $_Travis_Action = shift;
-    print "travis_fold:start:$_Travis_Action\n";
-}
-sub travis_fold_end {
-    print "travis_fold:end:$_Travis_Action\n";
-}
+def run(command):
+    # run a system command, check errors
+    print("\t%s" % command)
+    status = subprocess.call(command, shell=True)
+    if status < 0:
+        raise Exception("%Error: Command failed " + command + ", stopped")
+
+
+def unlink_ok(filename):
+    try:
+        os.unlink(filename)
+    except OSError:
+        pass
+
+
+def ci_fold_start(action):
+    print("::group::" + action, flush=True)
+
+
+def ci_fold_end():
+    print("::endgroup::\n", flush=True)
+
 
 #######################################################################
-__END__
+#######################################################################
 
-=pod
-
-=head1 NAME
-
-code_coverage - Build and collect Verilator coverage
-
-=head1 SYNOPSIS
+parser = argparse.ArgumentParser(
+    allow_abbrev=False,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    description=
+    """code_coverage builds Verilator with C++ coverage support and runs
+tests with coverage enabled. This will rebuild the current object
+files. Run as:
 
   cd $VERILATOR_ROOT
-  nodist/code_coverage
-
-=head1 DESCRIPTION
-
-code_coverage builds Verilator with C++ coverage support and runs tests
-with coverage enabled.
-
-This will rebuild the current object files.
-
-=head1 ARGUMENTS
-
-=over 4
-
-=item --hashset I<hashset>
-
-Pass test hashset onto driver.pl test harness.
-
-=item --help
-
-Displays this message and program version and exits.
-
-=item --scenarios I<scenarios>
-
-Pass test scenarios onto driver.pl test harness.
-
-=item --stages I<stage>
-
-Runs a specific stage or range of stages (see the script).
-
-=item --no-stop
-
-Do not stop collecting data if tests fail.
-
-=item --test I<test_regress_test_name>
-
-Instead of normal regressions, run the specified test.  May be specified
-multiple times for multiple tests.
-
-=back
-
-=head1 DISTRIBUTION
-
-Copyright 2019-2020 by Wilson Snyder. This program is free software; you
+  nodist/code_coverage""",
+    epilog=
+    """Copyright 2019-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
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-=head1 AUTHORS
+parser.add_argument('--debug', action='store_true', help='enable debug')
+parser.add_argument('--hashset',
+                    action='store',
+                    help='pass test hashset onto driver.pl test harness')
+parser.add_argument('--scenarios',
+                    action='store',
+                    help='pass test scenarios onto driver.pl test harness')
+parser.add_argument(
+    '--stages',
+    action='store',
+    help='runs a specific stage or range of stages (see the script)')
+parser.add_argument(
+    '--test',
+    action='append',
+    dest='tests',
+    default=[],
+    help=
+    'Instead of normal regressions, run the specified test(s), may be used multiple times'
+)
+parser.add_argument('--no-stop',
+                    dest='stop',
+                    action='store_false',
+                    help='do not stop collecting data if tests fail')
 
-Wilson Snyder <[email protected]>
+parser.set_defaults(stop=True)
+Args = parser.parse_args()
 
-=head1 SEE ALSO
+if True:
+    start = 0
+    end = 99
+    Args.stage_enabled = {}
+    if Args.stages:
+        match_one = re.match(r'^(\d+)$', Args.stages)
+        match_range = re.match(r'^(\d+)-(\d+)$', Args.stages)
+        match_to = re.match(r'^-(\d+)$', Args.stages)
+        match_from = re.match(r'^(\d+)-$', Args.stages)
+        if match_one:
+            start = end = int(match_one.group(1))
+        elif match_range:
+            start = int(match_range.group(1))
+            end = int(match_range.group(2))
+        elif match_to:
+            end = int(match_to.group(1))
+        elif match_from:
+            start = int(match_from.group(1))
+        else:
+            sys.exit("%Error: --stages not understood: " + Args.stages)
+    for n in range(0, 100):
+        Args.stage_enabled[n] = False
+    for n in range(start, end + 1):
+        Args.stage_enabled[n] = True
 
-C<lcov>
-
-=cut
+test()
 
 ######################################################################
-### Local Variables:
-### compile-command: "cd .. ; nodist/code_coverage "
-### End:
+# Local Variables:
+# compile-command: "cd .. ; nodist/code_coverage "
+# End:

nodist/code_coverage.dat

@@ -1,59 +1,62 @@
-# -*- Perl -*-
+# -*- Python -*-
 # DESCRIPTION: Verilator: Internal C++ code lcov control file
 #
-# Copyright 2019-2020 by Wilson Snyder. This program is free software; you
+# Copyright 2019-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
 
-source_globs("src/*.cpp",
-             "src/*.h",
-             "src/*.l",
-             "src/*.y",
-             "src/obj_dbg/*.h",
-             "src/obj_dbg/*.cpp",
-             "include/*.c",
-             "include/*.cpp",
-             "include/*.h",
-             "include/*/*.h",
-             "include/*/*.cpp",
-             "include/*/*.c",
-    );
+source_globs("src/*.cpp")
+source_globs("src/*.h")
+source_globs("src/*.l")
+source_globs("src/*.y")
+source_globs("src/obj_dbg/*.h")
+source_globs("src/obj_dbg/*.cpp")
+source_globs("include/*.c")
+source_globs("include/*.cpp")
+source_globs("include/*.h")
+source_globs("include/*/*.h")
+source_globs("include/*/*.cpp")
+source_globs("include/*/*.c")
 
 # Note *'s are removed when using fastcov
-remove_source("/usr/*");
-remove_source("*/include/sysc/*");
-remove_source("*/V3ClkGater.cpp");
-remove_source("*/V3ClkGater.h");
-remove_source("*/V3GraphDfa.cpp");
-remove_source("*/V3GraphDfa.h");
-remove_source("*/V3Lexer_pregen.yy.cpp");
-remove_source("*/V3PreLex_pregen.yy.cpp");
-remove_source("*/verilog.c");
-remove_source("*include/gtkwave/*");
+remove_source("/usr/*")
+remove_source("*/include/sysc/*")
+remove_source("*/V3ClkGater.cpp")
+remove_source("*/V3ClkGater.h")
+remove_source("*/V3GraphDfa.cpp")
+remove_source("*/V3GraphDfa.h")
+remove_source("*/V3Lexer_pregen.yy.cpp")
+remove_source("*/V3PreLex_pregen.yy.cpp")
+remove_source("*/verilog.c")
+remove_source("*include/gtkwave/*")
 # Something wrong in generation, unfortunately as would like this
 #genhtml: ERROR: cannot read /svaha/wsnyder/SandBox/homecvs/v4/verilator/src/obj_dbg/verilog.y
-#remove_source("*/src/obj_dbg/verilog.y");
-remove_source("*test_regress/*");
-remove_source("*examples/*");
+#remove_source("*/src/obj_dbg/verilog.y")
+remove_source("*test_regress/*")
+remove_source("*examples/*")
 
 # Remove collected coverage on each little test main file
 # Would just be removed with remove_source in later step
-remove_gcda_regexp(qr!test_regress/.*/(Vt_|Vtop_).*\.gcda!);
+remove_gcda_regexp(r'test_regress/.*/(Vt_|Vtop_).*\.gcda')
 
 # Exclude line entirely, also excludes from function and branch coverage
-exclude_line_regexp(qr/(\bv3fatalSrc\b
-                    |\bfatalSrc\b
-                    |\bVL_UNCOVERABLE\b
-                    |\bVL_FATAL
-                    |\bUASSERT
-                    |\bERROR_RSVD_WORD
-                    |\bV3ERROR_NA
-                    |\bUINFO\b)/x);
+exclude_line_regexp(r'\bv3fatalSrc\b')
+exclude_line_regexp(r'\bfatalSrc\b')
+exclude_line_regexp(r'\bVL_UNCOVERABLE\b')
+exclude_line_regexp(r'\bVL_UNREACHABLE\b')
+exclude_line_regexp(r'\bVL_FATAL')
+exclude_line_regexp(r'\bUASSERT')
+exclude_line_regexp(r'\bNUM_ASSERT')
+exclude_line_regexp(r'\bERROR_RSVD_WORD')
+exclude_line_regexp(r'\bV3ERROR_NA')
+exclude_line_regexp(r'\bUINFO\b')
 
 # Exclude for branch coverage only
-exclude_branch_regexp(qr/(\bdebug\(\)
-                         |\bSELF_CHECK)/x);
+exclude_branch_regexp(r'\bdebug\(\)')
+exclude_branch_regexp(r'\bassert\(')
+exclude_branch_regexp(r'\bBROKEN_RTK\(')
+exclude_branch_regexp(r'\bSELF_CHECK')
 
-1;
+True

nodist/dot_importer

@@ -1,164 +1,110 @@
-#!/usr/bin/env perl
-# See copyright, etc in below POD section.
+#!/usr/bin/env python3
+# pylint: disable=C0103,C0114,C0115,C0116,C0301
 ######################################################################
 
-use warnings;
-use Getopt::Long;
-use IO::File;
-use Pod::Usage;
-use Data::Dumper; $Data::Dumper::Indent=1;
-use strict;
-use vars qw($Debug);
+import argparse
+import re
 
-#======================================================================
+######################################################################
 
-our @Header;
-our %Vertexes;
-our @Edges;
-our %Edges;
+Header = []
+Vertexes = []
+Edges = []
 
-#======================================================================
+#######################################################################
+
+
+def dotread(filename):
+    with open(filename) as fh:
+        header = True
+        vnum = 0
+
+        vertex_re = re.compile(r'^\t([a-zA-Z0-9_]+)\t(.*)$')
+        edge_re = re.compile(
+            r'^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s*(.*)$')
+
+        for line in fh:
+            vertex_match = re.search(vertex_re, line)
+            edge_match = re.search(edge_re, line)
+            if vertex_match:
+                if vertex_match.group(1) != 'nTITLE':
+                    header = False
+                    Vertexes.append({
+                        'num': vnum,
+                        'line': line,
+                        'name': vertex_match.group(1)
+                    })
+                    vnum += 1
+            elif edge_match:
+                fromv = edge_match.group(1)
+                tov = edge_match.group(2)
+                w = re.match(r'weight=(\d+)', line)
+                weight = w.group(1) if w else 1
+                w = re.match(r'style=(\S+)', line)
+                cutable = w.group(1) if w else None
+                edge = {
+                    'num': vnum,
+                    'line': line,
+                    'weight': weight,
+                    'cutable': cutable,
+                    'from': fromv,
+                    'to': tov
+                }
+                vnum += 1
+                Edges.append(edge)
+            elif header:
+                Header.append(line)
+                print("IGNORE: " + line)
+
+
+#######################################################################
+
+
+def cwrite(filename):
+    with open(filename, "w") as fh:
+        fh.write("void V3GraphTestImport::dotImport() {\n")
+        fh.write("    auto* gp = &m_graph;\n")
+        for ver in sorted(Vertexes, key=lambda ver: ver['num']):
+            fh.write(
+                "    auto* %s = new V3GraphTestVertex(gp, \"%s\");  if (%s) {}\n"
+                % (ver['name'], ver['name'], ver['name']))
+        fh.write("\n")
+        for edge in Edges:
+            fh.write("    new V3GraphEdge(gp, %s, %s, %s, %s);\n" %
+                     (edge['from'], edge['to'], edge['weight'],
+                      "true" if edge['cutable'] else "false"))
+        fh.write("}\n")
+
+
+######################################################################
 # main
 
-$Debug = 0;
-my $opt_filename;
-autoflush STDOUT 1;
-autoflush STDERR 1;
-if (! GetOptions(
-          "help"        => \&usage,
-          "debug"       => \&debug,
-          "<>"          => \&parameter,
-    )) {
-    usage();
-}
-
-dotread($opt_filename);
-cwrite("graph_export.cpp");
-
-#----------------------------------------------------------------------
-
-sub usage {
-    pod2usage(-verbose=>2, -exitval=>0, -output=>\*STDOUT);
-    exit(1);  # Unreachable
-}
-
-sub debug {
-    $Debug = 1;
-}
-
-sub parameter {
-    my $param = shift;
-    if (!$opt_filename) {
-        $opt_filename = $param;
-    } else {
-        die "%Error: Unknown parameter: $param\n";
-    }
-}
-
-#######################################################################
-
-sub dotread {
-    my $filename = shift;
-
-    my $fh = IO::File->new($filename) or die "%Error: $! $filename,";
-    my $header = 1;
-    my $vnum = 0;
-    while (defined (my $line = $fh->getline)) {
-        if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
-            next if $1 eq 'nTITLE';
-            $header = 0;
-            $Vertexes{$1} = {num => $vnum++,
-                             line => $line,
-                             name => $1,};
-        }
-        elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
-            my $from=$1; my $to=$2;
-            my $weight = 1; $weight = $1 if $line =~ /weight=(\d+)/;
-            my $cutable = undef; $cutable = $1 if $line =~ /style=(\S+)/;
-            my $edge =  {num => $vnum++,
-                         line => $line,
-                         weight => $weight,
-                         cutable => $cutable,
-                         from => $from,
-                         to => $to,};
-            push @Edges, $edge;
-            $Edges{$from}{$to} = $edge;
-        }
-        elsif ($header) {
-            push @Header, $line;
-            print "IGNORE: $line";
-        }
-    }
-}
-
-#######################################################################
-
-sub cwrite {
-    my $filename = shift;
-
-    my $fh = IO::File->new(">$filename") or die "%Error: $! $filename,";
-    $fh->print("void V3GraphTestImport::dotImport() {\n");
-    $fh->print("    DfaGraph* gp = &m_graph;\n");
-    foreach my $ver (sort {$a->{num} <=> $b->{num}} (values %Vertexes)) {
-        $fh->printf("    V3GraphTestVertex* %s = new V3GraphTestVertex(gp, \"%s\");  if (%s) {}\n",
-                    $ver->{name}, $ver->{name}, $ver->{name});
-    }
-    $fh->print("\n");
-    foreach my $edge (@Edges) {
-        $fh->printf("    new V3GraphEdge(gp, %s, %s, %s, %s);\n",
-                    $edge->{from}, $edge->{to},
-                    $edge->{weight}, $edge->{cutable}?"true":"false");
-    }
-    $fh->print("}\n");
-}
-
-#######################################################################
-__END__
-
-=pod
-
-=head1 NAME
-
-dot_importer - Take graph .dot file and convert into .cpp file
-
-=head1 SYNOPSIS
-
-  dot_importer a.dot
-
-=head1 DESCRIPTION
-
-Dot_importer takes a graphvis .dot file and converts into .cpp file.  This
-.cpp file is then manually included in V3GraphTest.cpp to verify various
-sub-algorithms.
-
-=head1 ARGUMENTS
-
-=over 4
-
-=item --help
-
-Displays this message and program version and exits.
-
-=back
-
-=head1 DISTRIBUTION
-
-Copyright 2005-2020 by Wilson Snyder. This program is free software; you
+parser = argparse.ArgumentParser(
+    allow_abbrev=False,
+    formatter_class=argparse.RawDescriptionHelpFormatter,
+    description=
+    """dot_importer takes a graphvis .dot file and converts into .cpp file.
+This x.cpp file is then manually included in V3GraphTest.cpp to verify
+various xsub-algorithms.""",
+    epilog=
+    """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.
 
-SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
-=head1 AUTHORS
+parser.add_argument('--debug',
+                    action='store_const',
+                    const=9,
+                    help='enable debug')
+parser.add_argument('filename', help='input .dot filename to process')
 
-Wilson Snyder <[email protected]>
-
-=head1 SEE ALSO
-
-=cut
+Args = parser.parse_args()
+dotread(Args.filename)
+cwrite("graph_export.cpp")
 
 ######################################################################
-### Local Variables:
-### compile-command: "./dot_importer | tee ~/d/a.dot"
-### End:
+# Local Variables:
+# compile-command: "./dot_importer ../test_regress/obj_vlt/t_EXAMPLE/*orderg_o*.dot && cat graph_export.cpp"
+# End:

nodist/dot_pruner

@@ -1,205 +0,0 @@
-#!/usr/bin/env perl
-# See copyright, etc in below POD section.
-######################################################################
-
-use warnings;
-use Getopt::Long;
-use IO::File;
-use Pod::Usage;
-use Data::Dumper; $Data::Dumper::Indent=1;
-use strict;
-use vars qw($Debug);
-
-#======================================================================
-
-our @Header;
-our %Vertexes;
-our %Edges;
-our %User;
-our %User2;
-
-#======================================================================
-# main
-
-$Debug = 0;
-my $opt_filename;
-my $opt_circle;
-autoflush STDOUT 1;
-autoflush STDERR 1;
-if (! GetOptions(
-          "help"        => \&usage,
-          "debug"       => \&debug,
-          "<>"          => \&parameter,
-          "circle=s"    => \$opt_circle,
-    )) {
-    usage();
-}
-
-dotread($opt_filename);
-circle($opt_circle) if $opt_circle;
-simplify();
-dotwrite();
-
-#----------------------------------------------------------------------
-
-sub usage {
-    pod2usage(-verbose=>2, -exitval=>0, -output=>\*STDOUT);
-    exit(1);  # Unreachable
-}
-
-sub debug {
-    $Debug = 1;
-}
-
-sub parameter {
-    my $param = shift;
-    if (!$opt_filename) {
-        $opt_filename = $param;
-    } else {
-        die "%Error: Unknown parameter: $param\n";
-    }
-}
-
-#######################################################################
-
-sub dotread {
-    my $filename = shift;
-
-    my $fh = IO::File->new($filename) or die "%Error: $! $filename,";
-    my $header = 1;
-    while (defined (my $line = $fh->getline)) {
-        if ($line =~ /^\t([a-zA-Z0-9_]+)\t(.*)$/) {
-            $header = 0;
-            $Vertexes{$1} = $2;
-        }
-        elsif ($line =~ /^\t([a-zA-Z0-9_]+)\s+->\s+([a-zA-Z0-9_]+)\s+(.*)$/) {
-            $Edges{$1}{$2} = $3;
-        }
-        elsif ($header) {
-            push @Header, $line;
-        }
-    }
-}
-
-######################################################################
-
-sub simplify {
-    foreach my $ver (sort (keys %Vertexes)) {
-        $Vertexes{$ver} = _simplify($Vertexes{$ver});
-    }
-    foreach my $v1 (sort (keys %Edges)) {
-        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-            $Edges{$v1}{$v2} = _simplify($Edges{$v1}{$v2});
-        }
-    }
-}
-
-sub _simplify {
-    my $text = shift;
-    $text =~ s/__DOT__/./g;
-    return $text;
-}
-
-
-sub dotwrite {
-    foreach my $line (@Header) {
-        print "$line";
-    }
-    foreach my $ver (sort (keys %Vertexes)) {
-        print "\t$ver\t$Vertexes{$ver}\n";
-    }
-    foreach my $v1 (sort (keys %Edges)) {
-        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-            print "\t$v1 -> $v2\t$Edges{$v1}{$v2}\n";
-        }
-    }
-    print "}\n";
-}
-
-######################################################################
-
-sub circle {
-    my $node = shift;
-    %User = ();
-    %User2 = ();
-    _circle_recurse($node, 1);
-
-    foreach my $ver (keys %Vertexes) {
-        if (!$User{$ver}) {
-            delete $Vertexes{$ver};
-            delete $Edges{$ver};
-        }
-    }
-    foreach my $v1 (sort (keys %Edges)) {
-        foreach my $v2 (sort (keys %{$Edges{$v1}})) {
-            if (!$Vertexes{$v2}) { delete $Edges{$v1}{$v2}; }
-        }
-    }
-}
-
-sub _circle_recurse {
-    my $node = $_[0];
-    my $level = $_[1];
-    $Vertexes{$node} or warn "%Warning: Can't find ref node $node\n";
-
-    $User{$node} = 1 if (($User2{$node}||0)==1);
-    return $User{$node} if $User2{$node};
-
-    $User2{$node} = 1;
-    my $r = 0;
-    foreach my $v2 (keys %{$Edges{$node}}) {
-        $r |= _circle_recurse($v2,$level++)||0;
-    }
-    $User{$node} = 1 if $r;
-    $User2{$node} = 2;
-    return $r;
-}
-
-#######################################################################
-__END__
-
-=pod
-
-=head1 NAME
-
-dot_pruner -
-
-=head1 SYNOPSIS
-
-  dot_pruner *.log
-
-=head1 DESCRIPTION
-
-dd
-
-=head1 ARGUMENTS
-
-=over 4
-
-=item --help
-
-Displays this message and program version and exits.
-
-=back
-
-=head1 DISTRIBUTION
-
-Copyright 2005-2020 by Wilson Snyder. This program is free software; you
-can redistribute it and/or modify it under the terms of either the GNU
-Lesser General Public License Version 3 or the Perl Artistic License
-Version 2.0.
-
-SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-
-=head1 AUTHORS
-
-Wilson Snyder <[email protected]>
-
-=head1 SEE ALSO
-
-=cut
-
-######################################################################
-### Local Variables:
-### compile-command: "./dot_pruner | tee ~/d/a.dot"
-### End: