Version bump

First half of #6301

.bake.toml

@@ -0,0 +1,30 @@
+# mbake configuration file
+
+[formatter]
+# Indentation settings
+use_tabs = true
+tab_width = 2
+
+# Spacing settings
+space_around_assignment = true
+space_before_colon = false
+space_after_colon = true
+
+# Line continuation settings
+normalize_line_continuations = true
+max_line_length = 100
+
+# PHONY settings
+group_phony_declarations = false
+phony_at_top = false
+auto_insert_phony_declarations = false
+
+# General settings
+remove_trailing_whitespace = true
+ensure_final_newline = true
+normalize_empty_lines = true
+max_consecutive_empty_lines = 2
+
+# Global settings
+debug = false
+verbose = false

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,7 +9,7 @@ assignees: ''
 
 Thanks for taking the time to report this.
 
-Can you attach an example that shows the issue?  (Must be openly licensed, completely self-contaned so can directly run what you provide. Ideally use test_regress format, see https://veripool.org/guide/latest/contributing.html?highlight=test_regress#reporting-bugs
+Can you attach an example that shows the issue?  (Must be openly licensed, completely self-contained and self-checking so can directly run what you provide. Ideally use test_regress format, see https://veripool.org/guide/latest/contributing.html?highlight=test_regress#reporting-bugs
 
 What 'verilator' command line do we use to run your example?
 

.github/ISSUE_TEMPLATE/feature.md

@@ -13,6 +13,6 @@ What would you like added/supported?
 
 What 'verilator --version' are you using?  Did you try it with the git master version?
 
-Can you attach an example that runs on other simulators?  (Must be openly licensed, ideally in test_regress format.)
+Can you attach an example that runs on other simulators?  (Must be openly licensed, completely self-contained and self-checking so can directly run what you provide. Ideally use test_regress format, see https://veripool.org/guide/latest/contributing.html?highlight=test_regress#reporting-bugs
 
 May we assist you in trying to fix this in Verilator yourself?

.github/workflows/build.yml

@@ -12,14 +12,8 @@ on:
   schedule:
     - cron: '0 0 * * 0'  # weekly
 
-env:
-  CI_OS_NAME: linux
-  CI_COMMIT: ${{ github.sha }}
-  CCACHE_COMPRESS: 1
-  CCACHE_DIR: ${{ github.workspace }}/.ccache
-  CCACHE_LIMIT_MULTIPLE: 0.95
-  INSTALL_DIR: ${{ github.workspace }}/install
-  RELOC_DIR: ${{ github.workspace }}/relloc
+permissions:
+  contents: read
 
 defaults:
   run:
@@ -27,139 +21,160 @@ defaults:
     working-directory: repo
 
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
+  group: ${{ github.workflow }}-${{ github.actor }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
   cancel-in-progress: true
 
 jobs:
 
-  build:
+  build-2404-gcc:
+    name: Build
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-24.04, ubuntu-22.04, ubuntu-20.04]
-        compiler:
-          - {cc: clang, cxx: clang++}
-          - {cc: gcc, cxx: g++}
         include:
-          # Build GCC 10 on ubuntu-20.04
-          - os: ubuntu-20.04
-            compiler: {cc: gcc-10, cxx: g++-10}
-    runs-on: ${{ matrix.os }}
-    name: Build | ${{ matrix.os }} | ${{ matrix.compiler.cc }}
-    env:
-      CI_BUILD_STAGE_NAME: build
-      CI_RUNS_ON: ${{ matrix.os }}
-      CC: ${{ matrix.compiler.cc }}
-      CXX: ${{ matrix.compiler.cxx }}
-      CACHE_BASE_KEY: build-${{ matrix.os }}-${{ matrix.compiler.cc }}
-      CCACHE_MAXSIZE: 1000M  # Per build matrix entry (* 5 = 5000M in total)
-      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}.tar.gz
-    steps:
+          - {os: ubuntu-24.04, cc: gcc}
 
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          path: repo
-
-      - name: Cache $CCACHE_DIR
-        uses: actions/cache@v4
-        env:
-          CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ${{ env.CACHE_KEY }}-${{ github.sha }}
-          restore-keys: |
-            ${{ env.CACHE_KEY }}-
-
-      - name: Install packages for build
-        run: ./ci/ci-install.bash
-
-      - name: Build
-        run: ./ci/ci-script.bash
-
-      - name: Tar up repository
-        working-directory: ${{ github.workspace }}
-        run: tar --posix -c -z -f ${{ env.VERILATOR_ARCHIVE }} repo
-
-      - name: Upload tar archive
-        uses: actions/upload-artifact@v4
-        with:
-          path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
-          name: ${{ env.VERILATOR_ARCHIVE }}
-
-  test:
-    needs: build
+  build-2404-clang:
+    name: Build
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-22.04, ubuntu-20.04]
-        compiler:
-          - {cc: clang, cxx: clang++}
-          - {cc: gcc, cxx: g++}
-        reloc: [0]
-        suite: [dist-vlt-0, dist-vlt-1, dist-vlt-2, dist-vlt-3, vltmt-0, vltmt-1]
         include:
-          # Test with GCC 10 on ubuntu-20.04, also test relocation
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: dist-vlt-0}
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: dist-vlt-1}
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: dist-vlt-2}
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: dist-vlt-3}
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: vltmt-0}
-          - {os: ubuntu-20.04, compiler: {cc: gcc-10, cxx: g++-10}, reloc: 1, suite: vltmt-1}
-          # Ubuntu 24.04 only on GCC; not passing on clang yet
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: dist-vlt-0}
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: dist-vlt-1}
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: dist-vlt-2}
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: dist-vlt-3}
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: vltmt-0}
-          - {os: ubuntu-24.04, compiler: {cc: gcc, cxx: g++}, suite: vltmt-1}
-    runs-on: ${{ matrix.os }}
-    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
-    env:
-      CI_BUILD_STAGE_NAME: test
-      CI_RUNS_ON: ${{ matrix.os }}
-      CI_RELOC: ${{ matrix.reloc }}
-      CC: ${{ matrix.compiler.cc }}
-      CXX: ${{ matrix.compiler.cxx }}
-      CACHE_BASE_KEY: test-${{ matrix.os }}-${{ matrix.compiler.cc }}-${{ matrix.reloc }}-${{ matrix.suite }}
-      CCACHE_MAXSIZE: 100M  # Per build per suite (* 5 * 5 = 2500M in total)
-      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}.tar.gz
-    steps:
+          - {os: ubuntu-24.04, cc: clang}
 
-      - name: Download tar archive
-        uses: actions/download-artifact@v4
-        with:
-          name: ${{ env.VERILATOR_ARCHIVE }}
-          path: ${{ github.workspace }}
+  build-2204-gcc:
+    name: Build
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-22.04, cc: gcc}
 
-      - name: Unpack tar archive
-        working-directory: ${{ github.workspace }}
-        run: tar -x -z -f ${{ env.VERILATOR_ARCHIVE }}
+  build-2204-clang:
+    name: Build
+    uses: ./.github/workflows/reusable-build.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {os: ubuntu-22.04, cc: clang}
 
-      - name: Cache $CCACHE_DIR
-        uses: actions/cache@v4
-        env:
-          CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache2
-        with:
-          path: ${{ env.CCACHE_DIR }}
-          key: ${{ env.CACHE_KEY }}-${{ github.sha }}
-          restore-keys: |
-            ${{ env.CACHE_KEY }}-
+  test-2404-gcc:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }}
+    needs: build-2404-gcc
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Ubuntu 24.04 gcc
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: dist-vlt-0}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: dist-vlt-1}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: dist-vlt-2}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: dist-vlt-3}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: vltmt-0}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: vltmt-1}
+          - {os: ubuntu-24.04, cc: gcc, reloc: 0, suite: vltmt-2}
 
-      - name: Install test dependencies
-        run: ./ci/ci-install.bash
+  test-2404-clang:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }}
+    needs: build-2404-clang
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Ubuntu 24.04 clang
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: dist-vlt-0}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: dist-vlt-1}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: dist-vlt-2}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: dist-vlt-3}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: vltmt-0}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: vltmt-1}
+          - {os: ubuntu-24.04, cc: clang, reloc: 0, suite: vltmt-2}
 
-      - name: Test
-        env:
-          TESTS: ${{ matrix.suite }}
-        run: ./ci/ci-script.bash
+  test-2204-gcc:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }}
+    needs: build-2204-gcc
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Ubuntu 22.04 gcc
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: dist-vlt-0}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: dist-vlt-1}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: dist-vlt-2}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: dist-vlt-3}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: vltmt-0}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: vltmt-1}
+          - {os: ubuntu-22.04, cc: gcc, reloc: 0, suite: vltmt-2}
+
+  test-2204-clang:
+    name: Test | ${{ matrix.os }} | ${{ matrix.cc }}
+    needs: build-2204-clang
+    uses: ./.github/workflows/reusable-test.yml
+    with:
+      os: ${{ matrix.os }}
+      cc: ${{ matrix.cc }}
+      reloc: ${{ matrix.reloc }}
+      suite: ${{ matrix.suite }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Ubuntu 22.04 clang, also test relocation
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: dist-vlt-0}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: dist-vlt-1}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: dist-vlt-2}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: dist-vlt-3}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: vltmt-0}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: vltmt-1}
+          - {os: ubuntu-22.04, cc: clang, reloc: 1, suite: vltmt-2}
 
   lint-py:
     runs-on: ubuntu-22.04
     name: Lint Python
     env:
+      CI_OS_NAME: linux
+      CI_COMMIT: ${{ github.sha }}
       CI_BUILD_STAGE_NAME: build
       CI_RUNS_ON: ubuntu-22.04
+      CCACHE_COMPRESS: 1
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+      CCACHE_LIMIT_MULTIPLE: 0.95
+    strategy:
+      fail-fast: false
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/contributor.yml

@@ -7,10 +7,12 @@ on:
   push:
   pull_request:
   workflow_dispatch:
+permissions:
+  contents: read
 jobs:
   Test:
     name: "'docs/CONTRIBUTORS' was signed"
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
       - run: test_regress/t/t_dist_contributors.py

.github/workflows/coverage.yml

@@ -9,6 +9,9 @@ on:
   schedule:
     - cron: '0 0 * * 0'  # weekly
 
+permissions:
+  contents: read
+
 env:
   CI_OS_NAME: linux
   CI_COMMIT: ${{ github.sha }}
@@ -23,10 +26,12 @@ defaults:
 jobs:
 
   Build:
-    runs-on: ubuntu-22.04
+    # Only run scheduled jobs if explicitly enabled for that repo (e.g.: not on forks)
+    if: ${{ github.event_name != 'schedule' || vars.ENABLE_SCHEDULED_JOBS == 'true' }}
+    runs-on: ubuntu-24.04
     env:
       CI_BUILD_STAGE_NAME: build
-      CI_RUNS_ON: ubuntu-22.04
+      CI_RUNS_ON: ubuntu-24.04
     steps:
 
       - name: Checkout
@@ -59,11 +64,11 @@ jobs:
         num: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
         include:
           - {test: dist, num: ''}
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     name: test-${{ matrix.test }}${{ matrix.num }}
     env:
       CI_BUILD_STAGE_NAME: test
-      CI_RUNS_ON: ubuntu-22.04
+      CI_RUNS_ON: ubuntu-24.04
     steps:
 
       - name: Download tar archive

.github/workflows/docker.yml

@@ -22,11 +22,14 @@ on:
         type: boolean
         default: false
 
+permissions:
+  contents: write
+
 jobs:
 
   build:
 
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
 
     strategy:
       matrix:
@@ -76,11 +79,11 @@ jobs:
 
       - name: Build and Push to Docker
         uses: docker/build-push-action@v4
-        if: startsWith(github.ref, 'refs/tags/v')
+        if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch'
         with:
           context: ${{ env.build_context }}
           build-args: SOURCE_COMMIT=${{ env.git_tag }}
           platforms: linux/arm64,linux/amd64
-          push: ${{ !env.ACT && startsWith(github.ref, 'refs/tags/v') }}
+          push: ${{ !env.ACT && (startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch') }}
           tags: ${{ steps.docker_meta.outputs.tags }}
           labels: ${{ steps.docker_meta.outputs.labels }}

.github/workflows/format.yml

@@ -7,13 +7,15 @@ on:
   push:
   pull_request_target:
   workflow_dispatch:
+permissions:
+  contents: write
 jobs:
   format:
-    runs-on: ubuntu-22.04
-    name: Ubuntu 22.04 | format
+    runs-on: ubuntu-24.04
+    name: Ubuntu 24.04 | format
     env:
       CI_OS_NAME: linux
-      CI_RUNS_ON: ubuntu-22.04
+      CI_RUNS_ON: ubuntu-24.04
       CI_COMMIT: ${{ github.sha }}
     steps:
       - name: Checkout
@@ -25,14 +27,15 @@ jobs:
           CI_BUILD_STAGE_NAME: build
         run: |
           bash ci/ci-install.bash &&
-          sudo apt-get install clang-format-14 yapf3 &&
+          sudo apt-get install clang-format-18 yapf3 &&
+          sudo pip3 install gersemi mbake &&
           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-14 &&
+          make -j 2 format CLANGFORMAT=clang-format-18 &&
           git status
       - name: Push
         run: |

.github/workflows/msbuild.yml

@@ -10,6 +10,8 @@ on:
   workflow_dispatch:
   schedule:
     - cron: 0 0 * * 0  # weekly
+permissions:
+  contents: read
 env:
   CI_OS_NAME: win
   CI_COMMIT: ${{ github.sha }}
@@ -20,12 +22,12 @@ defaults:
   run:
     working-directory: repo
 concurrency:
-  group: ${{ github.workflow }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
+  group: ${{ github.workflow }}-${{ github.actor }}-${{ github.event_name == 'pull_request' && github.ref || github.run_id }}
   cancel-in-progress: true
 jobs:
   windows:
     name: run on windows
-    runs-on: windows-latest
+    runs-on: windows-2025
     steps:
       - uses: actions/checkout@v4
         with:

.github/workflows/reusable-build.yml

@@ -0,0 +1,75 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-build
+
+on:
+  workflow_call:
+    inputs:
+      os:  # e.g. ubuntu-24.04
+        required: true
+        type: string
+      cc:  # gcc or clang
+        required: true
+        type: string
+
+env:
+  CI_OS_NAME: linux
+  CI_COMMIT: ${{ github.sha }}
+  CCACHE_COMPRESS: 1
+  CCACHE_DIR: ${{ github.workspace }}/.ccache
+  CCACHE_LIMIT_MULTIPLE: 0.95
+  INSTALL_DIR: ${{ github.workspace }}/install
+  RELOC_DIR: ${{ github.workspace }}/relloc
+
+defaults:
+  run:
+    shell: bash
+    working-directory: repo
+
+jobs:
+
+  build:
+    runs-on: ${{ inputs.os }}
+    name: Sub-build | ${{ inputs.os }} | ${{ inputs.cc }}
+    env:
+      CI_BUILD_STAGE_NAME: build
+      CI_RUNS_ON: ${{ inputs.os }}
+      CC: ${{ inputs.cc }}
+      CXX: ${{ inputs.cc == 'clang' && 'clang++' || 'g++' }}
+      CACHE_BASE_KEY: build-${{ inputs.os }}-${{ inputs.cc }}
+      CCACHE_MAXSIZE: 1000M  # Per build matrix entry (* 5 = 5000M in total)
+      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ inputs.os }}-${{ inputs.cc }}.tar.gz
+    steps:
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: repo
+
+      - name: Cache $CCACHE_DIR
+        uses: actions/cache@v4
+        env:
+          CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ${{ env.CACHE_KEY }}-${{ github.sha }}
+          restore-keys: |
+            ${{ env.CACHE_KEY }}-
+
+      - name: Install packages for build
+        run: ./ci/ci-install.bash
+
+      - name: Build
+        run: ./ci/ci-script.bash
+
+      - name: Tar up repository
+        working-directory: ${{ github.workspace }}
+        run: tar --posix -c -z -f ${{ env.VERILATOR_ARCHIVE }} repo
+
+      - name: Upload tar archive
+        uses: actions/upload-artifact@v4
+        with:
+          path: ${{ github.workspace }}/${{ env.VERILATOR_ARCHIVE }}
+          name: ${{ env.VERILATOR_ARCHIVE }}

.github/workflows/reusable-rtlmeter-build.yml

@@ -0,0 +1,72 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-rtlmeter-build
+
+on:
+  workflow_call:
+    inputs:
+      runs-on:
+        description: "Runner to use, e.g.: ubuntu-24.04"
+        type: string
+        required: true
+      cc:
+        description: "Compiler to use: 'gcc' or 'clang'"
+        type: string
+        required: true
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  CCACHE_DIR: ${{ github.workspace }}/ccache
+  CCACHE_MAXSIZE: 512M
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runs-on }}
+    name: Build
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt install ccache mold help2man libfl-dev libgoogle-perftools-dev libsystemc-dev
+
+      - name: Use saved ccache
+        uses: actions/cache@v4
+        with:
+          path: ccache
+          key: rtlmeter-build-ccache-${{ inputs.runs-on }}-${{ inputs.cc }}-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: rtlmeter-build-ccache-${{ inputs.runs-on }}-${{ inputs.cc }}
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: repo
+          fetch-depth: 0 # Required for 'git describe' used for 'verilator --version'
+
+      - name: Configure
+        working-directory: repo
+        run: |
+          autoconf
+          ./configure --prefix=${{ github.workspace }}/install CXX=${{ inputs.cc == 'clang' && 'clang++' || 'g++' }}
+
+      - name: Make
+        working-directory: repo
+        run: make -j $(nproc)
+
+      - name: Install
+        working-directory: repo
+        run: make install
+
+      - name: Tar up installation
+        run: tar --posix -c -z -f verilator-rtlmeter.tar.gz install
+
+      - name: Upload Verilator installation archive
+        uses: actions/upload-artifact@v4
+        with:
+          path: verilator-rtlmeter.tar.gz
+          name: verilator-rtlmeter-${{ inputs.runs-on }}-${{ inputs.cc }}
+          overwrite: true

.github/workflows/reusable-rtlmeter-run.yml

@@ -0,0 +1,128 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-rtlmeter-run
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        description: "Unique identifier for storing results"
+        type: string
+        required: true
+      runs-on:
+        description: "Runner to use, e.g.: ubuntu-24.04"
+        type: string
+        required: true
+      cc:
+        description: "Compiler to use: 'gcc' or 'clang'"
+        type: string
+        required: true
+      # Note: The combination of 'cases' and 'run-name' must be unique for all
+      # invocations of this workflow within a run of the parent workflow.
+      # These two are used together to generate a unique results file name.
+      cases:
+        description: "RTLMeter cases to run"
+        type: string
+        required: true
+      run-name:
+        description: "Run name (identifier) to add to collated results"
+        type: string
+        required: true
+      compileArgs:
+        description: "Additional Verilator command line arguments"
+        type: string
+        default: ""
+      executeArgs:
+        description: "Additional simulator command line arguments"
+        type: string
+        default: ""
+
+defaults:
+  run:
+    shell: bash
+
+env:
+  CCACHE_DIR: ${{ github.workspace }}/ccache
+  CCACHE_MAXSIZE: 512M
+  CCACHE_DISABLE: 1
+
+jobs:
+  run:
+    runs-on: ${{ inputs.runs-on }}
+    name: Run
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt install ccache mold libfl-dev libgoogle-perftools-dev libsystemc-dev
+
+      - name: Download Verilator installation archive
+        uses: actions/download-artifact@v4
+        with:
+          name: verilator-rtlmeter-${{ inputs.runs-on }}-${{ inputs.cc }}
+
+      - name: Unpack Verilator installation archive
+        run: |
+          tar -x -z -f verilator-rtlmeter.tar.gz
+          echo "${{ github.workspace }}/install/bin" >> $GITHUB_PATH
+
+      - name: Use saved ccache
+        if: ${{ env.CCACHE_DISABLE == 0 }}
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: rtlmeter-run-ccache-${{ inputs.runs-on }}-${{ inputs.cc }}-${{ inputs.cases }}-${{ inputs.compileArgs }}-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: rtlmeter-run-ccache-${{ inputs.runs-on }}-${{ inputs.cc }}-${{ inputs.cases }}-${{ inputs.compileArgs }}
+
+      - name: Checkout RTLMeter
+        uses: actions/checkout@v4
+        with:
+          repository: "verilator/rtlmeter"
+          path: rtlmeter
+
+      - name: Setup RTLMeter venv
+        working-directory: rtlmeter
+        run: make venv
+
+      - name: Compile cases
+        working-directory: rtlmeter
+        run: |
+          ./rtlmeter run --verbose --cases='${{ inputs.cases }}' --compileArgs='${{ inputs.compileArgs }}' --executeArgs='${{ inputs.executeArgs }}' --nExecute=0
+          # My YAML highlighter sucks, so I put this comment here wiht a phony closing quote mark to make it work: '
+
+      - name: Execute cases
+        working-directory: rtlmeter
+        continue-on-error: true  # Do not fail on error, so we can at leat save the successful results
+        run: |
+          ./rtlmeter run --verbose --cases='${{ inputs.cases }}' --compileArgs='${{ inputs.compileArgs }}' --executeArgs='${{ inputs.executeArgs }}'
+          # My YAML highlighter sucks, so I put this comment here wiht a phony closing quote mark to make it work: '
+
+      - name: Collate results
+        id: results
+        working-directory: rtlmeter
+        run: |
+          # Use 'inputs.cases' and 'inputs.run-name' to generate a unique file name
+          hash=$(md5sum <<< '${{ inputs.cases }} ${{ inputs.run-name }}' | awk '{print $1}')
+          echo "hash=${hash}" >> $GITHUB_OUTPUT
+          ./rtlmeter collate --runName "${{ inputs.run-name }}"  > ../results-${hash}.json
+
+      - name: Report results
+        working-directory: rtlmeter
+        run: |
+          ./rtlmeter report --steps '*' --metrics '*' ../results-${{ steps.results.outputs.hash }}.json
+
+      - name: Upload results
+        uses: actions/upload-artifact@v4
+        with:
+          path: results-${{ steps.results.outputs.hash }}.json
+          name: rtlmeter-results-${{ inputs.tag }}-${{ steps.results.outputs.hash }}
+          overwrite: true
+          retention-days: 2
+
+      - name: Report status
+        working-directory: rtlmeter
+        run: | # This will fail the job if any of the runs failed
+          ./rtlmeter run --verbose --cases='${{ inputs.cases }}' --compileArgs='${{ inputs.compileArgs }}' --executeArgs='${{ inputs.executeArgs }}'
+          # My YAML highlighter sucks, so I put this comment here wiht a phony closing quote mark to make it work: '

.github/workflows/reusable-test.yml

@@ -0,0 +1,79 @@
+---
+# DESCRIPTION: Github actions config
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+name: reusable-test
+
+on:
+  workflow_call:
+    inputs:
+      os:  # e.g. ubuntu-24.04
+        required: true
+        type: string
+      cc:  # gcc or clang
+        required: true
+        type: string
+      reloc:  # 0 or 1
+        required: true
+        type: number
+      suite:  # e.g. dist-vlt-0
+        required: true
+        type: string
+
+env:
+  CI_OS_NAME: linux
+  CI_COMMIT: ${{ github.sha }}
+  CCACHE_COMPRESS: 1
+  CCACHE_DIR: ${{ github.workspace }}/.ccache
+  CCACHE_LIMIT_MULTIPLE: 0.95
+  INSTALL_DIR: ${{ github.workspace }}/install
+  RELOC_DIR: ${{ github.workspace }}/relloc
+
+defaults:
+  run:
+    shell: bash
+    working-directory: repo
+
+jobs:
+
+  test:
+    runs-on: ${{ inputs.os }}
+    name: Sub-test | ${{ inputs.os }} | ${{ inputs.cc }} | ${{inputs.reloc && 'reloc | ' || '' }} ${{ inputs.suite }}
+    env:
+      CI_BUILD_STAGE_NAME: test
+      CI_RUNS_ON: ${{ inputs.os }}
+      CI_RELOC: ${{inputs.reloc }}
+      CC: ${{ inputs.cc }}
+      CXX: ${{ inputs.cc == 'clang' && 'clang++' || 'g++' }}
+      CACHE_BASE_KEY: test-${{ inputs.os }}-${{ inputs.cc }}-${{inputs.reloc }}-${{ inputs.suite }}
+      CCACHE_MAXSIZE: 100M  # Per build per suite (* 5 * 5 = 2500M in total)
+      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ inputs.os }}-${{ inputs.cc }}.tar.gz
+    steps:
+
+      - name: Download tar archive
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ env.VERILATOR_ARCHIVE }}
+          path: ${{ github.workspace }}
+
+      - name: Unpack tar archive
+        working-directory: ${{ github.workspace }}
+        run: tar -x -z -f ${{ env.VERILATOR_ARCHIVE }}
+
+      - name: Cache $CCACHE_DIR
+        uses: actions/cache@v4
+        env:
+          CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache2
+        with:
+          path: ${{ env.CCACHE_DIR }}
+          key: ${{ env.CACHE_KEY }}-${{ github.sha }}
+          restore-keys: |
+            ${{ env.CACHE_KEY }}-
+
+      - name: Install test dependencies
+        run: ./ci/ci-install.bash
+
+      - name: Test
+        env:
+          TESTS: ${{ inputs.suite }}
+        run: ./ci/ci-script.bash

.github/workflows/rtlmeter.yml

@@ -0,0 +1,322 @@
+---
+# 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: RTLMeter
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 2 * * *'  # Daily, starting at 02:00 UTC
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - labeled
+      - unlabeled
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: bash
+
+concurrency:
+  group: ${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name != 'schedule' }}
+
+jobs:
+  start:
+    name: Start
+    # Only run scheduled jobs if explicitly enabled for that repo (e.g.: not on forks)
+    # Only run pull request jobs if labelled as needing an RTLMeter run
+    # Always run workflow dispatch jobs
+    if: |
+      (github.event_name == 'schedule'
+        && vars.ENABLE_SCHEDULED_JOBS == 'true') ||
+      (github.event_name == 'pull_request'
+        && contains(github.event.pull_request.labels.*.name, 'pr: rtlmeter')) ||
+      (github.event_name == 'workflow_dispatch')
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Startup
+        run: echo
+
+  build-gcc:
+    name: Build GCC
+    needs: start
+    uses: ./.github/workflows/reusable-rtlmeter-build.yml
+    with:
+      runs-on: ubuntu-24.04
+      cc: gcc
+
+  build-clang:
+    name: Build Clang
+    needs: start
+    uses: ./.github/workflows/reusable-rtlmeter-build.yml
+    with:
+      runs-on: ubuntu-24.04
+      cc: clang
+
+  run-gcc:
+    name: Run GCC | ${{ matrix.cases }}
+    needs: build-gcc
+    uses: ./.github/workflows/reusable-rtlmeter-run.yml
+    with:
+      tag: gcc
+      runs-on: ubuntu-24.04
+      cc: gcc
+      cases: ${{ matrix.cases }}
+      run-name: "gcc"
+      compileArgs: ""
+      executeArgs: ""
+    strategy:
+      fail-fast: false
+      max-parallel: ${{ github.event == 'schedule' && 2 || 7 }}
+      matrix:
+        cases:
+          - "NVDLA:*"
+          - "OpenPiton:1x1:*"
+          - "OpenPiton:2x2:*"
+          - "OpenPiton:4x4:*"
+          - "OpenTitan:*"
+          - "VeeR-EH1:asic*"
+          - "VeeR-EH1:default*"
+          - "VeeR-EH1:hiperf*"
+          - "VeeR-EH2:asic*"
+          - "VeeR-EH2:default*"
+          - "VeeR-EH2:hiperf*"
+          - "VeeR-EL2:asic*"
+          - "VeeR-EL2:default*"
+          - "VeeR-EL2:hiperf*"
+          - "Vortex:mini:*"
+          - "Vortex:sane:*"
+          - "XiangShan:default-chisel3:* !*:linux"
+          - "XiangShan:default-chisel6:* !*:linux"
+          - "XiangShan:mini-chisel3:* !*:linux"
+          - "XiangShan:mini-chisel6:* !*:linux"
+          - "XuanTie-E902:*"
+          - "XuanTie-E906:*"
+          - "XuanTie-C906:*"
+          - "XuanTie-C910:*"
+
+  run-clang:
+    name: Run Clang | ${{ matrix.cases }}
+    needs: build-clang
+    uses: ./.github/workflows/reusable-rtlmeter-run.yml
+    with:
+      tag: clang
+      runs-on: ubuntu-24.04
+      cc: clang
+      cases: ${{ matrix.cases }}
+      run-name: "clang --threads 4"
+      compileArgs: "--threads 4"
+      executeArgs: ""
+    strategy:
+      fail-fast: false
+      max-parallel: ${{ github.event == 'schedule' && 2 || 7 }}
+      matrix:
+        cases:
+          - "NVDLA:*"
+          - "OpenPiton:1x1:*"
+          - "OpenPiton:2x2:*"
+          - "OpenPiton:4x4:*"
+          - "OpenTitan:*"
+          - "VeeR-EH1:asic*"
+          - "VeeR-EH1:default*"
+          - "VeeR-EH1:hiperf*"
+          - "VeeR-EH2:asic*"
+          - "VeeR-EH2:default*"
+          - "VeeR-EH2:hiperf*"
+          - "VeeR-EL2:asic*"
+          - "VeeR-EL2:default*"
+          - "VeeR-EL2:hiperf*"
+          - "Vortex:mini:*"
+          - "Vortex:sane:*"
+          - "XiangShan:default-chisel3:* !*:linux"
+          - "XiangShan:default-chisel6:* !*:linux"
+          - "XiangShan:mini-chisel3:* !*:linux"
+          - "XiangShan:mini-chisel6:* !*:linux"
+          - "XuanTie-E902:*"
+          - "XuanTie-E906:*"
+          - "XuanTie-C906:*"
+          - "XuanTie-C910:*"
+
+  combine-results:
+    name: Combine results
+    needs: [run-gcc, run-clang]
+    # Run if any of the dependencies have run, even if failed.
+    # That is: do not run if all skipped, or the workflow was cancelled.
+    if: ${{ (contains(needs.*.result, 'success') || contains(needs.*.result, 'failure')) && !cancelled() }}
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        tag:
+          - gcc
+          - clang
+    steps:
+      - name: Checkout RTLMeter
+        uses: actions/checkout@v4
+        with:
+          repository: "verilator/rtlmeter"
+          path: rtlmeter
+      - name: Setup RTLMeter venv
+        working-directory: rtlmeter
+        run: make venv
+      - name: Download all results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: rtlmeter-results-${{ matrix.tag }}-*
+          path: all-results-${{ matrix.tag }}
+          merge-multiple: true
+      - name: Combine results
+        working-directory: rtlmeter
+        run: |
+          ./rtlmeter collate ../all-results-${{ matrix.tag }}/*.json > ../all-results-${{ matrix.tag }}.json
+      - name: Upload combined results
+        uses: actions/upload-artifact@v4
+        with:
+          path: all-results-${{ matrix.tag }}.json
+          name: all-results-${{ matrix.tag }}
+          overwrite: true
+          retention-days: 30
+
+  publish-scheduled-results:
+    name: Publish results to verilator/verilator-rtlmeter-results
+    needs: combine-results
+    # Only run on scheduled builds on the main repository. We also restrict
+    # the publishing to run only on the first run_attempt. This is required
+    # to prevent multiple uploads the same day (if rerunning), as the
+    # dashboard UI currently assumes there is only one data point per
+    # calendar day. Results from reruns can be imported manually if needed.
+    if: ${{ github.event_name == 'schedule' && github.repository == 'verilator/verilator' && github.run_attempt == 1 && contains(needs.*.result, 'success') && !cancelled() }}
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Download combined results
+        uses: actions/download-artifact@v4
+        with:
+          pattern: all-results-*
+          path: results
+          merge-multiple: true
+      - name: Upload published results
+        uses: actions/upload-artifact@v4
+        with:
+          path: results/*.json
+          name: published-results
+      # Pushing to verilator/verilator-rtlmeter-results requires elevated permissions
+      - name: Generate access token
+        id: generate-token
+        uses: actions/[email protected]
+        with:
+          app-id: ${{ vars.VERILATOR_CI_ID }}
+          private-key: ${{ secrets.VERILATOR_CI_KEY }}
+          owner: verilator
+          repositories: verilator-rtlmeter-results
+          permission-contents: write
+      - name: Checkout verilator-rtlmeter-results
+        uses: actions/checkout@v4
+        with:
+          repository: "verilator/verilator-rtlmeter-results"
+          token: ${{ steps.generate-token.outputs.token }}
+          path: verilator-rtlmeter-results
+      - name: Import results
+        id: import-results
+        working-directory: verilator-rtlmeter-results
+        run: |
+          for f in $(find ../results -name "*.json"); do \
+            echo "Importing $f"; \
+            ./bin/add-rtlmeter-result $f; \
+          done
+          test -z "$(git status --porcelain)" || echo "valid=1" >> "$GITHUB_OUTPUT"
+      - name: Push to verilator-rtlmeter-results
+        if: ${{ steps.import-results.outputs.valid }}
+        working-directory: verilator-rtlmeter-results
+        run: |
+          git config --global user.email "[email protected]"
+          git config --global user.name "github action"
+          git add .
+          git commit -m "Verilator CI: Results of 'RTLMeter' workflow run #${{ github.run_number }}"
+          git push origin
+
+  #publish-pr-results:
+  #  name: Publish results to Pull Request
+  #  needs: combine-results
+  #  if: ${{ github.event_name == 'pull_request' && github.repository == 'verilator/verilator' && github.run_attempt == 1 && contains(needs.*.result, 'success') && !cancelled() }}
+  #  runs-on: ubuntu-24.04
+  #  steps:
+  #    - name: Checkout RTLMeter
+  #      uses: actions/checkout@v4
+  #      with:
+  #        repository: "verilator/rtlmeter"
+  #        path: rtlmeter
+  #    - name: Setup RTLMeter venv
+  #      working-directory: rtlmeter
+  #      run: make venv
+  #    - name: Download combined results
+  #      uses: actions/download-artifact@v4
+  #      with:
+  #        pattern: all-results-*
+  #        path: all-results
+  #        merge-multiple: true
+  #    - name: Get scheduled run info
+  #      id: scheduled-info
+  #      run:
+  #        IDLATEST=$(gh run list --workflow RTLMeter --event schedule --status success --limit 1 --json databaseId --jq ".[0].databaseId")
+  #        echo "id=$IDLATEST" >> $GITHUB_OUTPUT
+  #        URL=$(gh run view $IDLATEST --json url --jq ".url")
+  #        echo "url=$URL" >> $GITHUB_OUTPUT
+  #        NUM=$(gh run view $IDLATEST --json number --jq ".number")
+  #        echo "num=$NUM" >> $GITHUB_OUTPUT
+  #    # Fetching artifacts from different workflow requires elevated privilege
+  #    - name: Generate access token
+  #      id: generate-token
+  #      uses: actions/[email protected]
+  #      with:
+  #        app-id: ${{ vars.VERILATOR_CI_ID }}
+  #        private-key: ${{ secrets.VERILATOR_CI_KEY }}
+  #        owner: verilator
+  #        repositories: verilator
+  #        permission-actions: read
+  #    - name: Download scheduled run results
+  #      uses: actions/download-artifact@v4
+  #      with:
+  #        name: published-results
+  #        path: nightly-results
+  #        run-id: ${{ steps.schedueld-info.outputs.id }}
+  #        github-token: ${{ steps.generate-token.outputs.token }}
+  #    # TODO: diff and present
+
+  # Create GitHub issue for failed schedueld jobs
+  # This should always be the last job (we want an issue if anything breaks)
+  create-issue:
+    name: Create issue on failure
+    needs: publish-scheduled-results
+    if: ${{ github.event_name == 'schedule' && github.repository == 'verilator/verilator' && github.run_attempt == 1 && failure() && !cancelled() }}
+    runs-on: ubuntu-24.04
+    steps:
+      # Creating issues requires elevated privilege
+      - name: Generate access token
+        id: generate-token
+        uses: actions/[email protected]
+        with:
+          app-id: ${{ vars.VERILATOR_CI_ID }}
+          private-key: ${{ secrets.VERILATOR_CI_KEY }}
+          owner: verilator
+          repositories: verilator
+          permission-issues: write
+      - name: Create issue
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+        run: |
+          echo "This issue was created automatically by the GitHub Actions CI due to the failure of a scheduled RTLMeter run." >> body.txt
+          echo "" >> body.txt
+          echo "Workflow status: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}" >> body.txt
+          gh issue --repo ${{ github.repository }} create \
+            --title "RTLMeter run #${{ github.run_number }} Failed" \
+            --body-file body.txt \
+            --label new \
+            --assignee gezalore,wsnyder

CMakeLists.txt

@@ -16,7 +16,7 @@ cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW) # Use MSVC_RUNTIME_LIBRARY to select the runtime
 project(
     Verilator
-    VERSION 5.034
+    VERSION 5.040
     HOMEPAGE_URL https://verilator.org
     LANGUAGES CXX
 )
@@ -134,10 +134,7 @@ configure_package_config_file(
     INSTALL_DESTINATION .
 )
 
-install(
-    FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config.cmake
-    DESTINATION .
-)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/verilator-config.cmake DESTINATION .)
 
 configure_package_config_file(
     verilator-config-version.cmake.in

Changes

@@ -5,7 +5,287 @@ Revision History and Change Log
 ===============================
 
 The changes in each Verilator version are described below.  The
-contributors that suggested a given feature are shown in []. Thanks!
+contributors that suggested or implemented a given issue are shown in []. Thanks!
+
+
+Verilator 5.040 2025-08-30
+==========================
+
+**Other:**
+
+* Add ENUMITEMWIDTH error, and apply to X-extended and ranged values.
+* Add NOEFFECT warning, replacing previous `foreach` error.
+* Add SPECIFYIGN warning for specify constructs that were previously silently ignored.
+* Add PARAMNODEFAULT error, for parameters without defaults.
+* Add enum base data type, wire data type, and I/O versus data declaration checking per IEEE.
+* Add PROTOTYPEMIS error on missing and mismatching prototypes (#6206) (#6207). [Alex Solomatnikov]
+* Add error when trying to assign class object to variable of non-class types (#6237). [Igor Zaworski, Antmicro Ltd.]
+* Add ALWNEVER warning, for `always @*` that never execute (#6291).
+* Add separate coverage counters for toggles 0->1 and 1->0 (#6086). [Ryszard Rozak, Antmicro Ltd.]
+* Add error on class 'function static'.
+* Add error on force/release non-constant selects.
+* Add `-DVERILATOR=1` definition to compiler flags when using verilated.mk.
+* Support member-level triggers for virtual interfaces (#5166) (#6148). [Yilou Wang]
+* Support unassigned virtual interfaces (#5265) (#6245). [Szymon Gizler, Antmicro Ltd.]
+* Support randomization of scope variables with 'std::randomize()' (#5438) (#6185). [Yilou Wang]
+* Support disabling a fork in additional contexts (#5432 partial) (#6174) (#6183). [Ryszard Rozak, Antmicro Ltd.]
+* Support bit queue streaming (#5830) (#6103). [Paul Swirhun]
+* Support `$fread` with missing start (#6125). [Iztok Jeras]
+* Support unpacked array `with` methods (#6134).
+* Support Verilog real ports as SystemC double ports (#6136) (#6158). [George Polack]
+* Support `$countones` in constraints (#6144 partial) (#6235). [Ryszard Rozak, Antmicro Ltd.]
+* Support disable dotted references (#6154). [Ryszard Rozak, Antmicro Ltd.]
+* Support randomize() on class member selects (#6161) (#6195). [Igor Zaworski, Ryszard Rozak, Antmicro Ltd.]
+* Support multiple variables on RHS of a `force` assignment (#6163). [Artur Bieniek, Antmicro Ltd.]
+* Support covergroup extends, etc., as unsupported (#6160). [Artur Bieniek, Antmicro Ltd.]
+* Support parameter resolution of 1D unpacked array slices (#6257) (#6268). [Michael Bedford Taylor]
+* Support generic interfaces (#6272). [Igor Zaworski, Antmicro Ltd.]
+* Support disabling a fork from within that fork (#6314). [Ryszard Rozak, Antmicro Ltd.]
+* Support future sampled value functions.
+* Support simple disable within task (#6334). [Ryszard Rozak, Antmicro Ltd.]
+* Support recursive constant functions.
+* Change control file `public_flat_*` and other signal attributes to support __ in names (#6140).
+* Change runtime to exit() instead of abort(), unless under +verilated+debug.
+* Change `$display("%p")` to remove space after `}`.
+* Improve `--skip-identical` to skip on identical input file contents (#6109).
+* Improve testing on FreeBSD (#6328). [Aleksander Kiryk]
+* Optimize to return memory when using -build (#6192) (#6226). [Michael B. Taylor]
+* Optimize 2 ** X to 1 << X if base is signed (#6203). [Max Wipfli]
+* Optimize more complex combinational logic in DFG (#6205) (#6209) (#6298). [Geza Lore]
+* Optimize combinational cycles through arrays in DFG (#6210). [Geza Lore]
+* Optimize variable removal in scoped DFG (#6260). [Geza Lore]
+* Optimize acyclic DFG components into the original acyclic sub-graph. (#6261). [Geza Lore]
+* Optimize multiplexers in DFG synthesis (#6331). [Geza Lore]
+* Optimize interfaces in DFG (#6332). [Geza Lore]
+* Optimize logic in non-virtual interfaces with DFG (#6347). [Geza Lore]
+* Fix loop initialization visibility outside loop (#4237).
+* Fix constructor parameters in inheritance hierarchies (#6036) (#6070). [Petr Nohavica]
+* Fix replicate of negative giving 'REPLICATE has no expected width' internal error (#6048) (#6229).
+* Fix cmake `-Wno` compiler flag testing (#6145). [Martin Stadler]
+* Fix class extends dotted error (#6162). [Igor Zaworski, Antmicro Ltd.]
+* Fix genvar error with `-O0` (#6165). [Max Wipfli]
+* Fix uninitialized thread PGO counters (#6167). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Fix additional UNOPTFLAT combinational cycles automatically in DFG (#6168) (#6173) (#6176). [Geza Lore]
+* Fix omitting error when assigning to an input (#6169). [Artur Bieniek, Antmicro Ltd.]
+* Fix parameter-dependent type linking (#6170). [Igor Zaworski, Antmicro Ltd.]
+* Fix param-dependent class typedef linking (#6171). [Igor Zaworski, Antmicro Ltd.]
+* Fix virtual interface member propagation (#6175) (#6184). [Yilou Wang]
+* Fix `--coverage-expr` null pointer dereference (#6181). [Igor Zaworski, Antmicro Ltd.]
+* Fix conflicting function/class name linking error (#6182). [Igor Zaworski, Antmicro Ltd.]
+* Fix negate of wide structure selections (#6186).
+* Fix VPI signal range order (#6189) (#6200). [Ibrahim Burak Yorulmaz]
+* Fix structure select causing 'Wide Op' error (#6191). [Danny Oler]
+* Fix automatic task variables in unrolled loops with forks (#6194) (#6201). [Danny Oler]
+* Fix 'driver same component' assertion (#6211) (#6215). [Geza Lore]
+* Fix `--stats` overridden by skipping identical build (#6220). [Geza Lore]
+* Fix MODDUP with duplicate packages to take first package (#6222).
+* Fix replicate with unsigned count but MSB set (#6231) (#6233). [Geza Lore]
+* Fix randomize on function-local variable (#6234).
+* Fix queue typedef with unbounded slice (#6236).
+* Fix error when force assignment is used with ref function args (#6244). [Ryszard Rozak, Antmicro Ltd.]
+* Fix write of 0 in '%c' (#6248) (#6249). [Rodrigo Batista de Moraes]
+* Fix coverage of variables of complex types (#6250). [Ryszard Rozak, Antmicro Ltd.]
+* Fix broken support of unassigned virtual interfaces (#6253) (#6338). [Szymon Gizler, Antmicro Ltd.]
+* Fix partial DFG conversion of concat assignments (#6255). [Geza Lore]
+* Fix dynamic cast purity (#6267). [Igor Zaworski, Antmicro Ltd.]
+* Fix same variable on the RHS forced to two different LHSs. (#6269). [Artur Bieniek, Antmicro Ltd.]
+* Fix spurious VPI value change callbacks (#6274). [Todd Strader]
+* Fix stray ']' in Verilog code output for non-constant select (#6277). [Geza Lore]
+* Fix hierarchical NBAs (#6286) (#6300). [Geza Lore]
+* Fix variables hiding package imports (#6289). [Johan Wouters]
+* Fix DFG circular driver tracing. [Geza Lore]
+* Fix no matching function calls for randomized `VlWide` in unpacked and dynamic arrays (#6290). [Mateusz Gancarz, Antmicro Ltd.]
+* Fix PowerPC support (#6292). [Sergey Fedorov]
+* Fix referencing module variables above classes (#6304). [Artur Bieniek, Antmicro Ltd.]
+* Fix direct NBA to dynamically-sized variable (#6310). [Artur Bieniek, Antmicro Ltd.]
+* Fix static vars under member select (#6313). [Igor Zaworski, Antmicro Ltd.]
+* Fix expression type comparison (#6316). [Igor Zaworski, Antmicro Ltd.]
+* Fix of inline constraints with member selects  (#6321). [Igor Zaworski, Antmicro Ltd.]
+* Fix corner case bugs in module and variable inlining (#6322). [Geza Lore]
+* Fix queue extend to check bounds (#6324). [Aleksander Kiryk]
+* Fix gathering sensitivities from virtual interface members (#6325). [Aleksander Kiryk]
+* Fix FreeBSD missing headers (#6326). [Aleksander Kiryk]
+* Fix to select UDPs when they are the only candidate for a top module.
+* Fix splitting of assignments to SC variables (#6329) (#6336). [Geza Lore]
+* Fix to localize for super constructors with function calls as arguments (#6330). [Igor Zaworski, Antmicro Ltd.]
+* Fix wide select expansion and substitution (#6341) (#6345). [Geza Lore]
+* Fix upcasting class type parameters (#6344). [Krzysztof Bieganski, Antmicro Ltd.]
+* Fix undefined weak link for Apple GCC etc (#6348). [Congcong Cai]
+
+
+Verilator 5.038 2025-07-08
+==========================
+
+**Important:**
+
+* Change `--assert` to be the default; use `--no-assert` for legacy behavior and faster runtimes.
+
+**Other:**
+
+* Support redeclaring type as non-type; major parsing change (#2412) (#6020) (#6042) (#6044).
+* Support scoped `new` (#4199).
+* Support elaboration-time printing of unpacked array with `%p` (#4732).
+* Support constrained random for associative arrays (#5985) (#5986). [Yilou Wang]
+* Support assignments to concatenations with impure RHS (#6002). [Ryszard Rozak, Antmicro Ltd.]
+* Support SARIF JSON diagnostic output with `--diagnostics-sarif`. (#6017)
+* Support 1-bit params with -G and -pvalue (#6051) (#6082). [Paul Swirhun]
+* Support `specparam` (#5767) (#6142).
+* Support `$timeformat` with missing arguments (#6113). [Alex Solomatnikov]
+* Support non-overlapping blocking/non-blocking assignments (#6137). [Geza Lore]
+* Support parameter forward types.
+* Support constant functions with left-hand-side concatenates.
+* Add PROCINITASSIGN on initial assignments to process variables (#2481). [Niraj Menon]
+* Add BADVLTPRAGMA on unknown Verilator pragmas (#5945). [Shou-Li Hsu]
+* Add ternary operator into branch coverage (#5880). [Ryszard Rozak, Antmicro Ltd.]
+* Add aggregate type error checks (#5570) (#5950). [Shou-Li Hsu]
+* Add `--work` library-selection option (#5891 partial).
+* Add `--filter-type` to verilator_coverage (#6030). [Ryszard Rozak, Antmicro Ltd.]
+* Add `--hierarchical-threads` (#6037). [Bartłomiej Chmiel]
+* Add `MODMISSING` error, in place of unnamed error (#6054). [Paul Swirhun]
+* Add DFG binToOneHot pass to generate one-hot decoders (#6096). [Geza Lore]
+* Add hint of the signed right-hand-side in oversized replication error (#6098). [Peter Birch]
+* Improve hierarchical scheduling visualization in V3ExecGraph (#6009). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Improve DPI temporary 'for' loop performance (#6079). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Improve memory usage for SenTrees in V3OrderProcessDomains (#6112). [Geza Lore]
+* Improve docker image size (#6139). [Tobias Rosenkranz, bitaggregat GmbH]
+* Update docker base image to Ubuntu 24.04 (#6147). [Tobias Rosenkranz, bitaggregat GmbH]
+* Optimize DFG De Morgan patterns (#6090). [Geza Lore]
+* Optimize DFG variable elimination (#6091). [Geza Lore]
+* Optimize DFG PUSH_SEL_THROUGH_CONCAT pattern (#6092). [Geza Lore]
+* Optimize DFG before V3Gate (#6141). [Geza Lore]
+* Optimize DFG peephole patterns (#6149). [Geza Lore]
+* Optimize constification within Expand and Subst stages (#6111). [Geza Lore]
+* Fix --x-initial and --x-assign random stability (#2662) (#5958) (#6018) (#6025) (#6075). [Todd Strader]
+* Fix trace hierarchical-name runtime errors (#5668) (#6076). [Paul Swirhun]
+* Fix streaming operator packing order (#5903) (#6077). [Paul Swirhun]
+* Fix filename backslash escapes in C code (#5947).
+* Fix C++ widths in V3Expand (#5953) (#5975). [Geza Lore]
+* Fix dependencies from different hierarchical schedules (#5954). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Fix constant propagation of post-expand stages (#5955) (#5963) (#5969) (#5972) (#5983).
+* Fix sign extension of signed compared with unsigned case items (#5968).
+* Fix always processes ignoring $finish (#5971). [Hennadii Chernyshchyk]
+* Fix method calls and new to access interface arrays (#5973). [Nick Brereton]
+* Fix streaming to/from packed arrays (#5976). [Geza Lore]
+* Fix segfault writing timestamp to VCD after buffer flush (#5978) (#5980). [Dominick Grochowina]
+* Fix inconsistent assignment error with split-var (#5984) (#5988). [Yutetsu TAKATSUKASA]
+* Fix AstAssignW conversion (#5991) (#5992). [Ryszard Rozak, Antmicro Ltd.]
+* Fix const-bit-op-tree with single-bit masks (#5993) (#5998). [Yutetsu TAKATSUKASA]
+* Fix arithmetic right-shift by constants over 32 bits (#5994). [Zhen Yan]
+* Fix array bounds checking with class member selects (#5996) (#5997). [Krzysztof Starecki]
+* Fix checking for too-wide divide and modulus (#6003) (#6006). [Zhen Yan]
+* Fix folding of LteS in DfgPeephole (#6000) (#6004). [Geza Lore]
+* Fix slicing of AstExprStmt nodes (#6005). [Ryszard Rozak, Antmicro Ltd.]
+* Fix skipped generate blocks in toggle coverage (#6010). [Ryszard Rozak, Antmicro Ltd.]
+* Fix arithmetic left-shift by constants over 32 bits (#6007) (#6015). [Zhen Yan]
+* Fix concatenation and type casting (#6012) (#6013). [Todd Strader]
+* Fix wrong optimization result of shifted out variable (#6016) (#6019). [Yutetsu TAKATSUKASA]
+* Fix missing FreeBSD include (#6027) (#6028). [Joel Bodenmann]
+* Fix associative arrays with enum keys (#6034) (#6035). [Petr Nohavica]
+* Fix GCC 10 read-only linker error (#6040). [Todd Strader]
+* Fix WIDTHCONCAT on packed pattern assignment (#6045). [Dan Petrisko]
+* Fix type operator for interface signals (#6049) (#6050). [Todd Strader]
+* Fix V3OrderParallel scoring contraction hang (#6052). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Fix virtual interface array typedef expressions (#6057).
+* Fix DFG peephole select conditionals (#6064) (#6071). [Geza Lore]
+* Fix `--skip-identical` skipping on some errors (#6066). [Todd Strader]
+* Fix class typedef elaboration (#6080). [Kamil Rakoczy, Antmicro Ltd.]
+* Fix unpacked to packed parameter assignment (#6081) (#6088). [Todd Strader]
+* Fix casting reals to large integrals (#6085). [Todd Strader]
+* Fix nested hier blocks workers error (#6087). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Fix `--lib-create` with double-underscore (#6099).
+* Fix DFG binToOneHot table index missing driver (#6100). [Geza Lore]
+* Fix decoding octal string escapes with 1-2 digits (#6108).
+* Fix colon-divide operator without space (#6121). [Alex Solomatnikov]
+* Fix variables declared in fork after taskify (#6126). [Kamil Rakoczy, Antmicro Ltd.]
+* Fix method calls without parenthesis (#6127). [Alex Solomatnikov]
+* Fix `pre_randomize`/`post_randomize` when no randomize (#6128). [Alex Solomatnikov]
+* Fix wide non-blocking assignment mis-optimization (#6150) (#6152) (#6155). [Todd Strader]
+* Fix interface array connections with non-zero low declaration index.
+* Fix developer build error on MacOS/Flex2.6.4 (#6153). [Paul Swirhun]
+* Fix crash with --dumpi-V3LinkDot without --debug (#6159). [Igor Zaworski, Antmicro Ltd.]
+* Fix dereferencing stale iterator in DfgVertex::scopep() (#6225) (#6227). [Geza Lore]
+* Fix component numbers of new Vertices in V3DfgBreakCycles (#6225) (#6228). [Geza Lore]
+
+
+Verilator 5.036 2025-04-27
+==========================
+
+**Important:**
+
+* Change `--output-groups` to default to value of `--build-jobs` (#5751).
+  Those using build farms may need to now use `--output-groups 0` or otherwise.
+* Support user-defined primitives (UDPs) (#468) (#5807) (#5936). [Zhou Shen, Krzysztof Sychla, et al]
+* Add `--trace-saif` for SAIF power traces (#5812) (#5914). [Mateusz Gancarz, Antmicro Ltd.]
+
+**Other:**
+
+* Change `--trace` to `--trace-vcd`.
+* Support simple `checker` blocks (#4066). [Srinivasan Venkataramanan]
+* Support force/release with a variable reference (#5721) (#5810). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Support constraint random for StructArray (#5805) (#5937). [Yilou Wang]
+* Support command-line overriding `define (#5900) (#5908). [Brian Li]
+* Support soft unions (#5912) (#5932). [Robin Heinemann]
+* Support `$setuphold` (#5884). [Krzysztof Sychla]
+* Support assigning unpacked arrays to queues (#5924) (#5928). [Brian Li]
+* Support `systemc_interface and related inside `class`.
+* Support class extends with arguments.
+* Add multi-thread hierarchical simulation (#2583) (#5871). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Add check for `let` misused in statement context (#5733).
+* Add used language to `--preproc-resolve` output (#5795). [Kamil Rakoczy, Antmicro Ltd.]
+* Add `--make json` to enable integration with non-make/cmake build systems (#5799). [Andrew Voznytsa]
+* Add numactl-like automatic assignment of processor affinity (#5911).
+* Add ccache support for generated cmake files (#5926) (#5930). [Andrew Voznytsa]
+* Add visualization of multi-threaded waiting time with verilator_gantt (#5929). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Add suggesting isolate_assignments to UNOPTFLAT (#5942). [John Khoo]
+* Add profiling of hierarchical mtasks with verilator_gantt (#5956). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Add empty veriuser.h for legacy compatibility.
+* Add DEPRECATED warning on `--xml-only` and `--xml-output`.
+* Remove unused gtkwave/wavealloca.h. [Geza Lore]
+* Optimize automatic splitting of some packed variables (#5843). [Geza Lore]
+* Optimize trigger vector in whole words (#5857). [Geza Lore]
+* Fix parameters referencing interface fields (#1593) (#5910). [Ryszard Rozak, Antmicro Ltd.]
+* Fix interface array assignments (#5270) (#5633) (#5869). [Nick Brereton]
+* Fix change detection at time 0 (#5499) (#5864). [Geza Lore]
+* Fix foreach of associative array inside a constraint block (#5727) (#5841). [Yilou Wang]
+* Fix reset of automatic function variables (#5747). [Augustin Fabre]
+* Fix invalid code motion over branches (#5811) (#5814). [Geza Lore]
+* Fix sorting of wide SenItems (#5816). [Geza Lore]
+* Fix tcmalloc static link and non-22.04 builds (#5817) (#5818). [Geza Lore]
+* Fix error on out-of-range lvalue part select (#5820).
+* Fix UNOPTFLAT warnings with `--coverage-trace` and always_comb (#5821).
+* Fix function locals in SenExprBuilder (#5822). [Geza Lore]
+* Fix type_id package scope resolution (#5826). [Krzysztof Bieganski, Antmicro Ltd.]
+* Fix `rand_mode` method with cast (#5831).
+* Fix invalidating variable caches in SenExprBulider (#5834) (#5835). [Geza Lore]
+* Fix assignment pattern as function argument (#5839).
+* Fix checking built-in method arguments (#5839).
+* Fix splitting of packed ports with non-zero based ranges (#5842). [Geza Lore]
+* Fix delays inside interface functions, and classes inside interfaces (#5846).
+* Fix NBA shared flag reuse (#5848). [Geza Lore]
+* Fix multiple expression coverage issues (#5849 partial) (#5867) (#5870). [Todd Strader]
+* Fix unresolved typedefs as parameters (#5850). [Eugene Feinberg, Brian Li]
+* Fix removal of callbacks no longer in current list (#5851) (#5852). [Gilberto Abram]
+* Fix segmentation fault on member compare (#5853).
+* Fix recursive error on virtual interfaces (#5854). [Yilou Wang]
+* Fix streaming of unpacked arrays concatenations (#5856). [Ryszard Rozak, Antmicro Ltd.]
+* Fix Windows paths in Perl (#5858) (#5860). [Tobias Jensen]
+* Fix algorithm header portability in V3Os.cpp (for std::replace) (#5861). [William D. Jones]
+* Fix `$fscanf` not returning -1 on EOF (#5881).
+* Fix PGO profiling for multi-threaded hierarchical scenarios (#5888). [Bartłomiej Chmiel, Antmicro Ltd.]
+* Fix V3Gate assertion on eliminated circular logic (#5889) (#5898). [Geza Lore]
+* Fix process comparisons (#5896).
+* Fix ccache with clang (#5899). [Geza Lore]
+* Fix delayed assignment malformed LHS assertion (#5904).
+* Fix segfault in fork synchronization (#5906). [Krzysztof Bieganski, Antmicro Ltd.]
+* Fix `new this` (#5909).
+* Fix assignments with stream expressions and unpacked arrays (#5915). [Ryszard Rozak, Antmicro Ltd.]
+* Fix LATCH warning for automatic variables (#5918). [Yutetsu TAKATSUKASA]
+* Fix %% on elaboration severity tasks (#5922). [Ethan Sifferman]
+* Fix port default values with `--coverage-line` creating `0=0` (#5920). [Drew Ranck]
+* Fix vlSelf error on fork repeats (#5927). [Drew Ranck]
+* Fix missing C++ regeneration when Verilog files are updated (#5934). [Zhouyi Shen]
+* Fix stream expressions (#5938). [Ryszard Rozak, Antmicro Ltd.]
+* Fix packed selection using over 32-bit index (#5957).
 
 
 Verilator 5.034 2025-02-24
@@ -195,7 +475,7 @@ Verilator 5.030 2024-10-27
 * Fix short-circuiting with associative array access (#5484). [Ethan Sifferman]
 * Fix short-circuiting on method calls (#5486). [Ethan Sifferman]
 * Fix exponential concatenate performance (#5488). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix V3Table trying to generate 'x' bits in the lookup table. (#5491). [Geza Lore]
+* Fix V3Table trying to generate 'x' bits in the lookup table (#5491). [Geza Lore]
 * Fix randomize with foreach constraints (#5492). [Arkadiusz Kozdra, Antmicro Ltd.]
 * Fix explicit CMAKE_INSTALL_PREFIX usages (#5500). [Fabian Keßler]
 * Fix configure inserting absolute paths for Python and Perl (#5504) (#5505). [Nathan Graybeal]
@@ -253,7 +533,7 @@ Verilator 5.028 2024-08-21
 * Add parsing but otherwise ignore std::randomize (#5354). [Arkadiusz Kozdra, Antmicro Ltd.]
 * Add Verilated cc define when `--timing` used (#5383). [Kaleb Barrett]
 * Improve emitted code to use a reference for VlSelf (#5254). [Yangyu Chen]
-* Fix monitor block sensitivity items (#4400) (#5294). [Udaya Raj Subedi]
+* Fix monitor block sensitivity items (#4040) (#4400) (#5294). [Udaya Raj Subedi]
 * Fix fusing macro arguments to not ignore whitespace (#5061). [Tudor Timi]
 * Fix optimized-out sensitivity trees with `--timing` (#5080) (#5349). [Krzysztof Bieganski, Antmicro Ltd.]
 * Fix classes/modules of case-similar names (#5109). [Arkadiusz Kozdra]
@@ -280,7 +560,7 @@ Verilator 5.028 2024-08-21
 * Fix static variable initializers in procedures (#5296). [Bartłomiej Chmiel, Antmicro Ltd.]
 * Fix randomizing current object with `rand` class instance member (#5292). [Krzysztof Bieganski, Antmicro Ltd.]
 * Fix handling of rand fields not referenced in constraints (#5305). [Ryszard Rozak, Antmicro Ltd.]
-* Fix Python3 path discovery in make flows to avoid mixing system and user python interpreters (#5307) [Markus Krause]
+* Fix Python3 path discovery in make flows to avoid mixing system and user python interpreters (#5307). [Markus Krause]
 * Fix make flows to pass PYTHON3 (like PERL) (#5307) (#5308). [Markus Krause]
 * Fix assert on wide expression (#5319) (#5324). [Varun Koyyalagunta]
 * Fix output clock variable overwriting signal (#5320)  (#5347). [Krzysztof Bieganski, Antmicro Ltd.]
@@ -459,7 +739,7 @@ Verilator 5.022 2024-02-24
 * Fix `vpi_get()` and `vpi_get64()` to return vpiUndefined on errors (#4795). [Marlon James]
 * Fix VPI parameter iteration (#4798). [Marlon James]
 * Fix delays using wrong timeunit when modules inlined (#4806). [Paul Wright]
-* Fix warnings in verilated_sc_trace.h for Clang. (#4807) (#4827). [Anthony Donlon]
+* Fix warnings in verilated_sc_trace.h for Clang (#4807) (#4827). [Anthony Donlon]
 * Fix null pointer dereference (#4810) (#4825). [Adrian Sampson]
 * Fix compilation error on multi-inherited interface class usage (#4819).
 * Fix maybe-uninitialized compiler warning (#4820) (#4822). [Larry Doolittle]
@@ -537,7 +817,7 @@ Verilator 5.020 2024-01-01
 * Fix conflicted namespace for coroutines (#4701) (#4707). [Jinyan Xu]
 * Fix compilers seeing empty input due to file system races (#4708). [Flavien Solt]
 * Fix shift of > 32-bit number (#4719). [Flavien Solt]
-* Fix Windows include gates in filesystem Flush implementation. (#4720). [William D. Jones]
+* Fix Windows include gates in filesystem Flush implementation (#4720). [William D. Jones]
 * Fix power operator with wide numbers and constants (#4721) (#4763). [Flavien Solt]
 * Fix parameter passing to ports (#4723). [Ryszard Rozak, Antmicro Ltd.]
 * Fix block names of nested do..while loops (#4728). [Ryszard Rozak, Antmicro Ltd.]
@@ -546,7 +826,7 @@ Verilator 5.020 2024-01-01
 * Fix $finish twice to no longer exit (#4757). [Tim Hutt]
 * Fix dynamic NBA conditions (#4773). [Krzysztof Bieganski, Antmicro Ltd.]
 * Fix `V3Fork` stage to run only if `--timing` is set (#4778). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix max multiply width and add runtime assertions if too small. (#4781)
+* Fix max multiply width and add runtime assertions if too small (#4781).
 * Fix select value too wide (#5148) (#5153). [Dercury]
 
 
@@ -663,7 +943,7 @@ Verilator 5.016 2023-09-16
 * Fix nested assignments on the LHS (#4435). [Ryszard Rozak, Antmicro Ltd]
 * Fix false MULTITOP on bound interfaces (#4438). [Alex Solomatnikov]
 * Fix internal error on real conversion (#4447). [vdhotre-ventana]
-* Fix lifetime unknown error on enum.name (#4448). [jwoutersymatra]
+* Fix lifetime unknown error on enum.name (#4448). [Johan Wouters]
 * Fix unstable output of VHashSha256 (#4453). [Anthony Donlon]
 * Fix static cast from a stream type (#4469) (#4485). [Ryszard Rozak, Antmicro Ltd]
 * Fix error on enum with VARHIDDEN of cell (#4482). [Michail Rontionov]
@@ -1211,7 +1491,7 @@ Verilator 4.218 2022-01-17
 
 * Support class static members (#2233).
 * Support force/release (#2431) (#2593). [Shunyao CAD]
-* Add 'forceable' attribute to allow forcing from C++. (#3272). [Geza Lore, Shunyao CAD]
+* Add 'forceable' attribute to allow forcing from C++ (#3272). [Geza Lore, Shunyao CAD]
 * Support lower dimension looping in foreach loops (#3172). [Ehab Ibrahim]
 * Support up to 64 bit enums for .next/.prev/.name (#3244). [Alexander Grobman]
 * Reduce .rodata footprint of trace initialization (#3250). [Geza Lore, Shunyao CAD]
@@ -1435,7 +1715,7 @@ Verilator 4.200 2021-03-12
 **Major:**
 
 * Add simulation context (VerilatedContext) to allow multiple fully independent
-  models to be in the same process. Please see the updated examples. (#2660)
+  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().
 
@@ -1446,7 +1726,7 @@ Verilator 4.200 2021-03-12
 * 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]
+* Fix MSVC++ compile error (#2831) (#2833). [Drew Taussig]
 
 
 Verilator 4.110 2021-02-25
@@ -1501,7 +1781,7 @@ Verilator 4.108 2021-01-10
 * 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 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]
@@ -1607,11 +1887,11 @@ Verilator 4.040 2020-08-15
 **Minor:**
 
 * Fix arrayed interfaces, broke in 4.038 (#2468). [Josh Redford]
-* Support $stable, $rose and $fell.  (#2148) (#2501) [Peter Monsson]
+* Support $stable, $rose and $fell (#2148) (#2501). [Peter Monsson]
 * Support simple function localparams (#2461). [James Hanlon]
 * Miscellaneous parsing error changes towards UVM support.
 * Fix arrayed interfaces (#2469).  [Josh Redford]
-* Fix protect lib VCS warning. (#2479) [Julien Margetts]
+* Fix protect lib VCS warning (#2479). [Julien Margetts]
 * Fix combining different-width parameters (#2484). [abirkmanis]
 * Fix protect-lib without sequential logic (#2492). [Yutetsu TAKATSUKASA]
 * Fix V3Unknown from running with flat XML output (#2494). [James Hanlon]
@@ -1667,16 +1947,16 @@ Verilator 4.036 2020-06-06
   waivers to the warnings emitted during a Verilator run.
 * Support verilator_coverage --write-info for lcov HTML reports.
 * Line Coverage now tracks all statement lines, not just branch lines.
-* The run-time library is now compiled with -Os by default. (#2369, #2373)
+* The run-time library is now compiled with -Os by default (#2369, #2373).
 * Support multi channel descriptor I/O (#2190) [Stephen Henry]
-* Support $countbits. (#2287) [Yossi Nivin]
-* Support $isunbounded and parameter $. (#2104)
+* Support $countbits (#2287). [Yossi Nivin]
+* Support $isunbounded and parameter $ (#2104).
 * Support unpacked array .sum and .product.
-* Support prefix/postfix increment/decrement. (#2223) [Maciej Sobkowski]
+* Support prefix/postfix increment/decrement (#2223). [Maciej Sobkowski]
 * Fix FST tracing of little bit endian signals. [Geza Lore]
-* Fix +: and -: on unpacked arrays. (#2304) [engr248]
+* Fix +: and -: on unpacked arrays (#2304). [engr248]
 * Fix $isunknown with constant Z's.
-* Fix queues and dynamic array wide ops. (#2352) [Vassilis Papaefstathiou]
+* Fix queues and dynamic array wide ops (#2352). [Vassilis Papaefstathiou]
 
 
 Verilator 4.034 2020-05-03

Makefile.in

@@ -104,45 +104,45 @@ PACKAGE_VERSION = @PACKAGE_VERSION@
 SHELL = /bin/sh
 
 SUBDIRS = docs src test_regress \
-	examples/cmake_hello_c \
-	examples/cmake_hello_sc \
-	examples/cmake_tracing_c \
-	examples/cmake_tracing_sc \
-	examples/cmake_protect_lib \
-	examples/make_hello_binary \
-	examples/make_hello_c \
-	examples/make_hello_sc \
-	examples/make_tracing_c \
-	examples/make_tracing_sc \
-	examples/make_protect_lib \
-	examples/json_py \
+  examples/cmake_hello_c \
+  examples/cmake_hello_sc \
+  examples/cmake_tracing_c \
+  examples/cmake_tracing_sc \
+  examples/cmake_protect_lib \
+  examples/make_hello_binary \
+  examples/make_hello_c \
+  examples/make_hello_sc \
+  examples/make_tracing_c \
+  examples/make_tracing_sc \
+  examples/make_protect_lib \
+  examples/json_py \
 
 INFOS = verilator.html verilator.pdf
 
 INFOS_OLD = README README.html README.pdf
 
 EXAMPLES_FIRST = \
-	examples/make_hello_c \
-	examples/make_hello_sc \
+  examples/make_hello_c \
+  examples/make_hello_sc \
 
 EXAMPLES = $(EXAMPLES_FIRST) $(filter-out $(EXAMPLES_FIRST), $(sort $(wildcard examples/*)))
 
 # See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
 # No verilator_ccache_report.1, verilator_difftree.1 as those are not bin/ installed
 VL_INST_MAN_FILES = \
-	verilator.1 \
-	verilator_coverage.1 \
-	verilator_gantt.1 \
-	verilator_profcfunc.1 \
+  verilator.1 \
+  verilator_coverage.1 \
+  verilator_gantt.1 \
+  verilator_profcfunc.1 \
 
 default: all
 all: all_nomsg msg_test
 all_nomsg: verilator_exe $(VL_INST_MAN_FILES)
 
-.PHONY:verilator_exe
-.PHONY:verilator_bin$(EXEEXT)
-.PHONY:verilator_bin_dbg$(EXEEXT)
-.PHONY:verilator_coverage_bin_dbg$(EXEEXT)
+.PHONY: verilator_exe
+.PHONY: verilator_bin$(EXEEXT)
+.PHONY: verilator_bin_dbg$(EXEEXT)
+.PHONY: verilator_coverage_bin_dbg$(EXEEXT)
 verilator_exe verilator_bin$(EXEEXT) verilator_bin_dbg$(EXEEXT) verilator_coverage_bin_dbg$(EXEEXT):
 	@echo ------------------------------------------------------------
 	@echo "making verilator in src"
@@ -151,7 +151,7 @@ verilator_exe verilator_bin$(EXEEXT) verilator_bin_dbg$(EXEEXT) verilator_covera
 ######################################################################
 # Tests
 
-.PHONY:msg_test
+.PHONY: msg_test
 msg_test: all_nomsg
 	@echo "Build complete!"
 	@echo
@@ -213,8 +213,8 @@ verilator.html:
 verilator.pdf: Makefile
 	$(MAKE) -C docs verilator.pdf
 
-TAGFILES=${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
-	${srcdir}/*.in ${srcdir}/*.pod
+TAGFILES = ${srcdir}/*/*.cpp ${srcdir}/*/*.h ${srcdir}/*/*.in \
+  ${srcdir}/*.in ${srcdir}/*.pod
 
 TAGS: $(TAGFILES)
 	etags $(TAGFILES)
@@ -224,42 +224,49 @@ TAGS: $(TAGFILES)
 doxygen:
 	$(MAKE) -C docs doxygen
 
+.PHONY: spelling
+spelling:
+	$(MAKE) -C docs spelling
+
 ######################################################################
 # Install
 
 # Public executables intended to be invoked directly by the user
 # Don't put wildcards in these variables, it might cause an uninstall of other stuff
-VL_INST_PUBLIC_SCRIPT_FILES = verilator \
-                              verilator_coverage \
-                              verilator_gantt \
-                              verilator_profcfunc \
+VL_INST_PUBLIC_SCRIPT_FILES = \
+  verilator \
+  verilator_coverage \
+  verilator_gantt \
+  verilator_profcfunc \
 
-VL_INST_PUBLIC_BIN_FILES = verilator_bin$(EXEEXT) \
-                           verilator_bin_dbg$(EXEEXT) \
-                           verilator_coverage_bin_dbg$(EXEEXT) \
+VL_INST_PUBLIC_BIN_FILES = \
+  verilator_bin$(EXEEXT) \
+  verilator_bin_dbg$(EXEEXT) \
+  verilator_coverage_bin_dbg$(EXEEXT) \
 
 # Private executabels intended to be invoked by internals
 # Don't put wildcards in these variables, it might cause an uninstall of other stuff
-VL_INST_PRIVATE_SCRIPT_FILES = verilator_ccache_report \
-                               verilator_includer \
+VL_INST_PRIVATE_SCRIPT_FILES = \
+  verilator_ccache_report \
+  verilator_includer \
 
 VL_INST_INC_BLDDIR_FILES = \
-	include/verilated_config.h \
-	include/verilated.mk \
+  include/verilated_config.h \
+  include/verilated.mk \
 
 # Files under srcdir, instead of build time
 VL_INST_INC_SRCDIR_FILES = \
-	include/*.[chv]* \
-	include/*.vlt \
-	include/*.sv \
-	include/gtkwave/*.[chv]* \
-	include/vltstd/*.[chv]* \
+  include/*.[chv]* \
+  include/*.vlt \
+  include/*.sv \
+  include/gtkwave/*.[chv]* \
+  include/vltstd/*.[chv]* \
 
 VL_INST_DATA_SRCDIR_FILES = \
-	examples/*/*.[chv]* \
-	examples/*/CMakeLists.txt \
-	examples/*/Makefile* \
-	examples/*/vl_* \
+  examples/*/*.[chv]* \
+  examples/*/CMakeLists.txt \
+  examples/*/Makefile* \
+  examples/*/vl_* \
 
 mkbindirs:
 	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
@@ -385,55 +392,55 @@ install-msg:
 ######################################################################
 # Format/Lint
 
-# Use --xml flag to see the cppcheck code to use for suppression
-CPPCHECK1_CPP = $(wildcard $(srcdir)/include/*.cpp)
-CPPCHECK2_CPP = $(wildcard $(srcdir)/examples/*/*.cpp)
-CPPCHECK3_CPP = $(wildcard $(srcdir)/src/Vlc*.cpp)
-CPPCHECK4_CPP = $(wildcard $(srcdir)/src/V3[A-D]*.cpp $(srcdir)/src/Verilator*.cpp)
-CPPCHECK5_CPP = $(wildcard $(srcdir)/src/V3[E-I]*.cpp)
-CPPCHECK6_CPP = $(wildcard $(srcdir)/src/V3[P-Z]*.cpp)
-CPPCHECK7_CPP = $(wildcard $(srcdir)/src/V3[L-R]*.cpp)
-CPPCHECK8_CPP = $(wildcard $(srcdir)/src/V3[S-Z]*.cpp)
-CHECK_CPP = $(CPPCHECK1_CPP) $(CPPCHECK2_CPP) $(CPPCHECK3_CPP) $(CPPCHECK4_CPP) \
-	$(CPPCHECK5_CPP) $(CPPCHECK6_CPP) $(CPPCHECK7_CPP) $(CPPCHECK8_CPP)
+CPPCHECK_VERILATOR_CPP = $(wildcard $(srcdir)/src/V3*.cpp $(srcdir)/src/Verilator*.cpp)
+CPPCHECK_RUNTIME_CPP = $(wildcard $(srcdir)/include/*.cpp)
+CPPCHECK_VLC_CPP = $(wildcard $(srcdir)/src/Vlc*.cpp)
+CPPCHECK_EXAMPLES_CPP = $(wildcard $(srcdir)/examples/*/*.cpp)
+CHECK_CPP = $(CPPCHECK_VERILATOR_CPP) $(CPPCHECK_RUNTIME_CPP) $(CPPCHECK_VLC_CPP) $(CPPCHECK_EXAMPLES_CPP)
 CHECK_H = $(wildcard \
-	$(srcdir)/include/*.h \
-	$(srcdir)/src/*.h )
+  $(srcdir)/include/*.h \
+  $(srcdir)/src/*.h )
 CHECK_YL = $(wildcard \
-	$(srcdir)/src/*.y \
-	$(srcdir)/src/*.l )
-CPPCHECK = src/cppcheck_filtered cppcheck
-CPPCHECK_FLAGS = --enable=all --inline-suppr \
-	--suppress=cstyleCast --suppress=useInitializationList \
-	--suppress=nullPointer --suppress=nullPointerRedundantCheck --suppress=ctunullpointer \
-	--suppress=unusedFunction --suppress=unusedScopedObject \
-	--suppress=useStlAlgorithm
-CPPCHECK_FLAGS += --xml
-CPPCHECK_DEP = $(subst .cpp,.cppcheck,$(CHECK_CPP))
-CPPCHECK_INC = -I$(srcdir)/include -I$(srcdir)/include/gtkwave -I$(srcdir)/include/vltstd -I$(srcdir)/src/obj_dbg -I$(srcdir)/src
+  $(srcdir)/src/*.y \
+  $(srcdir)/src/*.l )
+CPPCHECK = cppcheck
+CPPCHECK_JOBS = $(shell nproc)
+CPPCHECK_CACHE = $(srcdir)/src/obj_dbg/cppcheck-cache
+CPPCHECK_FLAGS = --enable=all
+CPPCHECK_FLAGS += --inline-suppr
+CPPCHECK_FLAGS += --suppressions-list=$(srcdir)/src/cppcheck-suppressions.txt
+CPPCHECK_FLAGS += --cppcheck-build-dir=$(CPPCHECK_CACHE)
+CPPCHECK_FLAGS += -DVL_DEBUG=1 -DVL_CPPCHECK=1 -DINFILTER_PIPE=1 -D__GNUC__=1
+CPPCHECK_FLAGS += -j$(CPPCHECK_JOBS)
+CPPCHECK_INC = -I$(srcdir)/include
+CPPCHECK_INC += -I$(srcdir)/include/gtkwave
+CPPCHECK_INC += -I$(srcdir)/include/vltstd
+CPPCHECK_INC += -I$(srcdir)/src/obj_dbg
+CPPCHECK_INC += -I$(srcdir)/src
 
-cppcheck: cppcheck-1 cppcheck-2 cppcheck-3 cppcheck-4 cppcheck-5 cppcheck-6 cppcheck-7 cppcheck-8
-cppcheck-1:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK1_CPP)
-cppcheck-2:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK2_CPP)
-cppcheck-3:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK3_CPP)
-cppcheck-4:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK4_CPP)
-cppcheck-5:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK5_CPP)
-cppcheck-6:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK6_CPP)
-cppcheck-7:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK7_CPP)
-cppcheck-8:
-	$(CPPCHECK) $(CPPCHECK_FLAGS) -DVL_DEBUG=1 -DVL_CPPCHECK=1 $(CPPCHECK_INC) $(CPPCHECK8_CPP)
+$(CPPCHECK_CACHE): $(CHECK_CPP) $(CHECK_H) $(CHECK_YL)
+	/bin/rm -rf $@
+	/bin/mkdir -p $@
+
+cppcheck-verilator: | $(CPPCHECK_CACHE)
+	$(CPPCHECK) $(CPPCHECK_FLAGS) $(CPPCHECK_INC) $(CPPCHECK_VERILATOR_CPP)
+cppcheck-runtime: | $(CPPCHECK_CACHE)
+	$(CPPCHECK) $(CPPCHECK_FLAGS) $(CPPCHECK_INC) $(CPPCHECK_RUNTIME_CPP)
+cppcheck-vlc: | $(CPPCHECK_CACHE)
+	$(CPPCHECK) $(CPPCHECK_FLAGS) $(CPPCHECK_INC) $(CPPCHECK_VLC_CPP)
+cppcheck-examples: | $(CPPCHECK_CACHE)
+	$(CPPCHECK) $(CPPCHECK_FLAGS) $(CPPCHECK_INC) $(CPPCHECK_EXAMPLES_CPP)
+
+cppcheck:
+	$(MAKE) cppcheck-vlc
+	$(MAKE) cppcheck-examples
+	$(MAKE) cppcheck-runtime
+	$(MAKE) cppcheck-verilator
 
 CLANGTIDY = clang-tidy
 CLANGTIDY_FLAGS = -config='' \
-	-header-filter='.*' \
-	-checks='-fuchsia-*,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-init-variables,-cppcoreguidelines-avoid-goto,-modernize-avoid-c-arrays,-readability-magic-numbers,-readability-simplify-boolean-expr,-cppcoreguidelines-macro-usage' \
+  -header-filter='.*' \
+  -checks='-fuchsia-*,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-init-variables,-cppcoreguidelines-avoid-goto,-modernize-avoid-c-arrays,-readability-magic-numbers,-readability-simplify-boolean-expr,-cppcoreguidelines-macro-usage' \
 
 CLANGTIDY_DEP = $(subst .cpp,.cpp.tidy,$(CHECK_CPP))
 CLANGTIDY_DEFS = -DVL_DEBUG=1 -DVL_CPPCHECK=1
@@ -453,15 +460,16 @@ analyzer-include:
 	scan-build $(MAKE) -k examples
 
 format:
-	$(MAKE) -j 4 format-c format-py format-exec
+	$(MAKE) -j 5 format-c format-cmake format-exec format-py
 
-CLANGFORMAT = clang-format-14
+CLANGFORMAT = clang-format-18
 CLANGFORMAT_FLAGS = -i
 CLANGFORMAT_FILES = $(CHECK_CPP) $(CHECK_H) $(CHECK_YL) test_regress/t/*.c* test_regress/t/*.h
 
 format-c clang-format:
-	@$(CLANGFORMAT) --version | egrep 14.0 > /dev/null \
-		|| echo "*** You are not using clang-format-14, indents may differ from master's ***"
+	$(CLANGFORMAT) --version
+	@$(CLANGFORMAT) --version | fgrep 'version 18' > /dev/null \
+	|| echo "*** You are not using clang-format-18, indents may differ from master's ***"
 	$(CLANGFORMAT) $(CLANGFORMAT_FLAGS) $(CLANGFORMAT_FILES)
 
 YAMLFIX = YAMLFIX_WHITELINES=1 YAMLFIX_LINE_LENGTH=130 YAMLFIX_preserve_quotes=true yamlfix
@@ -471,63 +479,79 @@ yamlfix:
 
 # CMake files
 CMAKE_FILES = \
-	CMakeLists.txt \
-	examples/*/CMakeLists.txt \
-	src/CMakeLists.txt \
-	test_regress/CMakeLists.txt \
-	*.cmake.in \
+  CMakeLists.txt \
+  examples/*/CMakeLists.txt \
+  src/CMakeLists.txt \
+  test_regress/CMakeLists.txt \
+  *.cmake.in \
+
+# Makefiles
+MAKE_FILES = \
+  Makefile*.in \
+  docs/Makefile* \
+  include/verilated.mk.in \
+  examples/*/Makefile* \
+  src/Makefile*.in \
+  test_regress/Makefile* \
 
 # Python programs, subject to format and lint
 PY_PROGRAMS = \
-	bin/verilator_ccache_report \
-	bin/verilator_difftree \
-	bin/verilator_gantt \
-	bin/verilator_includer \
-	bin/verilator_profcfunc \
-	examples/json_py/vl_file_copy \
-	examples/json_py/vl_hier_graph \
-	docs/guide/conf.py \
-	docs/bin/vl_sphinx_extract \
-	docs/bin/vl_sphinx_fix \
-	src/astgen \
-	src/bisonpre \
-	src/config_rev \
-	src/cppcheck_filtered \
-	src/flexfix \
-	src/vlcovgen \
-	src/.gdbinit.py \
-	test_regress/*.py \
-	test_regress/t/*.pf \
-	nodist/clang_check_attributes \
-	nodist/code_coverage \
-	nodist/dot_importer \
-	nodist/fuzzer/actual_fail \
-	nodist/fuzzer/generate_dictionary \
-	nodist/install_test \
-	nodist/log_changes \
+  bin/verilator_ccache_report \
+  bin/verilator_difftree \
+  bin/verilator_gantt \
+  bin/verilator_includer \
+  bin/verilator_profcfunc \
+  examples/json_py/vl_file_copy \
+  examples/json_py/vl_hier_graph \
+  docs/guide/conf.py \
+  docs/bin/vl_sphinx_extract \
+  docs/bin/vl_sphinx_fix \
+  src/astgen \
+  src/bisonpre \
+  src/config_rev \
+  src/flexfix \
+  src/vlcovgen \
+  src/.gdbinit.py \
+  test_regress/*.py \
+  test_regress/t/*.pf \
+  nodist/clang_check_attributes \
+  nodist/code_coverage \
+  nodist/dot_importer \
+  nodist/fuzzer/actual_fail \
+  nodist/fuzzer/generate_dictionary \
+  nodist/install_test \
+  nodist/log_changes \
 
 # Python files, subject to format but not lint
 PY_FILES = \
-	$(PY_PROGRAMS) \
-	nodist/code_coverage.dat \
-	test_regress/t/*.py \
+  $(PY_PROGRAMS) \
+  nodist/code_coverage.dat \
+  test_regress/t/*.py \
 
 # Python files, test_regress tests
-PY_TEST_FILES = \
-	test_regress/t/*.py \
+PY_TEST_FILES = test_regress/t/*.py
 
 YAPF = yapf3
 YAPF_FLAGS = -i --parallel
 
 format-py yapf:
+	$(YAPF) --version
 	$(YAPF) $(YAPF_FLAGS) $(PY_FILES)
 
 GERSEMI = gersemi
-GERSEMI_FLAGS = -i
+GERSEMI_FLAGS = -i --no-warn-about-unknown-commands
 
 format-cmake:
 	$(GERSEMI) $(GERSEMI_FLAGS) $(CMAKE_FILES)
 
+MBAKE = mbake
+MBAKE_FLAGS = format --config ./.bake.toml
+
+format-make:
+	$(MBAKE) $(MBAKE_FLAGS) $(MAKE_FILES)
+
+format-yaml: yamlfix
+
 PYLINT = pylint
 PYLINT_FLAGS = --recursive=n --score=n --disable=R0801
 PYLINT_TEST_FLAGS = $(PYLINT_FLAGS) --disable=C0103,C0114,C0116,C0209,C0411,C0413,C0301,R0801,R0912,R0915,R0916,R1702,W0511,W0621
@@ -595,6 +619,8 @@ clean mostlyclean distclean maintainer-clean::
 	rm -f *.tex
 	rm -rf examples/*/obj_dir* examples/*/logs
 	rm -rf test_*/obj_dir
+	rm -rf src/*.tidy include/*.tidy examples/*/*.tidy
+	rm -rf .ruff_cache
 	rm -rf nodist/fuzzer/dictionary
 	rm -rf nodist/obj_dir
 	rm -rf verilator.txt

README.rst

@@ -1,7 +1,7 @@
 .. Github doesn't render images unless absolute URL
 .. Do not know of a conditional tag, "only: github" nor "github display" works
 
-|badge1| |badge2| |badge3| |badge4| |badge5| |badge6| |badge7|
+|badge1| |badge2| |badge3| |badge4| |badge5| |badge7| |badge8|
 
 .. |badge1| image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
     :target: https://verilator.org
@@ -13,10 +13,10 @@
     :target: https://repology.org/project/verilator/versions
 .. |badge5| image:: https://img.shields.io/docker/pulls/verilator/verilator
     :target: https://hub.docker.com/r/verilator/verilator
-.. |badge6| image:: https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f
-    :target: https://www.codacy.com/gh/verilator/verilator
 .. |badge7| image:: https://github.com/verilator/verilator/workflows/build/badge.svg
     :target: https://github.com/verilator/verilator/actions?query=workflow%3Abuild
+.. |badge8| image:: https://img.shields.io/github/actions/workflow/status/verilator/verilator/rtlmeter.yml?branch=master&event=schedule&label=benchmarks
+    :target: https://verilator.github.io/verilator-rtlmeter-results
 
 
 Welcome to Verilator
@@ -131,10 +131,10 @@ organizations; please see `Verilator Commercial Support
 Related Projects
 ================
 
-- `GTKwave <http://gtkwave.sourceforge.net/>`_ - Waveform viewer for
+- `GTKwave <https://gtkwave.sourceforge.net/>`_ - Waveform viewer for
   Verilator traces.
 
-- `Icarus Verilog`_ - Icarus is a full-featured interpreted Verilog
+- `Icarus Verilog`_ - Icarus is a highly-featured interpreted Verilog
   simulator. If Verilator does not support your needs, perhaps Icarus may.
 
 

bin/verilator

@@ -130,7 +130,7 @@ if ($opt_gdb) {
 } elsif ($opt_valgrind) {
     # Run under valgrind
     my $valgrind_bin = ($ENV{VERILATOR_VALGRIND} || "valgrind --error-exitcode=1 --max-stackframe=2815880"
-        # Magic number sugested by valgrind, may need to be increased in future
+        # Magic number suggested by Valgrind, may need to be increased in future
         # if you get warnings. See: https://valgrind.org/docs/manual/manual-core.html#opt.max-stackframe
         );
 
@@ -256,7 +256,7 @@ sub sh_escape {
     # This is similar to quotemeta() but less aggressive.
     # There's no need to escape hyphens, periods, or forward slashes
     # for the shell as these have no special meaning to the shell.
-    $arg =~ s/([^0-9a-zA-Z_\-\+\=\.\/])/\\$1/g;
+    $arg =~ s/([^0-9a-zA-Z_\-\+\=\.\/:])/\\$1/g;
     return $arg;
 }
 
@@ -311,8 +311,8 @@ detailed descriptions of these arguments.
      +1800-2012ext+<ext>        Use SystemVerilog 2012 with file extension <ext>
      +1800-2017ext+<ext>        Use SystemVerilog 2017 with file extension <ext>
      +1800-2023ext+<ext>        Use SystemVerilog 2023 with file extension <ext>
-    --assert                    Enable all assertions
-    --assert-case               Enable unique/unique0/priority case related checks
+    --no-assert                 Disable all assertions
+    --no-assert-case            Disable unique/unique0/priority-case assertions
     --autoflush                 Flush streams after all $displays
     --bbox-sys                  Blackbox unknown $system calls
     --bbox-unsup                Blackbox unsupported language features
@@ -341,11 +341,14 @@ detailed descriptions of these arguments.
     --no-debug-leak             Disable leaking memory in --debug mode
     --debugi <level>            Enable debugging at a specified level
     --debugi-<srcfile> <level>  Enable debugging a source file at a level
-    --decorations <level>       Set output comment and spacing level
     --no-decoration             Disable comments and lower spacing level
+    --decorations <level>       Set output comment and spacing level
     --default-language <lang>   Default language to parse
      +define+<var>=<value>      Set preprocessor define
+    --diagnostics-sarif         Enable SARIF diagnostics output
+    --diagnostics-sarif-output <filename>  Set SARIF diagnostics output file
     --dpi-hdr-only              Only produce the DPI header file
+    --dump-<srcfile>            Enable dumping everything in source file
     --dump-defines              Show preprocessor defines with -E
     --dump-dfg                  Enable dumping DfgGraphs to .dot files
     --dump-graph                Enable dumping V3Graphs to .dot files
@@ -353,12 +356,11 @@ detailed descriptions of these arguments.
     --dump-tree-addrids         Use short identifiers instead of addresses
     --dump-tree-dot             Enable dumping Ast .tree.dot debug files
     --dump-tree-json            Enable dumping Ast .tree.json files and .tree.meta.json file
-    --dump-<srcfile>            Enable dumping everything in source file
+    --dumpi-<srcfile> <level>   Enable dumping everything in source file at level
     --dumpi-dfg <level>         Enable dumping DfgGraphs to .dot files at level
     --dumpi-graph <level>       Enable dumping V3Graphs to .dot files at level
     --dumpi-tree <level>        Enable dumping Ast .tree files at level
     --dumpi-tree-json <level>   Enable dumping Ast .tree.json files at level
-    --dumpi-<srcfile> <level>   Enable dumping everything in source file at level
      -E                         Preprocess, but do not compile
     --emit-accessors            Emit getter and setter methods for model top class
     --error-limit <value>       Abort after this number of errors
@@ -381,6 +383,7 @@ detailed descriptions of these arguments.
     --help                      Show this help
     --hierarchical              Enable hierarchical Verilation
     --hierarchical-params-file <name> Internal option that specifies parameters file for hier blocks
+    --hierarchical-threads <threads>  Number of threads for hierarchical scheduling
      -I<dir>                    Directory to search for includes
     --if-depth <value>          Tune IFDEPTH warning
      +incdir+<dir>              Directory to search for includes
@@ -388,10 +391,10 @@ detailed descriptions of these arguments.
     --instr-count-dpi <value>   Assumed dynamic instruction count of DPI imports
      -j <jobs>                  Parallelism for --build-jobs/--verilate-jobs
     --no-json-edit-nums         Don't dump editNum in .tree.json files
-    --no-json-ids               Don't use short identifiers instead of adresses/paths in .tree.json
+    --no-json-ids               Don't use short identifiers instead of addresses/paths in .tree.json
     --json-only                 Create JSON parser output (.tree.json and .meta.json)
-    --json-only-output          .tree.json output filename
-    --json-only-meta-output     .tree.meta.json output filename
+    --json-only-meta-output <filename>  Set .tree.meta.json output filename
+    --json-only-output <filename>       Set .tree.json output filename
     --l2-name <value>           Verilog scope name of the top module
     --language <lang>           Default language standard to parse
      -LDFLAGS <flags>           Linker pre-object arguments for makefile
@@ -399,20 +402,20 @@ detailed descriptions of these arguments.
      +libext+<ext>+[ext]...     Extensions for finding modules
     --lint-only                 Lint, but do not make output
     --localize-max-size <value>  Tune localize optimization variable size
-    --make <build-tool>         Generate scripts for specified build tool
-     -MAKEFLAGS <flags>         Arguments to pass to make during --build
     --main                      Generate C++ main() file
     --main-top-name             Specify top name passed to Verilated model in generated C++ main
+    --make <build-tool>         Generate scripts for specified build tool
+     -MAKEFLAGS <flags>         Arguments to pass to make during --build
     --max-num-width <value>     Maximum number width (default: 64K)
     --Mdir <directory>          Name of output object directory
     --MMD                       Create .d dependency files
     --mod-prefix <topname>      Name to prepend to lower classes
     --MP                        Create phony dependency targets
      +notimingchecks            Ignored
+     -o <executable>            Name of final executable
      -O0                        Disable optimizations
      -O3                        High-performance optimizations
      -O<optimization-letter>    Selectable optimizations
-     -o <executable>            Name of final executable
     --output-groups <numfiles>  Group .cpp files into larger ones
     --output-split <statements>          Split .cpp files into pieces
     --output-split-cfuncs <statements>   Split model functions
@@ -448,7 +451,7 @@ detailed descriptions of these arguments.
     --quiet-exit                Don't print the command on failure
     --quiet-stats               Don't print statistics
     --relative-includes         Resolve includes relative to current file
-    --reloop-limit              Minimum iterations for forming loops
+    --reloop-limit <value>      Minimum iterations for forming loops
     --report-unoptflat          Extra diagnostics for UNOPTFLAT
     --rr                        Run Verilator and record with rr
     --runtime-debug             Enable model runtime debugging
@@ -467,23 +470,25 @@ detailed descriptions of these arguments.
     --threads <threads>         Enable multithreading
     --threads-dpi <mode>        Enable multithreaded DPI
     --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
-    --timing                    Enable timing support
-    --no-timing                 Disable timing support
     --timescale <timescale>     Sets default timescale
     --timescale-override <timescale>  Overrides all timescales
+    --timing                    Enable timing support
+    --no-timing                 Disable timing support
     --top <topname>             Alias of --top-module
     --top-module <topname>      Name of top-level input module
-    --trace                     Enable waveform creation
+    --trace                     Enable VCD waveform creation
     --trace-coverage            Enable tracing of coverage
     --trace-depth <levels>      Depth of tracing
     --trace-fst                 Enable FST waveform creation
     --trace-max-array <depth>   Maximum array depth for tracing
     --trace-max-width <width>   Maximum bit width for tracing
     --trace-params              Enable tracing of parameters
+    --trace-saif                Enable SAIF file creation
     --trace-structs             Enable tracing structure names
     --trace-threads <threads>   Enable FST waveform creation on separate threads
     --no-trace-top              Do not emit traces for signals in the top module generated by verilator
     --trace-underscore          Enable tracing of _signals
+    --trace-vcd                 Enable VCD waveform creation
      -U<var>                    Undefine preprocessor define
     --no-unlimited-stack        Don't disable stack size limit
     --unroll-count <loops>      Tune maximum loop iterations
@@ -492,8 +497,8 @@ detailed descriptions of these arguments.
      -V                         Verbose version and config
      -v <filename>              Verilog library
     --valgrind                  Run Verilator under valgrind
-    --verilate-jobs             Job threads for Verilation stage
     --no-verilate               Skip Verilation and just compile previously Verilated code
+    --verilate-jobs             Job threads for Verilation stage
      +verilog1995ext+<ext>      Synonym for +1364-1995ext+<ext>
      +verilog2001ext+<ext>      Synonym for +1364-2001ext+<ext>
     --version                   Show program version and exits
@@ -508,6 +513,7 @@ detailed descriptions of these arguments.
      -Wno-fatal                 Disable fatal exit on warnings
      -Wno-lint                  Disable all lint warnings
      -Wno-style                 Disable all style warnings
+     -work <libname>            Set config library for following files
      -Wpedantic                 Warn on compliance-test issues
      -Wwarn-<message>           Enable specified warning message
      -Wwarn-lint                Enable lint warning message
@@ -526,9 +532,9 @@ description of these arguments.
 
 =for VL_SPHINX_EXTRACT "_build/gen/args_verilated.rst"
 
+     +verilator+coverage+file+<filename>   Set coverage output filename
      +verilator+debug                      Enable debugging
      +verilator+debugi+<value>             Enable debugging at a level
-     +verilator+coverage+file+<filename>   Set coverage output filename
      +verilator+error+limit+<value>        Set error limit
      +verilator+help                       Show help
      +verilator+noassert                   Disable assert checking

bin/verilator_coverage

@@ -170,6 +170,7 @@ L<https://verilator.org/guide/latest/exe_verilator_coverage.html>.
     --annotate-all                All files should be shown.
     --annotate-min <count>        Minimum occurrence count for uncovered.
     --annotate-points             Annotates info from each coverage point.
+    --filter-type <regex>         Keep only records of given coverage type.
     --help                        Displays this message and version and exits.
     --rank                        Compute relative importance of tests.
     --unlink                      With --write, unlink all inputs

bin/verilator_gantt

@@ -8,17 +8,27 @@ import collections
 import math
 import re
 import statistics
+from collections import OrderedDict
 # from pprint import pprint
 
-Sections = []
+Sections = OrderedDict()
 LongestVcdStrValueLength = 0
 Threads = collections.defaultdict(lambda: [])  # List of records per thread id
 Mtasks = collections.defaultdict(lambda: {'elapsed': 0, 'end': 0})
 Cpus = collections.defaultdict(lambda: {'mtask_time': 0})
-Global = {'args': {}, 'cpuinfo': collections.defaultdict(lambda: {}), 'stats': {}}
+Global = {
+    'args': {},
+    'cpuinfo': collections.defaultdict(lambda: {}),
+    'info': {
+        'numa': 'no data'
+    },
+    'stats': {}
+}
 ElapsedTime = None  # total elapsed time
-ExecGraphTime = 0  # total elapsed time excuting an exec graph
+ExecGraphTime = 0  # total elapsed time executing an exec graph
+WaitingTime = 0  # total elapsed time waiting for mtasks
 ExecGraphIntervals = []  # list of (start, end) pairs
+ThreadScheduleWaitIntervals = []  # list of (start, tick, ecpu) pairs
 
 ######################################################################
 
@@ -27,23 +37,29 @@ def read_data(filename):
     with open(filename, "r", encoding="utf8") as fh:
         re_thread = re.compile(r'^VLPROFTHREAD (\d+)$')
         re_record = re.compile(r'^VLPROFEXEC (\S+) (\d+)(.*)$')
-        re_payload_mtaskBegin = re.compile(r'id (\d+) predictStart (\d+) cpu (\d+)')
-        re_payload_mtaskEnd = re.compile(r'id (\d+) predictCost (\d+)')
+        # The hierBlock argument is optional
+        re_payload_mtaskBegin = re.compile(
+            r'id (\d+) predictStart (\d+) cpu (\d+)(?: hierBlock)?\s*(\w+)?')
+        re_payload_mtaskEnd = re.compile(r'predictCost (\d+)')
+        re_payload_wait = re.compile(r'cpu (\d+)')
 
         re_arg1 = re.compile(r'VLPROF arg\s+(\S+)\+([0-9.]*)\s*')
         re_arg2 = re.compile(r'VLPROF arg\s+(\S+)\s+([0-9.]*)\s*$')
-        re_stat = re.compile(r'VLPROF stat\s+(\S+)\s+([0-9.]+)')
+        re_info = re.compile(r'VLPROF info\s+(\S+)\s+(.*)$')
+        re_stat = re.compile(r'VLPROF stat\s+(\S+)\s+(\S+)')
         re_proc_cpu = re.compile(r'VLPROFPROC processor\s*:\s*(\d+)\s*$')
         re_proc_dat = re.compile(r'VLPROFPROC ([a-z_ ]+)\s*:\s*(.*)$')
         cpu = None
         thread = 0
-        execGraphStart = None
 
         global LongestVcdStrValueLength
         global ExecGraphTime
+        global WaitingTime
 
+        ExecGraphStack = []
         SectionStack = []
-        mTaskThread = {}
+        MtasksStack = []
+        ThreadScheduleWait = collections.defaultdict(list)
 
         for line in fh:
             recordMatch = re_record.match(line)
@@ -60,44 +76,57 @@ def read_data(filename):
                     SectionStack.pop()
                     Sections[thread].append((tick, tuple(SectionStack)))
                 elif kind == "MTASK_BEGIN":
-                    mtask, predict_start, ecpu = re_payload_mtaskBegin.match(payload).groups()
+                    mtask, predict_start, ecpu, hier_block = re_payload_mtaskBegin.match(
+                        payload).groups()
+                    hier_block = "" if hier_block is None else hier_block
                     mtask = int(mtask)
                     predict_start = int(predict_start)
                     ecpu = int(ecpu)
-                    mTaskThread[mtask] = thread
                     records = Threads[thread]
-                    assert not records or records[-1]['start'] <= records[-1]['end'] <= tick
                     records.append({
                         'start': tick,
                         'mtask': mtask,
                         'predict_start': predict_start,
+                        'hier_block': hier_block,
                         'cpu': ecpu
                     })
-                    Mtasks[mtask]['begin'] = tick
-                    Mtasks[mtask]['thread'] = thread
-                    Mtasks[mtask]['predict_start'] = predict_start
+                    Mtasks[(hier_block, mtask)]['begin'] = tick
+                    Mtasks[(hier_block, mtask)]['predict_start'] = predict_start
+                    Mtasks[(hier_block, mtask)]['thread'] = thread
+                    MtasksStack.append((hier_block, mtask, records[-1]))
                 elif kind == "MTASK_END":
-                    mtask, predict_cost = re_payload_mtaskEnd.match(payload).groups()
+                    predict_cost, = re_payload_mtaskEnd.match(payload).groups()
                     mtask = int(mtask)
+                    hier_block, mtask, record = MtasksStack.pop()
                     predict_cost = int(predict_cost)
-                    begin = Mtasks[mtask]['begin']
-                    record = Threads[mTaskThread[mtask]][-1]
+                    begin = Mtasks[(hier_block, mtask)]['begin']
                     record['end'] = tick
+                    assert record and records[-1]['start'] <= records[-1]['end'] <= tick
                     record['predict_cost'] = predict_cost
-                    Mtasks[mtask]['elapsed'] += tick - begin
-                    Mtasks[mtask]['predict_cost'] = predict_cost
-                    Mtasks[mtask]['end'] = max(Mtasks[mtask]['end'], tick)
+                    Mtasks[(hier_block, mtask)]['elapsed'] += tick - begin
+                    Mtasks[(hier_block, mtask)]['predict_cost'] = predict_cost
+                    Mtasks[(hier_block, mtask)]['end'] = max(Mtasks[(hier_block, mtask)]['end'],
+                                                             tick)
+                elif kind == "THREAD_SCHEDULE_WAIT_BEGIN":
+                    ecpu = int(re_payload_wait.match(payload).groups()[0])
+                    ThreadScheduleWait[ecpu].append(tick)
+                elif kind == "THREAD_SCHEDULE_WAIT_END":
+                    ecpu = int(re_payload_wait.match(payload).groups()[0])
+                    start = ThreadScheduleWait[ecpu].pop()
+                    WaitingTime += tick - start
+                    ThreadScheduleWaitIntervals.append((start, tick, ecpu))
                 elif kind == "EXEC_GRAPH_BEGIN":
-                    execGraphStart = tick
+                    ExecGraphStack.append(tick)
                 elif kind == "EXEC_GRAPH_END":
+                    assert ExecGraphStack, "EXEC_GRAPH_END without EXEC_GRAPH_BEGIN"
+                    execGraphStart = ExecGraphStack.pop()
                     ExecGraphTime += tick - execGraphStart
                     ExecGraphIntervals.append((execGraphStart, tick))
-                    execGraphStart = None
                 elif Args.debug:
                     print("-Unknown execution trace record: %s" % line)
             elif re_thread.match(line):
                 thread = int(re_thread.match(line).group(1))
-                Sections.append([])
+                Sections[thread] = []
             elif re.match(r'^VLPROF(THREAD|VERSION)', line):
                 pass
             elif re_arg1.match(line):
@@ -106,6 +135,9 @@ def read_data(filename):
             elif re_arg2.match(line):
                 match = re_arg2.match(line)
                 Global['args'][match.group(1)] = match.group(2)
+            elif re_info.match(line):
+                match = re_info.match(line)
+                Global['info'][match.group(1)] = match.group(2)
             elif re_stat.match(line):
                 match = re_stat.match(line)
                 Global['stats'][match.group(1)] = match.group(2)
@@ -156,11 +188,13 @@ def report():
     print("\nSummary:")
     print("  Total elapsed time = {} rdtsc ticks".format(ElapsedTime))
     print("  Parallelized code  = {:.2%} of elapsed time".format(ExecGraphTime / ElapsedTime))
+    print("  Waiting time       = {:.2%} of elapsed time".format(WaitingTime / ElapsedTime))
     print("  Total threads      = %d" % nthreads)
     print("  Total CPUs used    = %d" % ncpus)
     print("  Total mtasks       = %d" % len(Mtasks))
     print("  Total yields       = %d" % int(Global['stats'].get('yields', 0)))
 
+    report_numa()
     report_mtasks()
     report_cpus()
     report_sections()
@@ -181,6 +215,11 @@ def report():
     print()
 
 
+def report_numa():
+    print("\nNUMA assignment:")
+    print("  NUMA status        = %s" % Global['info']['numa'])
+
+
 def report_mtasks():
     if not Mtasks:
         return
@@ -199,10 +238,11 @@ def report_mtasks():
     thread_mtask_time = collections.defaultdict(lambda: 0)
     long_mtask_time = 0
     long_mtask = None
+    long_mtask_hier_block = None
     predict_mtask_time = 0
     predict_elapsed = 0
-    for mtaskId in Mtasks:
-        record = Mtasks[mtaskId]
+    for (hier_block, mtask_id) in Mtasks:
+        record = Mtasks[(hier_block, mtask_id)]
         predict_mtask_time += record['predict_cost']
         total_mtask_time += record['elapsed']
         thread_mtask_time[record['thread']] += record['elapsed']
@@ -210,7 +250,8 @@ def report_mtasks():
         predict_elapsed = max(predict_elapsed, predict_end)
         if record['elapsed'] > long_mtask_time:
             long_mtask_time = record['elapsed']
-            long_mtask = mtaskId
+            long_mtask = mtask_id
+            long_mtask_hier_block = hier_block
     Global['predict_last_end'] = predict_elapsed
 
     serialTime = ElapsedTime - ExecGraphTime
@@ -239,31 +280,55 @@ def report_mtasks():
     max_p2e = -1000000
     max_mtask = None
 
-    for mtask in sorted(Mtasks.keys()):
-        if Mtasks[mtask]['elapsed'] > 0:
-            if Mtasks[mtask]['predict_cost'] == 0:
-                Mtasks[mtask]['predict_cost'] = 1  # don't log(0) below
-            p2e_ratio = math.log(Mtasks[mtask]['predict_cost'] / Mtasks[mtask]['elapsed'])
+    min_hier_block = None
+    max_hier_block = None
+
+    for (hier_block, mtask_id) in sorted(Mtasks.keys()):
+        mtask = Mtasks[(hier_block, mtask_id)]
+        if mtask['elapsed'] > 0:
+            if mtask['predict_cost'] == 0:
+                mtask['predict_cost'] = 1  # don't log(0) below
+            p2e_ratio = math.log(mtask['predict_cost'] / mtask['elapsed'])
             p2e_ratios.append(p2e_ratio)
 
             if p2e_ratio > max_p2e:
                 max_p2e = p2e_ratio
-                max_mtask = mtask
+                max_mtask = mtask_id
+                max_hier_block = hier_block
             if p2e_ratio < min_p2e:
                 min_p2e = p2e_ratio
-                min_mtask = mtask
+                min_mtask = mtask_id
+                min_hier_block = hier_block
 
     print("\nMTask statistics:")
-    print("  Longest mtask id = {}".format(long_mtask))
+    if long_mtask_hier_block:
+        print("  Longest mtask id = {} from hier_block '{}'".format(long_mtask,
+                                                                    long_mtask_hier_block))
+    else:
+        print("  Longest mtask id = {}".format(long_mtask))
     print("  Longest mtask time = {:.2%} of time elapsed in parallelized code".format(
         long_mtask_time / ExecGraphTime))
     print("  min log(p2e) = %0.3f" % min_p2e, end="")
 
-    print("  from mtask %d (predict %d," % (min_mtask, Mtasks[min_mtask]['predict_cost']), end="")
-    print(" elapsed %d)" % Mtasks[min_mtask]['elapsed'])
+    if min_hier_block:
+        print("  from hier_block '%s' mtask %d (predict %d," %
+              (min_hier_block, min_mtask, Mtasks[(min_hier_block, min_mtask)]['predict_cost']),
+              end="")
+    else:
+        print("  from mtask %d (predict %d," %
+              (min_mtask, Mtasks[(min_hier_block, min_mtask)]['predict_cost']),
+              end="")
+    print(" elapsed %d)" % Mtasks[(min_hier_block, min_mtask)]['elapsed'])
     print("  max log(p2e) = %0.3f" % max_p2e, end="")
-    print("  from mtask %d (predict %d," % (max_mtask, Mtasks[max_mtask]['predict_cost']), end="")
-    print(" elapsed %d)" % Mtasks[max_mtask]['elapsed'])
+    if max_hier_block:
+        print("  from hier_block '%s' mtask %d (predict %d," %
+              (max_hier_block, max_mtask, Mtasks[(max_hier_block, max_mtask)]['predict_cost']),
+              end="")
+    else:
+        print("  from mtask %d (predict %d," %
+              (max_mtask, Mtasks[(max_hier_block, max_mtask)]['predict_cost']),
+              end="")
+    print(" elapsed %d)" % Mtasks[(max_hier_block, max_mtask)]['elapsed'])
 
     stddev = statistics.pstdev(p2e_ratios)
     mean = statistics.mean(p2e_ratios)
@@ -308,7 +373,7 @@ def report_cpus():
 
 
 def report_sections():
-    for thread, section in enumerate(Sections):
+    for thread, section in Sections.items():
         if section:
             print(f"\nSection profile for thread {thread}:")
             report_section(section)
@@ -403,6 +468,9 @@ def write_vcd(filename):
                 val = buf.ljust(LongestVcdStrValueLength * 8, "0")
             values[time][code] = val
 
+        def addXValue(code, time):
+            values[time][code] = 'x'
+
         # Measured graph
         for thread in sorted(Threads):
             mcode = getCode(32, 'measured', 't%d_mtask' % thread)
@@ -427,27 +495,36 @@ def write_vcd(filename):
         tStart = sorted(_['start'] for records in Threads.values() for _ in records)
         tEnd = sorted(_['end'] for records in Threads.values() for _ in records)
 
+        # Measured waiting time
+        for (start, end, cpu) in ThreadScheduleWaitIntervals:
+            mcode = getCode(32, 'measured', 'cpu%d_waiting' % cpu)
+            addXValue(mcode, start)
+            addValue(mcode, end, None)
+
         # Predicted graph
         for start, end in ExecGraphIntervals:
             # Find the earliest MTask start after the start point, and the
             # latest MTask end before the end point, so we can scale to the
             # same range
-            start = tStart[bisect.bisect_left(tStart, start)]
+            tStartIdx = bisect.bisect_left(tStart, start)
+            if tStartIdx >= len(tStart):
+                continue
+            start = tStart[tStartIdx]
             end = tEnd[bisect.bisect_right(tEnd, end) - 1]
             # Compute scale so predicted graph is of same width as interval
             measured_scaling = (end - start) / Global['predict_last_end']
             # Predict mtasks that fill the time the execution occupied
-            for mtask in Mtasks:
-                thread = Mtasks[mtask]['thread']
-                pred_scaled_start = start + int(Mtasks[mtask]['predict_start'] * measured_scaling)
+            for (hier_block, mtask_id) in Mtasks:
+                mtask = Mtasks[(hier_block, mtask_id)]
+                thread = mtask['thread']
+                pred_scaled_start = start + int(mtask['predict_start'] * measured_scaling)
                 pred_scaled_end = start + int(
-                    (Mtasks[mtask]['predict_start'] + Mtasks[mtask]['predict_cost']) *
-                    measured_scaling)
+                    (mtask['predict_start'] + mtask['predict_cost']) * measured_scaling)
                 if pred_scaled_start == pred_scaled_end:
                     continue
 
                 mcode = getCode(32, 'predicted', 't%d_mtask' % thread)
-                addValue(mcode, pred_scaled_start, mtask)
+                addValue(mcode, pred_scaled_start, mtask_id)
                 addValue(mcode, pred_scaled_end, None)
 
                 parallelism['predicted'][pred_scaled_start] += 1
@@ -462,7 +539,7 @@ def write_vcd(filename):
                 addValue(pcode, time, value)
 
         # Section graph
-        for thread, section in enumerate(Sections):
+        for thread, section in Sections.items():
             if section:
                 scode = getCode(LongestVcdStrValueLength * 8, "section", f"t{thread}_trace")
                 dcode = getCode(32, "section", f"t{thread}_depth")
@@ -510,6 +587,8 @@ def write_vcd(filename):
                 value = values[time][code]
                 if value is None:
                     fh.write("bz v%x\n" % code)
+                elif value == 'x':
+                    fh.write("bx v%x\n" % code)
                 elif isinstance(value, str):
                     fh.write("b%s v%x\n" % (value, code))
                 else:
@@ -538,7 +617,7 @@ SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
 
 parser.add_argument('--debug', action='store_true', help='enable debug')
 parser.add_argument('--no-vcd', help='disable creating vcd', action='store_true')
-parser.add_argument('--vcd', help='filename for vcd outpue', default='profile_exec.vcd')
+parser.add_argument('--vcd', help='filename for vcd output', default='profile_exec.vcd')
 parser.add_argument('filename',
                     help='input profile_exec.dat filename to process',
                     default='profile_exec.dat')

ci/ci-install.bash

@@ -40,7 +40,7 @@ fi
 install-vcddiff() {
   TMP_DIR="$(mktemp -d)"
   git clone https://github.com/veripool/vcddiff "$TMP_DIR"
-  git -C "${TMP_DIR}" checkout e5664be5fe39d353bf3fcb50aa05214ab7ed4ac4
+  git -C "${TMP_DIR}" checkout dca845020668887fd13498c772939814d9264fd5
   "$MAKE" -C "${TMP_DIR}"
   sudo cp "${TMP_DIR}/vcddiff" /usr/local/bin
 }
@@ -55,16 +55,16 @@ if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then
     sudo apt-get update
     sudo apt-get install ccache help2man libfl-dev ||
     sudo apt-get install ccache help2man libfl-dev
-    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ]; then
+    if [[ ! "$CI_RUNS_ON" =~ "ubuntu-22.04" ]]; then
       # Some conflict of libunwind verison on 22.04, can live without it for now
       sudo apt-get install libgoogle-perftools-dev ||
       sudo apt-get install libgoogle-perftools-dev
     fi
-    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ] || [ "$CI_RUNS_ON" = "ubuntu-22.04" ] || [ "$CI_RUNS_ON" = "ubuntu-24.04" ]; then
+    if [[ "$CI_RUNS_ON" =~ "ubuntu-20.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
       sudo apt-get install libsystemc libsystemc-dev ||
       sudo apt-get install libsystemc libsystemc-dev
     fi
-    if [ "$CI_RUNS_ON" = "ubuntu-22.04" ] || [ "$CI_RUNS_ON" = "ubuntu-24.04" ]; then
+    if [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
       sudo apt-get install bear mold ||
       sudo apt-get install bear mold
     fi
@@ -92,11 +92,11 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
     sudo apt-get install gdb gtkwave lcov libfl-dev ccache jq z3 ||
     sudo apt-get install gdb gtkwave lcov libfl-dev ccache jq z3
     # Required for test_regress/t/t_dist_attributes.py
-    if [ "$CI_RUNS_ON" = "ubuntu-22.04" ] || [ "$CI_RUNS_ON" = "ubuntu-24.04" ]; then
+    if [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
       sudo apt-get install python3-clang mold ||
       sudo apt-get install python3-clang mold
     fi
-    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ] || [ "$CI_RUNS_ON" = "ubuntu-22.04" ] || [ "$CI_RUNS_ON" = "ubuntu-24.04" ]; then
+    if [[ "$CI_RUNS_ON" =~ "ubuntu-20.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-22.04" ]] || [[ "$CI_RUNS_ON" =~ "ubuntu-24.04" ]]; then
       sudo apt-get install libsystemc-dev ||
       sudo apt-get install libsystemc-dev
     fi

ci/ci-script.bash

@@ -87,7 +87,7 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   fi
 
   # Run sanitize on Ubuntu 22.04 only
-  ( [ "$CI_RUNS_ON" = 'ubuntu-22.04' ] || [ "$CI_RUNS_ON" = 'ubuntu-24.04' ] ) && sanitize='--sanitize' || sanitize=''
+  ( [[ "$CI_RUNS_ON" =~ 'ubuntu-22.04' ]] || [[ "$CI_RUNS_ON" =~ 'ubuntu-24.04' ]] ) && sanitize='--sanitize' || sanitize=''
 
   TEST_REGRESS=test_regress
   if [ "$CI_RELOC" == 1 ]; then
@@ -98,6 +98,8 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
      export VERILATOR_ROOT="$RELOC_DIR/relocated-install/share/verilator"
      TEST_REGRESS="$RELOC_DIR/test_regress"
      mv test_regress "$TEST_REGRESS"
+     NODIST="$RELOC_DIR/nodist"
+     mv nodist "$NODIST"
      # Feeling brave?
      find . -delete
      ls -la .
@@ -107,22 +109,25 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
   ccache -z
   case $TESTS in
     dist-vlt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/4
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean $sanitize" DRIVER_HASHSET=--hashset=0/4
       ;;
     dist-vlt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/4
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean $sanitize" DRIVER_HASHSET=--hashset=1/4
       ;;
     dist-vlt-2)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=2/4
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean $sanitize" DRIVER_HASHSET=--hashset=2/4
       ;;
     dist-vlt-3)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=3/4
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt --driver-clean $sanitize" DRIVER_HASHSET=--hashset=3/4
       ;;
     vltmt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=0/3
       ;;
     vltmt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=1/3
+      ;;
+    vltmt-2)
+      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--vltmt --driver-clean" DRIVER_HASHSET=--hashset=2/3
       ;;
     coverage-all)
       nodist/code_coverage --stages 1-

ci/docker/buildenv/Dockerfile

@@ -6,7 +6,7 @@
 # Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 # Create the user
 RUN groupadd verilator \
@@ -36,12 +36,14 @@ RUN apt-get update \
                         help2man \
                         libfl2 \
                         libfl-dev \
+                        libclang-rt-18-dev \
                         libgoogle-perftools-dev \
                         libsystemc \
                         libsystemc-dev \
                         numactl \
                         perl \
                         python3 \
+                        python3-distro \
                         wget \
                         z3 \
                         zlib1g \

ci/docker/buildenv/README.rst

@@ -13,7 +13,7 @@ Verilator build. It uses the following parameters:
 
 -  Source revision (default: master)
 
--  Compiler (GCC 10.3.0, clang 10.0.0, default: 10.3.0)
+-  Compiler (GCC 13.3.0, clang 18.1.3, default: 13.3.0)
 
 The container is published as ``verilator/verilator-buildenv`` on `docker
 hub
@@ -31,18 +31,18 @@ To also run tests:
 
    docker run -ti verilator/verilator-buildenv test
 
-To change the compiler:
+To change the compiler use the `-e` switch to pass environment variables:
 
 ::
 
-   docker run -ti -e CC=clang-10 -e CXX=clang++-10 verilator/verilator-buildenv test
+   docker run -ti -e CC=clang-18 -e CXX=clang++-18 verilator/verilator-buildenv test
 
-The tests that involve gdb are not working due to security restrictions.
-To run those too:
+The tests, that involve numactl are not working due to security restrictions.
+To run those too, add the CAP_SYS_NICE capability during the start of the container:
 
 ::
 
-   docker run -ti -e CC=clang-10 -e CXX=clang++-10 --cap-add=SYS_PTRACE --security-opt seccomp=unconfined verilator/verilator-buildenv test
+   docker run -ti --cap-add=CAP_SYS_NICE 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
@@ -52,7 +52,7 @@ 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
+   docker run -ti -v ${PWD}:/tmp/repo -e REPO=/tmp/repo -e REV=`git rev-parse --short HEAD` verilator/verilator-buildenv test
 
 
 Rebuilding

ci/docker/run/Dockerfile

@@ -6,7 +6,7 @@
 # Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 RUN apt-get update \
     && DEBIAN_FRONTEND=noninteractive \
@@ -48,7 +48,8 @@ RUN git clone "${REPO}" verilator && \
     make && \
     make install && \
     cd .. && \
-    rm -r verilator
+    rm -r verilator && \
+    ccache -C
 
 COPY verilator-wrap.sh /usr/local/bin/verilator-wrap.sh
 

configure.ac

@@ -7,10 +7,11 @@
 
 # When releasing, also update header of Changes file, and CMakeLists.txt,
 # and commit using "devel release" or "Version bump" message
+# Then 'make distclean' 'autoconf' './configure' 'make' 'make test'
 # Then 'make maintainer-dist'
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[5.034 2025-02-24],
+AC_INIT([Verilator],[5.040 2025-08-30],
         [https://verilator.org],
         [verilator],[https://verilator.org])
 
@@ -68,6 +69,7 @@ AC_ARG_ENABLE([tcmalloc],
                 *)   AC_MSG_ERROR([bad value '${enableval}' for --enable-tcmalloc]) ;;
                esac],
               [CFG_WITH_TCMALLOC=check;])
+AC_SUBST(CFG_WITH_TCMALLOC)
 AC_MSG_RESULT($CFG_WITH_TCMALLOC)
 
 # Flag to enable coverage build
@@ -177,7 +179,7 @@ AC_PROG_INSTALL
 
 AC_LANG_PUSH(C++)
 CFG_CXX_VERSION=`$CXX --version | head -1`
-AC_MSG_RESULT([compiler $CXX --version = $CFG_CXX_VERSION])
+AC_MSG_RESULT([compiler version... $CXX --version = $CFG_CXX_VERSION])
 AC_SUBST(CFG_CXX_VERSION)
 
 AC_MSG_CHECKING([that C++ compiler can compile simple program])
@@ -432,9 +434,10 @@ AC_SUBST(HAVE_COROUTINES)
 
 # Flags for compiling Verilator internals including parser always
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Qunused-arguments)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
-_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
 _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-shadow)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Wno-unused-parameter)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-Xclang -fno-pch-timestamp)
+_MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-faligned-new)
 AC_SUBST(CFG_CXXFLAGS_SRC)
 
 # Flags for compiling Verilator parser always (in addition to above CFG_CXXFLAGS_SRC)
@@ -469,11 +472,13 @@ CFG_CXX_FLAGS_CMAKE="-faligned-new"
 m4_foreach([cflag],[
         [-fbracket-depth=4096],
         [-fcf-protection=none],
+        [-Xclang -fno-pch-timestamp],
         [-mno-cet],
         [-Qunused-arguments],
         [-Wno-bool-operation],
         [-Wno-c++11-narrowing],
         [-Wno-constant-logical-operand],
+        [-Wno-int-in-bool-context],
         [-Wno-non-pod-varargs],
         [-Wno-parentheses-equality],
         [-Wno-shadow],
@@ -515,7 +520,7 @@ if test "$CFG_ENABLE_PARTIAL_STATIC" = "yes"; then
   _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -static-libgcc)
   _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -static-libstdc++)
   _MY_LDLIBS_CHECK_OPT(CFG_LDFLAGS_SRC, -Xlinker -gc-sections)
-  LTCMALLOC=-l:libtcmalloc_minimal.a
+  LTCMALLOC="-Wl,--whole-archive -l:libtcmalloc_minimal.a -Wl,--no-whole-archive"
 else
   LTCMALLOC=-ltcmalloc_minimal
 fi
@@ -544,10 +549,12 @@ _MY_LDLIBS_CHECK_IFELSE(
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-calloc)
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-realloc)
     _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_SRC,-fno-builtin-free)
+    AC_DEFINE([HAVE_TCMALLOC],[1],[Defined if have tcmalloc])
    fi],
   [if test "$CFG_WITH_TCMALLOC" = "yes"; then
     AC_MSG_ERROR([--enable-tcmalloc was given but test for ${LTCMALLOC} failed])
    fi])
+AC_SUBST(HAVE_TCMALLOC)
 AC_SUBST(CFG_LIBS)
 
 # Need C++14 at least

docs/CONTRIBUTORS

@@ -3,6 +3,7 @@ under the Developer Certificate of Origin (https://developercertificate.org/).
 
 Please see the Verilator manual for 200+ additional contributors. Thanks to all.
 
+404allen404
 Adam Bagley
 Adrian Sampson
 Adrien Le Masle
@@ -11,7 +12,6 @@ Aidan McNay
 Aleksander Kiryk
 Alex Chadwick
 Alex Solomatnikov
-Àlex Torregrosa
 Aliaksei Chapyzhenka
 Ameya Vikram Singh
 Andrea Calabrese
@@ -19,12 +19,15 @@ Andreas Kuster
 Andrei Kostovski
 Andrew Miloradovsky
 Andrew Nolte
+Andrew Voznytsa
 Anthony Donlon
 Anthony Moore
 Arkadiusz Kozdra
 Arthur Rosa
+Artur Bieniek
 Aylon Chaim Porat
 Bartłomiej Chmiel
+Brian Li
 Cameron Kirk
 Chih-Mao Chen
 Chris Bachhuber
@@ -32,17 +35,20 @@ Chris Randall
 Christopher Taylor
 Chuxuan Wang
 Chykon
+Congcong Cai
 Conor McCullough
 Dan Petrisko
+Danny Oler
 Daniel Bates
+Dave Sargeant
 David Horton
 David Ledger
 David Metz
-Dave Sargeant
 David Stanford
 David Turner
 Dercury
 Diego Roux
+Dominick Grochowina
 Don Williamson
 Drew Ranck
 Drew Taussig
@@ -52,26 +58,27 @@ Eric Müller
 Eric Rippey
 Ethan Sifferman
 Eyck Jentzsch
-Furqan Nadir
 Fabian Keßler
 Fan Shupei
-february cozzocrea
 Felix Neumärker
 Felix Yan
 Frans Skarman
 Fuad Ismail
+Furqan Nadir
 G-A. Kamendje
 Garrett Smith
+George Polack
 Geza Lore
 Gianfranco Costamagna
 Gijs Burghoorn
+Gilberto Abram
 Glen Gibb
-Gökçe Aydos
 Graham Rushton
 Greg Davill
 Guokai Chen
 Gus Smith
 Gustav Svensk
+Gökçe Aydos
 Han Qi
 Harald Heckmann
 Hennadii Chernyshchyk
@@ -80,7 +87,8 @@ Huang Rui
 Huanghuang Zhou
 HungMingWu
 HyungKi Jeong
-Ícaro Lima
+Ibrahim Burak Yorulmaz
+Igor Zaworski
 Ilya Barkov
 Iru Cai
 Ivan Vnučec
@@ -94,19 +102,21 @@ James Shi
 Jamey Hicks
 Jamie Iles
 Jan Van Winkel
-Jiangjie Weng
 Jean Berniolles
 Jeremy Bennett
 Jesse Taube
 Jevin Sweval
 Jiacheng Qian
 Jiamin Zhu
-Jitesh Nayak
+Jiangjie Weng
 Jinyan Xu
+Jitesh Nayak
 Jiuyang Liu
+Joel Bodenmann
 Joey Liu
 John Coiner
 John Demme
+John Khoo
 John Wehle
 Jonathan Drolet
 Jonathan Schröter
@@ -132,6 +142,7 @@ Krzysztof Boronski
 Krzysztof Boroński
 Krzysztof Obłonczek
 Krzysztof Starecki
+Krzysztof Sychla
 Kuba Ober
 Larry Doolittle
 Liam Braun
@@ -148,11 +159,14 @@ Marlon James
 Marshal Qiao
 Martin Schmidt
 Martin Stadler
+Mateusz Gancarz
 Matthew Ballance
+Max Wipfli
+Michael Bedford Taylor
 Michael Bikovitsky
 Michael Killough
-Michaël Lefebvre
 Michal Czyz
+Michaël Lefebvre
 Mike Popoloski
 Miodrag Milanović
 Mladen Slijepcevic
@@ -174,9 +188,11 @@ Paul Wright
 Pawel Jewstafjew
 Pawel Sagan
 Pengcheng Xu
+Peter Birch
 Peter Debacker
 Peter Horvath
 Peter Monsson
+Petr Nohavica
 Philip Axer
 Philipp Wagner
 Pierre-Henri Horrein
@@ -191,37 +207,41 @@ Ricardo Barbedo
 Richard Myers
 Risto Pejašinović
 Robert Balas
+Robin Heinemann
+Rodrigo Batista de Moraes
 Rupert Swarbrick
 Ryan Ziegler
 Ryszard Rozak
 Samuel Riedel
 Sean Cross
 Sebastien Van Cauwenberghe
+Sergey Fedorov
 Sergi Granell
 Seth Pellegrino
+Shou-Li Hsu
 Srinivasan Venkataramanan
 Stefan Wallentowitz
 Stephen Henry
 Steven Hugg
-sumpster
 Szymon Gizler
 Sören Tempel
 Teng Huang
-Tom Manner
 Tim Hutt
 Tim Snyder
+Tobias Jensen
 Tobias Rosenkranz
 Tobias Wölfel
 Todd Strader
+Tom Manner
 Tomasz Gorochowik
 Topa Topino
 Toru Niina
 Trung Nguyen
 Tudor Timi
 Tymoteusz Blazejczyk
+Udaya Raj Subedi
 Udi Finkelstein
 Unai Martinez-Corral
-Udaya Raj Subedi
 Valentin Atepalikhin
 Varun Koyyalagunta
 Vassilis Papaefstathiou
@@ -242,7 +262,11 @@ Yuri Victorovich
 Yutetsu TAKATSUKASA
 Yves Mathieu
 Zhanglei Wang
+Zhen Yan
 Zhou Shen
+Zhouyi Shen
 Zixi Li
-أحمد المحمودي
-404allen404
+february cozzocrea
+sumpster
+Àlex Torregrosa
+Ícaro Lima

docs/Makefile

@@ -25,7 +25,7 @@ BUILDDIR = _build
 
 SPHINXOPTS ?= -c guide -j 4
 ifneq ($(VERILATOR_ANALYTICS_ID),)
-SPHINXOPTS += -D html_theme_options.analytics_id=$(VERILATOR_ANALYTICS_ID)
+  SPHINXOPTS += -D html_theme_options.analytics_id=$(VERILATOR_ANALYTICS_ID)
 endif
 
 ######################################################################
@@ -68,15 +68,21 @@ pdf:
 
 ######################################################################
 
-html latex linkcheck spelling::
+html latex linkcheck::
 	$(MAKE) vl-extract
 	$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS)
 	$(PYTHON3) bin/vl_sphinx_fix _build
 
+spelling::
+	$(MAKE) vl-extract
+	$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS)
+	sort -o guide/spelling.txt guide/spelling.txt
+
 help:
 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS)
 
 clean mostlyclean distclean maintainer-clean::
+	rm -rf _build
 	rm -f $(SCRIPTS) *.tmp
 	rm -f *.aux *.cp *.cps *.dvi *.fn *.fns *.ky *.kys *.log
 	rm -f *.pg *.pgs *.toc *.tp *.tps *.vr *.vrs *.idx

docs/gen/ex_ALWNEVER_faulty.rst

@@ -0,0 +1,4 @@
+.. comment: generated by t_event_control_star_never_bad
+.. code-block:: sv
+
+     always @* a = 100;

docs/gen/ex_ALWNEVER_msg.rst

@@ -0,0 +1,4 @@
+.. comment: generated by t_event_control_star_never_bad
+.. code-block::
+
+   %Warning-ALWNEVER: example.v:1:3 'always @*' will never execute as expression list is empty (no variables read)

docs/gen/ex_BADVLTPRAGMA_faulty.rst

@@ -0,0 +1,5 @@
+.. comment: generated by t_lint_badvltpragma_bad
+.. code-block:: sv
+   :emphasize-lines: 1
+
+      // verilator lintt_off WIDTH  //<--- Warning (lint_off misspelled)

docs/gen/ex_BADVLTPRAGMA_msg.rst

@@ -0,0 +1,7 @@
+.. comment: generated by t_lint_badvltpragma_bad
+.. code-block::
+   :emphasize-lines: 1,2
+
+   %Error-BADVLTPRAGMA: example.v:1:4 Unknown verilator comment: '/*verilator lintt_off WIDTH <--- Warning (lint_off misspelled)*/'
+       7 |    /*verilator lintt_off WIDTH <--- Warning (lint_off misspelled)*/
+         |    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/gen/ex_DIDNOTCONVERGE_msg.rst

@@ -1,5 +1,5 @@
 .. comment: generated by t_lint_didnotconverge_bad
 .. code-block::
 
-   -V{t#,#}         'stl' region trigger index 1 is active: @([hybrid] a)
+   -V{t#,#}         'stl' region trigger index 1 is active: @([hybrid] b)
    %Error: t/t_lint_didnotconverge_bad.v:7: Settle region did not converge.

docs/gen/ex_PARAMNODEFAULT_faulty.rst

@@ -0,0 +1,7 @@
+.. comment: generated by t_lint_paramnodefault_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 2
+
+   module sub;
+     parameter NODEF;  //<--- Warning

docs/gen/ex_PARAMNODEFAULT_msg.rst

@@ -0,0 +1,6 @@
+.. comment: generated by t_lint_paramnodefault_bad
+.. code-block::
+
+   %Error-PARAMNODEFAULT: example.v:1:13 Parameter without default requires ANSI-style parameter list (IEEE 1800-2023 6.20.1): 'NODEF'
+       8 |   parameter NODEF;
+         |             ^~~~~

docs/gen/ex_PINMISSING_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_lint_pinmissing_bad
 .. code-block::
 
-   %Warning-PINMISSING: example.v:1:8 Cell has missing pin: 'port'
+   %Warning-PINMISSING: example.v:1:8 Instance has missing pin: 'port'

docs/gen/ex_PKGNODECL_faulty.rst

@@ -1,11 +0,0 @@
-.. comment: generated by t_lint_pkgnodecl_bad
-.. code-block:: sv
-   :linenos:
-   :emphasize-lines: 2
-
-   module t;
-      initial Pkg::hello();  //<--- Warning
-   endmodule
-   package Pkg;
-      function void hello(); endfunction
-   endpackage

docs/gen/ex_PKGNODECL_msg.rst

@@ -1,4 +0,0 @@
-.. comment: generated by t_lint_pkgnodecl_bad
-.. code-block::
-
-   %Error-PKGNODECL: example.v:1:12 Package/class 'Pkg' not found, and needs to be predeclared (IEEE 1800-2023 26.3)

docs/gen/ex_PROCASSINIT_faulty.rst

@@ -0,0 +1,12 @@
+.. comment: generated by t_lint_procassinit_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 1,5
+
+      logic flop_out = 1;  // <--- Warning
+
+      always @(posedge clk, negedge reset_l) begin
+         if (enable) begin
+            flop_out <= ~in;  // <--- Use of initialized
+         end
+      end

docs/gen/ex_PROCASSINIT_fixed.rst

@@ -0,0 +1,15 @@
+.. comment: generated by t_lint_procassinit_bad
+.. code-block:: sv
+   :linenos:
+   :emphasize-lines: 5
+
+      logic flop2_out;
+
+      always @(posedge clk, negedge reset_l) begin
+         if (!reset_l) begin
+            flop2_out <= '1;  // <--- Added reset init
+         end
+         else if (enable) begin
+            flop2_out <= ~in;
+         end
+      end

docs/gen/ex_PROCASSINIT_msg.rst

@@ -0,0 +1,12 @@
+.. comment: generated by t_lint_procassinit_bad
+.. code-block::
+
+   %Warning-PROCASSINIT: example.v:1:21 Procedural assignment to declaration with initial value: 'flop_out'
+                                                         : ... note: In instance 't'
+                                                         : ... Location of variable initialization
+      26 |    logic flop_out = 1;
+         |                     ^
+                         example.v:1:10 ... Location of variable process write
+                                                         : ... Perhaps should initialize instead using a reset in this process
+      30 |          flop_out <= ~in;
+         |          ^~~~~~~~

docs/gen/ex_WIDTHEXPAND_1_faulty.rst

@@ -3,6 +3,6 @@
    :linenos:
    :emphasize-lines: 3
 
-      int array[5];
-      bit [1:0] rd_addr;
-      wire int rd_value = array[rd_addr];  //<--- Warning
+     logic [31:0] array[5];
+     bit [1:0] rd_addr;
+     wire [31:0] rd_value = array[rd_addr];  //<--- Warning

docs/gen/ex_WIDTHEXPAND_1_fixed.rst

@@ -2,4 +2,4 @@
 .. code-block:: sv
    :emphasize-lines: 1
 
-      wire int rd_value = array[{1'b0, rd_addr}];  //<--- Fixed
+     wire [31:0] rd_value = array[{1'b0, rd_addr}];  //<--- Fixed

docs/gen/ex_WIDTHEXPAND_1_msg.rst

@@ -1,4 +1,4 @@
 .. comment: generated by t_lint_widthexpand_docs_bad
 .. code-block::
 
-   %Warning-WIDTHEXPAND: example.v:3:29 Bit extraction of array[4:0] requires 3 bit index, not 2 bits.
+   %Warning-WIDTHEXPAND: example.v:3:31 Bit extraction of array[4:0] requires 3 bit index, not 2 bits.

docs/guide/conf.py

@@ -169,15 +169,7 @@ latex_elements = {
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title,
 #  author, documentclass [howto, manual, or own class]).
-# latex_documents = [
-#    (
-#        master_doc,
-#        "Verilog-to-Routing.tex",
-#        "Verilog-to-Routing Documentation",
-#        "VTR Developers",
-#        "manual",
-#    ),
-# ]
+# latex_documents = [ ... ]
 
 # For "manual" documents, if this is true, then toplevel headings are parts,
 # not chapters.

docs/guide/connecting.rst

@@ -73,8 +73,8 @@ often inlined into the root scope) will need to be updated as follows:
     :code:`$` character, i.e.: :code:`rootp` points to the Verilated
     SystemVerilog :code:`$root` scope.
 
-  * Replace :code:`modelp->internal->member->lookup` references with
-    :code:`modelp->rootp->internal->member->lookup` references, which
+  * Replace :code:`modelp->internal->member` references with
+    :code:`modelp->rootp->internal->member` references, which
     contain one additional indirection via the :code:`rootp` pointer.
 
 

docs/guide/contributing.rst

@@ -72,13 +72,17 @@ and the design can be easily manually reduced. In other cases, the bug is
 caused by a complex interaction of many parts of the design, and it is not
 clear which parts are necessary to reproduce the bug. In these cases, an
 Open Source tool called `sv-bugpoint
-<https://github.com/antmicro/sv-bugpoint>_` can be used to automatically
+<https://github.com/antmicro/sv-bugpoint>`_ can be used to automatically
 reduce a SystemVerilog design to the smallest possible reproducer.
 It can be used to automatically reduce a design with hundreds of thousands of
 lines to a minimal test case while preserving the bug-inducing behavior.
 
-Please refer to the `README
-<https://github.com/antmicro/sv-bugpoint/blob/main/README.md>`_ file for more
+With :vlopt:`--debug`, Verilator will write a *{prefix}*\ __inputs\ .vpp
+file which has all of the individual input files combined and
+pre-processed, this is often useful as the input design into `sv-bugpoint`.
+
+Please refer to `sv-bugpoint README
+<https://github.com/antmicro/sv-bugpoint/blob/main/README.md>`_ for more
 information on how to use `sv-bugpoint`.
 
 .. Contributing

docs/guide/contributors.rst

@@ -23,8 +23,8 @@ Contributors
 Many people have provided ideas and other assistance with Verilator.
 
 Verilator is receiving significant development support from the `CHIPS
-Alliance <https://chipsalliance.org>`_, `Antmicro Ltd
-<https://antmicro.com>`_ and `Shunyao CAD <https://shunyaocad.com>`_.
+Alliance <https://chipsalliance.org>`_, and `Antmicro Ltd
+<https://antmicro.com>`_.
 
 Previous major corporate sponsors of Verilator, by providing significant
 contributions of time or funds include: Antmicro Ltd., Atmel Corporation,

docs/guide/exe_sim.rst

@@ -47,6 +47,11 @@ Summary:
 
    Display help and exit.
 
+.. option:: +verilator+noassert
+
+   Disable assert checking per runtime argument. This is the same as
+   calling :code:`VerilatedContext*->assertOn(false)` in the model.
+
 .. option:: +verilator+prof+exec+file+<filename>
 
    When a model was Verilated using :vlopt:`--prof-exec`, sets the
@@ -110,11 +115,6 @@ Summary:
    simulation runtime random seed value.  If zero or not specified picks a
    value from the system random number generator.
 
-.. option:: +verilator+noassert
-
-   Disable assert checking per runtime argument. This is the same as
-   calling :code:`VerilatedContext*->assertOn(false)` in the model.
-
 .. option:: +verilator+V
 
    Shows the verbose version, including configuration information.

docs/guide/exe_verilator_coverage.rst

@@ -49,116 +49,125 @@ verilator_coverage Arguments
 
 .. option:: <filename>
 
-Specifies the input coverage data file.  Multiple filenames may be provided
-to read multiple inputs.  If no data file is specified, by default,
-"coverage.dat" will be read.
+   Specifies the input coverage data file.  Multiple filenames may be
+   provided to read multiple inputs.  If no data file is specified, by
+   default, "coverage.dat" will be read.
 
 .. option:: --annotate <output_directory>
 
-Specifies the directory name to which source files with annotated coverage
-data should be written.
+   Specifies the directory name to which source files with annotated
+   coverage data should be written.
 
-Points are children of each line coverage- branches, expressions or toggle points.
-When point counts are aggregated into a line, the minimum and maximum counts
-are used to determine the status of the line (complete, partial, failing)
-The count is equal to the maximum of the points.
+   Points are children of each line coverage- branches, expressions or
+   toggle points.  When point counts are aggregated into a line, the
+   minimum and maximum counts are used to determine the status of the line
+   (complete, partial, failing) The count is equal to the maximum of the
+   points.
 
-Coverage data is annotated at the beginning of the line and is formatted
-as a special character followed by the number of coverage hits. The special
-characters " ,%,~,+,-" indicate summary of the coverage, and allow use of grep
-to filter the report.
+   Coverage data is annotated at the beginning of the line and is formatted
+   as a special character followed by the number of coverage hits. The
+   special characters " ,%,~,+,-" indicate summary of the coverage, and
+   allow use of grep to filter the report.
 
-* " " (whitespace) indicates that all points on the line are above the coverage min.
-* "%" indicates that all points on the line are below the coverage min.
-* "~" indicates that some points on the line are above the coverage min and some are below.
-* "+" coverage point was at or above the min. Only used with :option:`--annotate-points`.
-* "-" coverage point was below the min.  Only used with :option:`--annotate-points`.
+   * " " (whitespace) indicates that all points on the line are above the coverage min.
+   * "%" indicates that all points on the line are below the coverage min.
+   * "~" indicates that some points on the line are above the coverage min and some are below.
+   * "+" coverage point was at or above the min. Only used with :option:`--annotate-points`.
+   * "-" coverage point was below the min.  Only used with :option:`--annotate-points`.
 
-.. code-block::
+   .. code-block::
 
-   100000  input logic a;      // Begins with whitespace, because
-                               // number of hits (100000) is above the min.
-  +100000  point: comment=a    // Begins with +, because
-                               // number of hits (100000) is above the min.
-  %000000  input logic b;      // Begins with %, because
-                               // number of hits (0) is below the min.
-  -000000  point: comment=b    // Begins with -, because
-                               // number of hits (0) is below the min.
-  ~000010  if (cyc!=0) begin   // Begins with ~, because
-                               // branches are below and above the min.
-  +000010  point: comment=if   // The if branch is above the min.
-  -000000  point: comment=else // The else branch is below the min.
+      100000  input logic a;      // Begins with whitespace, because
+                                  // number of hits (100000) is above the min.
+     +100000  point: comment=a    // Begins with +, because
+                                  // number of hits (100000) is above the min.
+     %000000  input logic b;      // Begins with %, because
+                                  // number of hits (0) is below the min.
+     -000000  point: comment=b    // Begins with -, because
+                                  // number of hits (0) is below the min.
+     ~000010  if (cyc!=0) begin   // Begins with ~, because
+                                  // branches are below and above the min.
+     +000010  point: comment=if   // The if branch is above the min.
+     -000000  point: comment=else // The else branch is below the min.
 
 .. option:: --annotate-all
 
-Specifies all files should be shown.  By default, only those source files
-with low coverage are written to the output directory.
+   Specifies all files should be shown.  By default, only those source
+   files with low coverage are written to the output directory.
 
-This option should be used together with :option:`--annotate`.
+   This option should be used together with :option:`--annotate`.
 
 .. option:: --annotate-min <count>
 
-Specifies the threshold (<count>) below which coverage point is considered
-sufficient. If the threshold is not exceeded, then the annotation will begin
-with a "%" symbol to indicate the coverage is insufficient.
+   Specifies the threshold (<count>) below which coverage point is
+   considered sufficient. If the threshold is not exceeded, then the
+   annotation will begin with a "%" symbol to indicate the coverage is
+   insufficient.
 
-The <count> threshold defaults to 10.
+   The <count> threshold defaults to 10.
 
-This option should be used together with :option:`--annotate`.
+   This option should be used together with :option:`--annotate`.
 
 
 .. option:: --annotate-points
 
-Specifies all coverage points should be shown after each line of text.  By
-default, only source lines are shown.
+   Specifies all coverage points should be shown after each line of text.  By
+   default, only source lines are shown.
 
-.. code-block::
+   .. code-block::
 
-  100000  input logic a, b, c;
- +100000 point: comment=a // These lines are only shown
- +200000 point: comment=b // with option --annotate-points
- +300000 point: comment=c // enabled.
+     100000  input logic a, b, c;
+    +100000 point: comment=a  // These lines are only shown
+    +200000 point: comment=b  // with option --annotate-points
+    +300000 point: comment=c  // enabled.
 
 
-This option should be used together with :option:`--annotate`.
+   This option should be used together with :option:`--annotate`.
+
+.. option:: --filter-type <regex>
+
+   Skips records of coverage types that matches with <regex>
+   Possible values are `toggle`, `line`, `branch`, `expr`, `user` and
+   a wildcard with `\*` or `?`. The default value is `\*`.
 
 .. option:: --help
 
-Displays a help summary, the program version, and exits.
+   Displays a help summary, the program version, and exits.
 
 .. option:: --rank
 
-Prints an experimental report listing the relative importance of each test
-in covering all of the coverage points.  The report shows "Covered" which
-indicates the number of points the test covers; a test is considered to
-cover a point if it has a bucket count of at least 1. The "rank" column has
-a higher number t indicate the test is more critical, and rank 0 means the
-test does not need to be run to cover the points.  "RankPts" indicates the
-number of coverage points this test will contribute to overall coverage if
-all tests are run in the order of highest to the lowest rank.
+   Prints an experimental report listing the relative importance of each
+   test in covering all of the coverage points.  The report shows "Covered"
+   which indicates the number of points the test covers; a test is
+   considered to cover a point if it has a bucket count of at least 1. The
+   "rank" column has a higher number t indicate the test is more critical,
+   and rank 0 means the test does not need to be run to cover the points.
+   "RankPts" indicates the number of coverage points this test will
+   contribute to overall coverage if all tests are run in the order of
+   highest to the lowest rank.
 
 .. option:: --unlink
 
-With :option:`--write`, unlink all input files after the output
-has been successfully created.
+   With :option:`--write`, unlink all input files after the output has been
+   successfully created.
 
 .. option:: --version
 
-Displays program version and exits.
+   Displays program version and exits.
 
 .. option:: --write <filename>
 
-Specifies the aggregate coverage results, summed across all the files,
-should be written to the given filename in verilator_coverage data format.
-This is useful in scripts to combine many coverage data files (likely
-generated from random test runs) into one master coverage file.
+   Specifies the aggregate coverage results, summed across all the files,
+   should be written to the given filename in verilator_coverage data
+   format.  This is useful in scripts to combine many coverage data files
+   (likely generated from random test runs) into one master coverage file.
 
 .. option:: --write-info <filename.info>
 
-Specifies the aggregate coverage results, summed across all the files,
-should be written to the given filename in :command:`lcov` .info format.
-This may be used to feed into :command:`lcov` to aggregate or generate
-reports. This format lacks the comments for cover points that the
-verilator_coverage format has. It can be used with :command:`genhtml`
-to generate an HTML report. :command:`genhtml --branch-coverage` will
-also display the branch coverage, analogous to :option:`--annotate-points`
+   Specifies the aggregate coverage results, summed across all the files,
+   should be written to the given filename in :command:`lcov` .info format.
+   This may be used to feed into :command:`lcov` to aggregate or generate
+   reports. This format lacks the comments for cover points that the
+   verilator_coverage format has. It can be used with :command:`genhtml` to
+   generate an HTML report. :command:`genhtml --branch-coverage` will also
+   display the branch coverage, analogous to :option:`--annotate-points`.

docs/guide/exe_verilator_gantt.rst

@@ -51,6 +51,10 @@ predicted_parallelism
 cpu#_thread
   For the given CPU number, the thread number measured to be executing.
 
+cpu#_waiting
+  For the given CPU number, aggregated waiting time for mtask dependencies.
+  Visualized as `X` values.
+
 mtask#_cpu
   For the given mtask id, the CPU it was measured to execute on.
 
@@ -80,16 +84,16 @@ verilator_gantt Arguments
 
 .. option:: <filename>
 
-The filename to read data from; the default is "profile_exec.dat".
+   The filename to read data from; the default is "profile_exec.dat".
 
 .. option:: --help
 
-Displays a help summary, the program version, and exits.
+   Displays a help summary, the program version, and exits.
 
 .. option:: --no-vcd
 
-Disables creating a .vcd file.
+   Disables creating a .vcd file.
 
 .. option:: --vcd <filename>
 
-Sets the output filename for vcd dump; the default is "verilator_gantt.vcd".
+   Sets the output filename for vcd dump; the default is "verilator_gantt.vcd".

docs/guide/exe_verilator_profcfunc.rst

@@ -33,8 +33,8 @@ verilator_profcfunc Arguments
 
 .. option:: <filename>
 
-The :command:`gprof`-generated filename to read data from. Typically "gprof.out".
+   The :command:`gprof`-generated filename to read data from. Typically "gprof.out".
 
 .. option:: --help
 
-Displays a help summary, the program version, and exits.
+   Displays a help summary, the program version, and exits.

docs/guide/extensions.rst

@@ -1,14 +1,19 @@
 .. Copyright 2003-2025 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-*******************
-Language Extensions
-*******************
+=====================
+ Language Extensions
+=====================
 
 The following additional constructs are the extensions Verilator supports
 on top of standard Verilog code.  Using these features outside of comments
 or "`ifdef`"'s may break other tools.
 
+.. option:: """ [string] """
+
+   A triple-quoted block specifies a string that may include newlines and
+   single quotes.  This extension was standardized in IEEE 1800-2023.
+
 .. option:: `__FILE__
 
    The :option:`\`__FILE__` define expands to the current filename as a
@@ -21,6 +26,12 @@ or "`ifdef`"'s may break other tools.
    C++'s __LINE__.  This Verilator feature added in 2006 was incorporated
    into IEEE 1800-2009.
 
+.. option:: `coverage_block_off
+
+   Specifies the entire begin/end block should be ignored for coverage
+   analysis.  Must be inside a code block, e.g., within a begin/end pair.
+   Same as :option:`coverage_block_off` in :ref:`Verilator Control Files`.
+
 .. option:: `error [string]
 
    This will report an error when the preprocessor emits it, similar to
@@ -33,10 +44,117 @@ or "`ifdef`"'s may break other tools.
    internal tests, so that debugging can leave the line numbers correctly
    referring to the test file's line numbers.
 
-.. option:: """ [string] """
+.. option:: `systemc_class_name
 
-   A triple-quoted block specifies a string that may include newlines and
-   single quotes.  This extension was standardized in IEEE 1800-2023.
+   Inside one of the :option:`\`systemc_... <\`systemc_header>` text
+   blocks, replaced with the C++ class name generated for the given
+   containing SystemVerilog class or module. Currently this is replaced
+   blindly, ignoring quoting or other escapes; this behavior may change in
+   the future.  This attribute is indented only to be used internally in
+   `verilated_std.sv`.
+
+.. option:: `systemc_ctor
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the C++ class constructor.  Must be placed as a module or
+   class item, e.g., directly inside a module/endmodule or class/endclass
+   pair. Despite the name of this macro, this also works in pure C++ code.
+
+.. option:: `systemc_dtor
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the C++ class destructor.  Must be placed as a module or
+   class item, e.g., directly inside a module/endmodule or class/endclass
+   pair. Despite the name of this macro, this also works in pure C++ code.
+
+.. option:: `systemc_header
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the output .h file's header.  Must be placed as a module
+   or class item, e.g., directly inside a module/endmodule or
+   class/endclass pair. Despite the name of this macro, this also works in
+   pure C++ code.
+
+.. option:: `systemc_header_post
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the output .h file's header after the class definition.
+   Must be placed as a module or class item, e.g., directly inside a
+   module/endmodule or class/endclass pair. Despite the name of this macro,
+   this also works in pure C++ code.
+
+.. option:: `systemc_imp_header
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the header of all files for this C++ class implementation.
+   Must be placed as a module or class item, e.g., directly inside a
+   module/endmodule or class/endclass pair. Despite the name of this macro,
+   this also works in pure C++ code.
+
+.. option:: `systemc_implementation
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into a single file of the C++ class implementation.  Must be
+   placed as a module or class item, e.g., directly inside a
+   module/endmodule or class/endclass pair. Despite the name of this macro,
+   this also works in pure C++ code.
+
+   If you will be reading or writing any Verilog variables in the C++
+   functions, the Verilog signals must be declared with a
+   :option:`/*verilator&32;public*/` metacomment.  See also the public task
+   feature; writing an accessor may result in cleaner code.
+
+.. option:: `systemc_interface
+
+   Take the remaining text up to the next :option:`\`verilog` or
+   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
+   verbatim into the C++ class interface.  Must be placed as a module or
+   class item, e.g., directly inside a module/endmodule or class/endclass
+   pair. Despite the name of this macro, this also works in pure C++ code.
+
+.. option:: `SYSTEMVERILOG
+
+   The SYSTEMVERILOG, SV_COV_START, and related standard predefined macros
+   are defined by default when :vlopt:`--language <--language>` is
+   "1800-\*".
+
+.. option:: `VERILATOR
+
+.. option:: `verilator
+
+.. option:: `verilator3
+
+   The VERILATOR, verilator and verilator3 predefined macros are defined by
+   default so you may "\`ifdef" around tool specific constructs.
+
+.. option:: `verilator_config
+
+   Take the remaining text up to the next :option:`\`verilog` mode switch
+   and treat it as Verilator Control File commands.  See :ref:`Verilator
+   Control Files`.
+
+.. option:: `VERILATOR_TIMING
+
+   The VERILATOR_TIMING define is set when :vlopt:`--timing` is used to
+   allow an "\`ifdef" of code dependent on this feature.  Note that this define
+   is not affected by the :option:`timing_off` control file option
+   nor timing metacomments.
+
+.. option:: `verilog
+
+   Switch back to processing Verilog code after a
+   :option:`\`systemc_... <\`systemc_header>` mode switch.  The Verilog
+   code returns to the last language mode specified with
+   "\`begin_keywords", or SystemVerilog if none was specified.
+
+
+   .. t_dist_docs_style restart_sort
 
 .. option:: $c([string], ...);
 
@@ -86,6 +204,16 @@ or "`ifdef`"'s may break other tools.
    prints 5 digits per the C standard. This extension was standardized into
    1800-2009.
 
+.. option:: $stacktrace
+
+   Called as a task, print a stack trace.  Called as a function, return a
+   string with a stack trace.  This relies on the C++ system trace, which
+   may give less meaningful results if the model is not compiled with debug
+   symbols.  Also, the data represents the C++ stack; the SystemVerilog
+   functions/tasks involved may be renamed and/or inlined before becoming
+   the C++ functions that may be visible in the stack trace.  This
+   extension was standardized in IEEE 1800-2023.
+
 .. option:: $timeprecision
 
    Returns the timeprecision of the model as an integer.  This extension is
@@ -96,98 +224,6 @@ or "`ifdef`"'s may break other tools.
    Returns the timeunit of the current module as an integer.  This
    extension is experimental and may be removed without deprecation.
 
-.. option:: `coverage_block_off
-
-   Specifies the entire begin/end block should be ignored for coverage
-   analysis.  Must be inside a code block, e.g., within a begin/end pair.
-   Same as :option:`coverage_block_off` in :ref:`Configuration Files`.
-
-.. option:: `systemc_header
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into the output .h file's header.  Must be placed as a module
-   item, e.g., directly inside a module/endmodule pair. Despite the name of
-   this macro, this also works in pure C++ code.
-
-.. option:: `systemc_ctor
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into the C++ class constructor.  Must be placed as a module
-   item, e.g., directly inside a module/endmodule pair. Despite the name of
-   this macro, this also works in pure C++ code.
-
-.. option:: `systemc_dtor
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into the C++ class destructor.  Must be placed as a module
-   item, e.g., directly inside a module/endmodule pair. Despite the name of
-   this macro, this also works in pure C++ code.
-
-.. option:: `systemc_interface
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into the C++ class interface.  Must be placed as a module item,
-   e.g., directly inside a module/endmodule pair. Despite the name of this
-   macro, this also works in pure C++ code.
-
-.. option:: `systemc_imp_header
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into the header of all files for this C++ class implementation.
-   Must be placed as a module item, e.g., directly inside a module/endmodule
-   pair. Despite the name of this macro, this also works in pure C++ code.
-
-.. option:: `systemc_implementation
-
-   Take the remaining text up to the next :option:`\`verilog` or
-   :option:`\`systemc_... <\`systemc_header>` mode switch and place it
-   verbatim into a single file of the C++ class implementation.  Must be
-   placed as a module item, e.g., directly inside a module/endmodule
-   pair. Despite the name of this macro, this also works in pure C++ code.
-
-   If you will be reading or writing any Verilog variables in the C++
-   functions, the Verilog signals must be declared with a
-   :option:`/*verilator&32;public*/` metacomment.  See also the public task
-   feature; writing an accessor may result in cleaner code.
-
-.. option:: `SYSTEMVERILOG
-
-   The SYSTEMVERILOG, SV_COV_START, and related standard defines are set by
-   default when :vlopt:`--language <--language>` is "1800-\*".
-
-.. option:: `VERILATOR
-
-.. option:: `verilator
-
-.. option:: `verilator3
-
-   The VERILATOR, verilator and verilator3 defines are set by default so
-   you may "\`ifdef" around tool specific constructs.
-
-.. option:: `verilator_config
-
-   Take the remaining text up to the next :option:`\`verilog` mode switch and
-   treat it as Verilator configuration commands.  See :ref:`Configuration Files`.
-
-.. option:: `VERILATOR_TIMING
-
-   The VERILATOR_TIMING define is set when :vlopt:`--timing` is used to
-   allow an "\`ifdef" of code dependent on this feature.  Note that this define
-   is not affected by the :option:`timing_off` configuration file option
-   nor timing metacomments.
-
-.. option:: `verilog
-
-   Switch back to processing Verilog code after a
-   :option:`\`systemc_... <\`systemc_header>` mode switch.  The Verilog
-   code returns to the last language mode specified with
-   "\`begin_keywords", or SystemVerilog if none was specified.
-
 .. option:: /*verilator&32;clock_enable*/
 
    Deprecated and has no effect (ignored).
@@ -210,7 +246,10 @@ or "`ifdef`"'s may break other tools.
    the scheduling algorithm, sometimes required for correct clock behavior,
    and always improving performance.
 
-   Same as :option:`clock_enable` configuration file option.
+   Same as :option:`clock_enable` control file option.
+
+
+   .. t_dist_docs_style ignore /*verilator&32;no_clocker*/
 
 .. option:: /*verilator&32;clocker*/
 
@@ -226,7 +265,7 @@ or "`ifdef`"'s may break other tools.
    Specifies the entire begin/end block should be ignored for coverage
    analysis purposes.
 
-   Same as :option:`coverage_block_off` configuration file option.
+   Same as :option:`coverage_block_off` control file option.
 
 .. option:: /*verilator&32;coverage_off*/
 
@@ -274,7 +313,7 @@ or "`ifdef`"'s may break other tools.
    submodules will be named :code:`{submodule}__DOT__{subsignal}` as C++
    does not allow "." in signal names.
 
-   Same as :option:`inline` configuration file option.
+   Same as :option:`inline` control file option.
 
 .. option:: /*verilator&32;isolate_assignments*/
 
@@ -317,7 +356,7 @@ or "`ifdef`"'s may break other tools.
            end
          end
 
-   Same as :option:`isolate_assignments` configuration file option.
+   Same as :option:`isolate_assignments` control file option.
 
 .. option:: /*verilator&32;lint_off <msg>*/
 
@@ -356,7 +395,7 @@ or "`ifdef`"'s may break other tools.
    Specifies the module the comment appears in should not be inlined into
    any modules that use this module.
 
-   Same as :option:`no_inline` configuration file option.
+   Same as :option:`no_inline` control file option.
 
 .. option:: /*verilator&32;no_inline_task*/
 
@@ -367,7 +406,7 @@ or "`ifdef`"'s may break other tools.
    must be pure; they cannot reference any variables outside the task
    itself.
 
-   Same as :option:`no_inline` configuration file option.
+   Same as :option:`no_inline` control file option.
 
 .. option:: /*verilator&32;public*/ (on parameter)
 
@@ -379,29 +418,6 @@ or "`ifdef`"'s may break other tools.
 
          parameter [2:0] PARAM /*verilator public*/ = 2'b0;
 
-.. option:: /*verilator&32;public*/ (on typedef enum)
-
-   Used after an enum typedef declaration to indicate the emitted C code
-   should have the enum values visible. Due to C++ language restrictions,
-   this may only be used on 64-bit or narrower integral enumerations.
-
-   .. code-block:: sv
-
-         typedef enum logic [2:0] { ZERO = 3'b0 } pub_t /*verilator public*/;
-
-.. option:: /*verilator&32;public*/ (on variable)
-
-   Used after an input, output, register, or wire declaration to indicate
-   the signal should be declared so that C code may read or write the value
-   of the signal.  This will also declare this module public; otherwise, use
-   :code:`/*verilator&32;public_flat*/`.
-
-   Instead of using public variables, consider making a DPI or public
-   function that accesses the variable.  This is nicer as it provides an
-   obvious entry point compatible across simulators.
-
-   Same as :option:`public` configuration file option.
-
 .. option:: /*verilator&32;public*/ (on task/function)
 
    Used inside the declaration section of a function or task declaration to
@@ -424,34 +440,30 @@ or "`ifdef`"'s may break other tools.
    You may want to use DPI exports instead, as it's compatible with other
    simulators.
 
-   Same as :option:`public` configuration file option.
+   Same as :option:`public` control file option.
 
-.. option:: /*verilator&32;public_flat*/ (on variable)
+.. option:: /*verilator&32;public*/ (on typedef enum)
+
+   Used after an enum typedef declaration to indicate the emitted C code
+   should have the enum values visible. Due to C++ language restrictions,
+   this may only be used on 64-bit or narrower integral enumerations.
+
+   .. code-block:: sv
+
+         typedef enum logic [2:0] { ZERO = 3'b0 } pub_t /*verilator public*/;
+
+.. option:: /*verilator&32;public*/ (on variable)
 
    Used after an input, output, register, or wire declaration to indicate
    the signal should be declared so that C code may read or write the value
-   of the signal.  This will not declare this module public, which means
-   the name of the signal or path to it may change based upon the module
-   inlining which takes place.
+   of the signal.  This will also declare this module public; otherwise, use
+   :code:`/*verilator&32;public_flat*/`.
 
-   Same as :option:`public_flat` configuration file option.
+   Instead of using public variables, consider making a DPI or public
+   function that accesses the variable.  This is nicer as it provides an
+   obvious entry point compatible across simulators.
 
-.. option:: /*verilator&32;public_flat_rd*/ (on variable)
-
-   Used after an input, output, register, or wire declaration to indicate
-   the signal should be declared public_flat (see above), but read-only.
-
-   Same as :option:`public_flat_rd` configuration file option.
-
-.. option:: /*verilator&32;public_flat_rw @(<edge_list>)*/ (on variable)
-
-   Used after an input, output, register, or wire declaration to indicate
-   the signal should be declared public_flat_rd (see above), and writable,
-   where writes should be considered to have the timing specified by the
-   given sensitivity edge list. Use of this is implied when using the
-   :vlopt:`--public-flat-rw` option.
-
-   Same as :option:`public_flat_rw` configuration file option.
+   Same as :option:`public` control file option.
 
 .. option:: /*verilator&32;public_[|flat|flat_rd|flat_rw]_on [@(<edge_list>)]*/ (as scope)
 
@@ -476,9 +488,32 @@ or "`ifdef`"'s may break other tools.
          parameter width /*verilator public_flat_rw*/ = 8;
          logic data;
 
-.. option:: /*verilator&32;public_off*/
+.. option:: /*verilator&32;public_flat*/ (on variable)
 
-   Terminates the previous `/*verilator public*_on*/` directive; see above.
+   Used after an input, output, register, or wire declaration to indicate
+   the signal should be declared so that C code may read or write the value
+   of the signal.  This will not declare this module public, which means
+   the name of the signal or path to it may change based upon the module
+   inlining which takes place.
+
+   Same as :option:`public_flat` control file option.
+
+.. option:: /*verilator&32;public_flat_rd*/ (on variable)
+
+   Used after an input, output, register, or wire declaration to indicate
+   the signal should be declared public_flat (see above), but read-only.
+
+   Same as :option:`public_flat_rd` control file option.
+
+.. option:: /*verilator&32;public_flat_rw @(<edge_list>)*/ (on variable)
+
+   Used after an input, output, register, or wire declaration to indicate
+   the signal should be declared public_flat_rd (see above), and writable,
+   where writes should be considered to have the timing specified by the
+   given sensitivity edge list. Use of this is implied when using the
+   :vlopt:`--public-flat-rw` option.
+
+   Same as :option:`public_flat_rw` control file option.
 
 .. option:: /*verilator&32;public_module*/
 
@@ -488,15 +523,11 @@ or "`ifdef`"'s may break other tools.
    contains public signals or \`systemc_ directives.  Use of this is
    implied when using the :vlopt:`--public` option.
 
-   Same as :option:`public` configuration file option.
+   Same as :option:`public` control file option.
 
-.. option:: /*verilator&32;sc_clock*/
+.. option:: /*verilator&32;public_off*/
 
-   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.
+   Terminates the previous `/*verilator public*_on*/` directive; see above.
 
 .. option:: /*verilator&32;sc_bv*/
 
@@ -507,7 +538,15 @@ or "`ifdef`"'s may break other tools.
    In general, you should avoid using this attribute when unnecessary, as
    the performance decreases significantly with increasing usage of sc_bv.
 
-   Same as :option:`sc_bv` configuration file option.
+   Same as :option:`sc_bv` control file option.
+
+.. option:: /*verilator&32;sc_clock*/
+
+   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.
 
 .. option:: /*verilator&32;sformat*/
 
@@ -517,7 +556,7 @@ or "`ifdef`"'s may break other tools.
    $display-like behavior.  See the :file:`test_regress/t/t_dpi_display.v`
    file for an example.
 
-   Same as :option:`sformat` configuration file option.
+   Same as :option:`sformat` control file option.
 
 .. option:: /*verilator&32;split_var*/
 
@@ -550,7 +589,21 @@ or "`ifdef`"'s may break other tools.
    large arrays may slow down the Verilation speed, so use this only on
    variables that require it.
 
-   Same as :option:`split_var` configuration file option.
+   Packed variables that are only referenced locally (without hierarchical
+   references) via non-overlapping, constant-indexed bit or part select
+   expressions are split automatically. This covers the somewhat common
+   usage pattern:
+
+   .. code-block:: sv
+
+         logic [1:0][31:0] tmp;
+
+         assign tmp[0] = foo    + a;
+         assign tmp[1] = tmp[1] + b;
+         assign bar    = tmp[1] + c;
+
+
+   Same as :option:`split_var` control file option.
 
 .. option:: /*verilator&32;tag <text...>*/
 
@@ -565,14 +618,14 @@ or "`ifdef`"'s may break other tools.
    :option:`--no-timing`), and :code:`fork`/:code:`join*` blocks are
    converted into :code:`begin`/:code:`end` blocks.
 
-   Same as :option:`timing_off` configuration file option.
+   Same as :option:`timing_off` control file option.
 
 .. option:: /*verilator&32;timing_on*/
 
    Re-enable all timing constructs after this metacomment (only applicable
    after :option:`timing_off`).
 
-   Same as :option:`timing_on` configuration file option.
+   Same as :option:`timing_on` control file option.
 
 .. option:: /*verilator&32;trace_init_task*/
 
@@ -583,7 +636,7 @@ or "`ifdef`"'s may break other tools.
    Attached to a DPI import to indicate that function should be called when
    initializing tracing. This attribute is indented only to be used
    internally in code that Verilator generates when :vlopt:`--lib-create`
-   or :vlopt:`--hierarchical` is used along with :vlopt:`--trace`.
+   or :vlopt:`--hierarchical` is used along with :vlopt:`--trace-vcd`.
 
 .. option:: /*verilator&32;tracing_off*/
 
@@ -613,13 +666,3 @@ or "`ifdef`"'s may break other tools.
    following loop at the same statement level should always be fully
    unrolled by Verilator, ignoring :vlopt:`--unroll-count`.  This is
    similar to clang's ``#pragma clang loop unroll(full)``.
-
-.. option:: $stacktrace
-
-   Called as a task, print a stack trace.  Called as a function, return a
-   string with a stack trace.  This relies on the C++ system trace, which
-   may give less meaningful results if the model is not compiled with debug
-   symbols.  Also, the data represents the C++ stack; the SystemVerilog
-   functions/tasks involved may be renamed and/or inlined before becoming
-   the C++ functions that may be visible in the stack trace.  This
-   extension was standardized in IEEE 1800-2023.

docs/guide/faq.rst

@@ -128,7 +128,7 @@ How do I generate waveforms (traces) in C++?
 
 See also the next question for tracing in SystemC mode.
 
-A. Pass the :vlopt:`--trace` option to Verilator.  Then you may use ``$dumpfile`` and
+A. Pass the :vlopt:`--trace-vcd` option to Verilator.  Then you may use ``$dumpfile`` and
    ``$dumpvars`` to enable traces, the same as with any Verilog simulator,
    although Verilator ignores the arguments to ``$dumpvars``. See
    ``examples/make_tracing_c`` in the distribution.
@@ -177,7 +177,7 @@ file.
 How do I generate waveforms (traces) in SystemC?
 """"""""""""""""""""""""""""""""""""""""""""""""
 
-A. Pass the :vlopt:`--trace` option to Verilator, and in your top-level
+A. Pass the :vlopt:`--trace-vcd` option to Verilator, and in your top-level
    :code:`sc_main()`, call :code:`Verilated::traceEverOn(true)`.  Then you
    may use :code:`$dumpfile` and code:`$dumpvars` to enable traces, as
    with any Verilog simulator; see the non-SystemC example in
@@ -260,7 +260,7 @@ How do I view waveforms (aka dumps or traces)?
 
 Verilator creates standard VCD (Value Change Dump) and FST files.  VCD
 files are viewable with the open-source
-`GTKWave <http://gtkwave.sourceforge.net/>`_,
+`GTKWave <https://gtkwave.sourceforge.net/>`_,
 `Surfer <https://surfer-project.org/>`_, Dinotrace (legacy), or any of the
 many closed-source viewer offerings; FST is supported only by GTKWave and
 Surfer.
@@ -335,7 +335,7 @@ How do I prevent my assertions from firing during reset?
 
 Call :code:`Verilated::assertOn(false)` before you first call the model,
 then turn it back on after reset.  It defaults to true.  When false, all
-assertions controlled by :vlopt:`--assert` are disabled.
+assertions are disabled.
 
 
 Why do I get "undefined reference to sc_time_stamp()?

docs/guide/files.rst

@@ -65,9 +65,9 @@ For --cc/--sc, it creates:
    * - *{prefix}*\ ___024root\ *{__DepSet_hash__n}*\ .cpp
      - Infrequent cold routines (hashed to reduce build times)
    * - *{prefix}*\ ___024root__Trace\ *{__n}*\ .cpp
-     - Wave file generation code (from --trace)
+     - Wave file generation code (from --trace-\*)
    * - *{prefix}*\ ___024root__Trace__Slow\ *{__n}*\ .cpp
-     - Wave file generation code (from --trace)
+     - Wave file generation code (from --trace-\*)
    * - *{prefix}*\ __Dpi.h
      - DPI import and export declarations (from --dpi)
    * - *{prefix}*\ __Dpi.cpp
@@ -112,12 +112,14 @@ In specific debug and other modes, it also creates:
 
 .. list-table::
 
-   * - *{prefix}*\ .xml
-     - XML tree information (from --xml)
+   * - *{prefix}*\ .sarif
+     - SARIF diagnostics (from --diagnostics-sarif)
    * - *{prefix}*\ .tree.json
      - JSON tree information (from --json-only)
    * - *{prefix}*\ .tree.meta.json
      - JSON tree metadata (from --json-only)
+   * - *{prefix}*\ .xml
+     - XML tree information (from --xml)
    * - *{prefix}*\ __cdc.txt
      - Clock Domain Crossing checks (from --cdc)
    * - *{prefix}*\ __stats.txt

docs/guide/install.rst

@@ -15,9 +15,9 @@ Package Manager Quick Install
 =============================
 
 Using a distribution's package manager is the easiest way to get
-started. (Note packages are unlikely to have the most recent version, so
-:ref:`Git Install` might be a better alternative.) To install as a
-package:
+started. (Note distribution packages almost never have the most recent
+Verilator version, so we recommend following :ref:`Git Install` below,
+instead.) To install as a package:
 
 .. code-block:: shell
 
@@ -118,6 +118,25 @@ To build or run Verilator, you need these standard packages:
    sudo apt-get install libfl-dev  # Ubuntu only (ignore if gives error)
    sudo apt-get install zlibc zlib1g zlib1g-dev  # Ubuntu only (ignore if gives error)
 
+For SystemC:
+
+.. code-block:: shell
+
+   sudo apt-get install libsystemc libsystemc-dev
+
+For constraints:
+
+.. code-block:: shell
+
+   sudo apt-get install z3  # Optional solver
+
+The following is optional but is recommended for nicely rendered command line
+help when running Verilator:
+
+.. code-block:: shell
+
+   sudo apt-get install perl-doc
+
 To build or run Verilator, the following are optional but should be installed
 for good performance:
 
@@ -127,13 +146,6 @@ for good performance:
    sudo apt-get install mold  # If present at build, needed for run
    sudo apt-get install libgoogle-perftools-dev numactl
 
-The following is optional but is recommended for nicely rendered command line
-help when running Verilator:
-
-.. code-block:: shell
-
-   sudo apt-get install perl-doc
-
 To build Verilator you will need to install these packages; these do not
 need to be present to run Verilator:
 
@@ -141,13 +153,13 @@ 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):
+Those developing Verilator itself also need these (see internals.rst):
 
 .. code-block:: shell
 
-   sudo apt-get install clang clang-format-14 cmake gdb gprof graphviz lcov
-   sudo apt-get install python3-clang yapf3 bear jq
-   sudo pip3 install sphinx sphinx_rtd_theme sphinxcontrib-spelling breathe ruff
+   sudo apt-get install clang clang-format-18 cmake gdb gprof graphviz lcov
+   sudo apt-get install python3-clang python3-distro yapf3 bear jq
+   sudo pip3 install sphinx sphinx_rtd_theme sphinxcontrib-spelling breathe gersemi mbake ruff sarif-tools
    sudo pip3 install git+https://github.com/antmicro/astsee.git
    cpan install Pod::Perldoc
 
@@ -155,7 +167,10 @@ Those developing Verilator itself may also want these (see internals.rst):
 Install SystemC
 ^^^^^^^^^^^^^^^
 
-If you will be using SystemC (vs straight C++ output), download `SystemC
+SystemC code can be generated from Verilator (with :vlopt:`--sc`) if it is
+installed as a package (see above).
+
+Alternatively, from their sources, download `SystemC
 <https://www.accellera.org/downloads/standards/systemc>`__.  Follow their
 installation instructions. You will need to set the
 :option:`SYSTEMC_INCLUDE` environment variable to point to the include
@@ -167,15 +182,19 @@ Install GTKWave
 ^^^^^^^^^^^^^^^
 
 To make use of Verilator FST tracing you will want `GTKwave
-<http://gtkwave.sourceforge.net/>`__ installed, however this is not
+<https://gtkwave.sourceforge.net/>`__ installed, however this is not
 required at Verilator build time.
 
+.. code-block:: shell
+
+    sudo apt-get install gtkwave  # Optional Waveform viewer
+
 
 Install Z3
 ^^^^^^^^^^
 
 In order to use constrained randomization the `Z3 Theorem Prover
-<https://github.com/z3prover/z3#readme>`__ must be installed, however this is
+<https://github.com/z3prover/z3>`__ must be installed, however this is
 not required at Verilator build time. There are other compatible SMT solvers,
 like CVC5/CVC4, but they are not guaranteed to work. Since different solvers are
 faster for different scenarios, the solver to use at run-time can be specified
@@ -269,7 +288,7 @@ location include the Verilator version name:
 
 Note after installing (see `Installation`_), you need to add the path to
 the ``bin`` directory to your ``PATH``. Or, if you use `modulecmd
-<http://modules.sourceforge.net/>`__, you'll want a module file like the
+<https://modules.sourceforge.net/>`__, you'll want a module file like the
 following:
 
 .. code-block:: shell

docs/guide/languages.rst

@@ -6,7 +6,7 @@ Input Languages
 ***************
 
 This section describes the languages Verilator takes as input.  See also
-:ref:`Configuration Files`.
+:ref:`Verilator Control Files`.
 
 
 Language Standard Support
@@ -90,14 +90,14 @@ wreal.
 Synthesis Directive Assertion Support
 -------------------------------------
 
-With the :vlopt:`--assert` option, Verilator reads any
+Verilator reads any :code:`//synopsys full_case` or :code:`//synopsys
+parallel_case` directives.  The same applies to any :code:`//ambit
+synthesis`, :code:`//cadence` or :code:`//pragma` directives of the same
+form.
 
-:code:`//synopsys full_case` or :code:`//synopsys parallel_case`
-directives.  The same applies to any :code:`//ambit synthesis`,
-:code:`//cadence` or :code:`//pragma` directives of the same form.
-
-When these synthesis directives are discovered, Verilator will either
-formally prove the directive to be true, or, failing that, will insert the
+When these synthesis directives are discovered, unless
+:vlopt:`--no-assert-case` option is used, Verilator will either 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.
 
@@ -168,7 +168,7 @@ files. The :option:`/*verilator&32;timing_off*/` and
 the encompassed timing controls and forks, regardless of the chosen
 :vlopt:`--timing` or :vlopt:`--no-timing` option. This can also be achieved
 using the :option:`timing_off` and :option:`timing_off` options in Verilator
-configuration files.
+Control Files.
 
 
 .. _Language Limitations:
@@ -334,7 +334,8 @@ Gate Primitives
 
 The 2-state gate primitives (and, buf, nand, nor, not, or, xnor, xor) are
 directly converted to behavioral equivalents.  The 3-state and MOS gate
-primitives are not supported.  Tables are not supported.
+primitives are not supported.  User-defined primitive (UDP) tables are
+supported.
 
 
 Specify blocks
@@ -396,8 +397,8 @@ This section describes specific limitations for each language keyword.
    \`begin_keywords, \`begin_keywords, \`begin_keywords, \`begin_keywords,
    \`define, \`else, \`elsif, \`end_keywords, \`endif, \`error, \`ifdef,
    \`ifndef, \`include, \`line, \`systemc_ctor, \`systemc_dtor,
-   \`systemc_header, \`systemc_imp_header, \`systemc_implementation,
-   \`systemc_interface, \`undef, \`verilog
+   \`systemc_header, \`systemc_header_post, \`systemc_imp_header,
+   \`systemc_implementation, \`systemc_interface, \`undef, \`verilog
 
 |cmdslong1|
   Fully supported.
@@ -451,17 +452,17 @@ disable
 force, release
   Verilator supports the procedural `force` (and corresponding `release`)
   statement. However, the behavior of the `force` statement does not
-  entirely comply with IEEE 1800. According to the standard, when a
-  procedural statement of the form `force a = b;` is executed, the
-  simulation should behave as if, from that point forwards, a continuous
-  assignment `assign a = b;` has been added to override the drivers of `a`.
-  More specifically: the value of `a` should be updated whenever the value
-  of `b` changes, until a `release a;` statement is executed.  Verilator
-  instead evaluates the current value of `b` when the `force` statement is
-  executed, and forces `a` to that value, without updating it until a new
-  `force` or `release` statement is encountered that applies to `a`. This
-  non-standard behavior is nevertheless consistent with some other
-  simulators.
+  entirely comply with IEEE 1800-2023:
+
+  #. Using forced variable as a value to another force statement is
+     currently not supported. The dependent force statement is forced by an
+     initial constant value.
+
+  #. Force/release with procedural continuous assignment is not supported.
+     The assignment is treated as procedural.
+
+  #. Expressions using multiple variable references or function calls on
+     forced right-hand side are not sensitive to dependency changes.
 
 inside
   Inside expressions may not include unpacked array traversal or $ as an
@@ -477,7 +478,8 @@ shortreal
   other simulators either do not support float, or convert likewise.
 
 specify specparam
-  All specify blocks and timing checks are ignored.
+  All timing checks and specify blocks (except specparam, which is
+  supported) are ignored.
 
 uwire
   Verilator does not perform warning checking on uwires; it treats the
@@ -488,7 +490,7 @@ $bits, $countbits, $countones, $finish, $isunknown, $onehot, $onehot0, $signed,
 
 $dump/$dumpports and related
   $dumpfile or $dumpports will create a VCD or FST file (based on
-  the :vlopt:`--trace` option given when the model was Verilated). This
+  the :vlopt:`--trace-vcd` option given when the model was Verilated). This
   will take effect starting at the next eval() call.  If you have multiple
   Verilated designs under the same C model, this will dump signals
   only from the design containing the $dumpvars.
@@ -535,4 +537,4 @@ $test$plusargs, $value$plusargs
         {VerilatedContext*} ->commandArgs(argc, argv);
 
   to register the command line before calling $test$plusargs or
-  $value$plusargs.
+  $value$plusargs. Or use :vlopt:`--binary` or :vlopt:`--main`.

docs/guide/simulating.rst

@@ -76,16 +76,19 @@ Benchmarking & Optimization
 For best performance, run Verilator with the :vlopt:`-O3`
 :vlopt:`--x-assign fast <--x-assign>`
 :vlopt:`--x-initial fast <--x-initial>`
-:vlopt:`--noassert <--assert>` options.  The :vlopt:`-O3`
+:vlopt:`--no-assert` options.  The :vlopt:`-O3`
 option will require a longer time to run Verilator, and
 :vlopt:`--x-assign fast <--x-assign>`
 :vlopt:`--x-initial fast <--x-assign>`
-may increase the risk of reset bugs in trade for performance; see the above
-documentation for these options.
+may increase the risk of reset bugs in trade for performance.  The
+:vlopt:`--no-assert` will suppress checking assertions, which is faster and
+appropriate for known-good models running software, but may hide design
+errors.  See the above documentation for these options.
 
-If using Verilated multithreaded, use ``numactl`` to ensure you use
-non-conflicting hardware resources. See :ref:`Multithreading`. Also,
-consider using profile-guided optimization; see :ref:`Thread PGO`.
+If using Verilated multithreaded, consider overriding Verilator's default
+thread-to-processor assignment by using ``numactl``; see
+:ref:`Multithreading`. Also, consider using profile-guided optimization;
+see :ref:`Thread PGO`.
 
 Minor Verilog code changes can also give big wins.  You should not have any
 :option:`UNOPTFLAT` warnings from Verilator.  Fixing these warnings can
@@ -202,9 +205,6 @@ With :vlopt:`--coverage` or :vlopt:`--coverage-user`, Verilator will
 translate functional coverage points the user has inserted manually in
 SystemVerilog code through into the Verilated model.
 
-Currently, all functional coverage points are specified using SystemVerilog
-assertion syntax, which must be separately enabled with :vlopt:`--assert`.
-
 For example, the following SystemVerilog statement will add a coverage
 point under the coverage name "DefaultClock":
 
@@ -314,7 +314,7 @@ Suppressing Coverage
 Using :option:`/*verilator&32;coverage_off*/` and
 :option:`/*verilator&32;coverage_on*/` around a block of code will disable
 and enable coverage respectively around that block. Or, use the
-:option:`coverage_block_off` configuration file option.
+:option:`coverage_block_off` control file option.
 
 Verilator automatically disables coverage of lines and branches with a
 $stop in them, as it is assumed that $stop branches contain an error check

docs/guide/verilating.rst

@@ -66,6 +66,40 @@ Once a model is built, the next step is typically for the user to run it,
 see :ref:`Simulating`.
 
 
+.. _Finding and Binding Modules:
+
+Finding and Binding Modules
+===========================
+
+Verilator provides several mechanisms to find the source code containing a
+module, primitive, interface, or program ("module" in this section) and
+bind them to an instantiation.  These capabilities are similar to the
+"Precompiling in a single-pass" use model described in IEEE 1800-2023
+33.5.1, although `config` is not yet supported.
+
+Verilator first reads all files provided on the command line and
+:vlopt:`-f` files, and parses all modules within.  Each module is assigned
+to the most recent library specified with :vlopt:`-work`, thus `-work liba
+a.v -work libb b.v` will assign modules in `a.v` to `liba` and modules in
+`b.v` to `libb`.
+
+If a module is not defined from a file on the command-line, Verilator
+attempts to find a filename constructed from the module name using
+:vlopt:`-y` and `+libext`.
+
+Binding begins with the :vlopt:`--top` module, if provided. If not provided
+Verilator attempts to figure out the top module itself, and if multiple
+tops result a :option:`MULTITOP` warning is issued which may be suppressed
+(see details in :option:`MULTITOP`).
+
+Verilator will attempt to bind lower unresolved instances first in the same
+library name as the parent's instantiation library, and if not found search
+globally across all libraries in the order modules were declared.  This
+allows otherwise conflicting duplicate module names between libraries to
+coexist uniquely within each library name.  When IEEE `config use` is
+supported, more complicated selections will be able to be specified.
+
+
 .. _Hierarchical Verilation:
 
 Hierarchical Verilation
@@ -94,7 +128,7 @@ There are two ways to mark a module:
 
 * Write :option:`/*verilator&32;hier_block*/` metacomment in HDL code.
 
-* Add a :option:`hier_block` line in the :ref:`Configuration Files`.
+* Add a :option:`hier_block` line in the :ref:`Verilator Control Files`.
 
 Then pass the :vlopt:`--hierarchical` option to Verilator.
 
@@ -113,8 +147,6 @@ Hierarchy blocks have some limitations, including:
 * The hierarchy block cannot be accessed using dot (.) from the upper
   module(s) or other hierarchy blocks.
 
-* Signals in the block cannot be traced.
-
 * Modport cannot be used at the hierarchical block boundary.
 
 * The simulation speed is likely not as fast as flat Verilation, in which
@@ -221,7 +253,7 @@ model, it may be beneficial to performance to adjust the
 influences the partitioning of the model by adjusting the assumed execution
 time of DPI imports.
 
-When using :vlopt:`--trace` to perform VCD tracing, the VCD trace
+When using :vlopt:`--trace-vcd` to perform VCD tracing, the VCD trace
 construction is parallelized using the same number of threads as specified
 with :vlopt:`--threads`, and is executed on the same thread pool as the model.
 
@@ -243,11 +275,14 @@ trace. FST tracing can utilize up to 2 offload threads, so there is no use
 of setting :vlopt:`--trace-threads` higher than 2 at the moment.
 
 When running a multithreaded model, the default Linux task scheduler often
-works against the model by assuming short-lived threads and thus
-it often schedules threads using multiple hyperthreads within the same
-physical core. For best performance, use the :command:`numactl` program to
-(when the threading count fits) select unique physical cores on the same
-socket. The same applies for :vlopt:`--trace-threads` as well.
+works against the model by assuming short-lived threads and thus it often
+schedules threads using multiple hyperthreads within the same physical
+core. If there is no affinity already set, on Linux only, Verilator
+attempts to set thread-to-processor affinity in a reasonable way.
+
+For best performance, use the :command:`numactl` program to (when the
+threading count fits) select unique physical cores on the same socket. The
+same applies for :vlopt:`--trace-threads` as well.
 
 As an example, if a model was Verilated with
 :vlopt:`--threads 4 <--threads>`, we consult:
@@ -290,8 +325,8 @@ and must be called only by the eval thread.
 If using :vlopt:`--sc`, the SystemC kernel is not thread-safe; therefore,
 the eval thread and main thread must be the same.
 
-If using :vlopt:`--trace`, the tracing classes must be constructed and
-called from the main thread.
+If using :vlopt:`--trace-vcd` or other trace options, the tracing classes
+must be constructed and called from the main thread.
 
 If using :vlopt:`--vpi`, since SystemVerilog VPI was not architected by
 IEEE to be multithreaded, Verilator requires all VPI calls are only made
@@ -367,10 +402,11 @@ Verilate in CMake
 .. code-block:: CMake
 
      verilate(target SOURCES source ... [TOP_MODULE top] [PREFIX name]
-              [TRACE] [TRACE_FST] [SYSTEMC] [COVERAGE]
+              [COVERAGE] [SYSTEMC]
+              [TRACE_FST] [TRACE_SAIF] [TRACE_VCD] [TRACE_THREADS num]
               [INCLUDE_DIRS dir ...] [OPT_SLOW ...] [OPT_FAST ...]
               [OPT_GLOBAL ..] [DIRECTORY dir] [THREADS num]
-              [TRACE_THREADS num] [VERILATOR_ARGS ...])
+              [VERILATOR_ARGS ...])
 
 Lowercase and ... should be replaced with arguments; the uppercase parts
 delimit the arguments and can be passed in any order or left out entirely
@@ -443,10 +479,6 @@ SystemC include directories and link to the SystemC libraries.
 
    Optional. Enable a multithreaded model; see :vlopt:`--threads`.
 
-.. describe:: TRACE_THREADS
-
-   Optional. Enable multithreaded FST trace; see :vlopt:`--trace-threads`.
-
 .. describe:: TOP_MODULE
 
    Optional. Sets the name of the top module. Defaults to the name of the
@@ -454,14 +486,27 @@ SystemC include directories and link to the SystemC libraries.
 
 .. describe:: TRACE
 
-   Optional. Enables VCD tracing if present, equivalent to "VERILATOR_ARGS
-   --trace".
+   Deprecated. Same as TRACE_VCD, which should be used instead.
 
 .. describe:: TRACE_FST
 
    Optional. Enables FST tracing if present, equivalent to "VERILATOR_ARGS
    --trace-fst".
 
+.. describe:: TRACE_SAIF
+
+   Optional. Enables SAIF tracing if present, equivalent to "VERILATOR_ARGS
+   --trace-saif".
+
+.. describe:: TRACE_THREADS
+
+   Optional. Enable multithreaded FST trace; see :vlopt:`--trace-threads`.
+
+.. describe:: TRACE_VCD
+
+   Optional. Enables VCD tracing if present, equivalent to "VERILATOR_ARGS
+   --trace-vcd".
+
 .. describe:: VERILATOR_ARGS
 
    Optional. Extra arguments to Verilator. Do not specify :vlopt:`--Mdir`

docs/guide/warnings.rst

@@ -1,9 +1,9 @@
 .. Copyright 2003-2025 by Wilson Snyder.
 .. SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
 
-*******************
-Errors and Warnings
-*******************
+=====================
+ Errors and Warnings
+=====================
 
 .. _Disabling Warnings:
 
@@ -37,7 +37,7 @@ Warnings may be disabled in multiple ways:
    propagate upwards to any parent file (file that included the file with
    the lint_off).
 
-#. Disable the warning using :ref:`Configuration Files` with a
+#. Disable the warning using :ref:`Verilator Control Files` with a
    :option:`lint_off` command.  This is useful when a script suppresses
    warnings, and the Verilog source should not be changed.  This method also
    allows matching on the warning text.
@@ -68,6 +68,10 @@ source code corresponding to the error, prefixed by the line number and a "
 | ".  Following this is typically an arrow and ~ pointing at the error on
 the source line directly above.
 
+Instead of parsing this text diagnostic output, tools that need to
+understand Verilator's warning output should read the SARIF JSON output
+created with :vlopt:`--diagnostics-sarif`.
+
 
 List Of Warnings
 ================
@@ -86,6 +90,8 @@ List Of Warnings
    Limitations`.
 
 
+   .. t_dist_docs_style restart_sort
+
 .. option:: ALWCOMBORDER
 
    .. TODO better example
@@ -105,6 +111,27 @@ List Of Warnings
    simulate correctly.
 
 
+.. option:: ALWNEVER
+
+   Warning that an `always @*` statement has no variables being read,
+   therefore the event list is empty, and as there are no events to wake
+   the process up, the always will never execute.
+
+   Faulty example:
+
+   .. include:: ../../docs/gen/ex_ALWNEVER_faulty.rst
+
+   Results in:
+
+   .. include:: ../../docs/gen/ex_ALWNEVER_msg.rst
+
+   To repair, assuming the intent was to execute the statements at e.g.
+   time zero, instead use an `always_comb` statement.
+
+   Ignoring this warning will only suppress the lint check; it will
+   simulate correctly.
+
+
 .. option:: ASCRANGE
 
    .. TODO better example
@@ -165,6 +192,28 @@ List Of Warnings
    'pragma protect'.  Third-party pragmas not defined by IEEE 1800-2023 are
    ignored.
 
+   This error may be disabled with a lint_off BADSTDPRAGMA metacomment.
+
+   Ignoring this warning will cause the pragma to be ignored.
+
+
+.. option:: BADVLTPRAGMA
+
+   An error that a `/*verilator ...*/` metacomment pragma is badly formed
+   or not understood.
+
+   Faulty example:
+
+   .. include:: ../../docs/gen/ex_BADVLTPRAGMA_faulty.rst
+
+   Results in:
+
+   .. include:: ../../docs/gen/ex_BADVLTPRAGMA_msg.rst
+
+   This error may be disabled with a lint_off BADVLTPRAGMA metacomment.
+
+   Ignoring this warning will cause the pragma to be ignored.
+
 
 .. option:: BLKANDNBLK
 
@@ -183,23 +232,32 @@ List Of Warnings
    public task, or when the blocking and non-blocking assignments have
    non-overlapping bits and structure members.
 
+   From Verilator 5.038, this warning is only issued when Verilator can't prove that
+   the assignments are to non-overlapping sub-parts, and the blocking
+   assignment is in combinational logic (which is the case where simulation
+   results might differ from other simulators). Review any BLKANDNBLK
+   cases carefully after this version, and sign them off as
+   described above, only if know for sure the updates are not to overlapping
+   parts of the signal.
+
    Generally, this is caused by a register driven by both combo logic and a
    flop:
 
    .. code-block:: sv
 
-         logic [1:0] foo;
-         always @(posedge clk)  foo[0] <= ...
-         always_comb foo[1] = ...
+         logic [3:0] foo;
+         always @(posedge clk) foo[index] <= ...  // With index != 0
+         always_comb foo[0] = ...
 
    Instead, use a different register for the flop:
 
    .. code-block:: sv
 
-         logic [1:0] foo;
-         always @(posedge clk)  foo_flopped[0] <= ...
-         always_comb foo[0] = foo_flopped[0];
-         always_comb foo[1] = ...
+         logic [3:0] foo;
+         logic [3:1] foo_flopped;
+         always @(posedge clk) foo_flopped[index] <= ... // With index != 0
+         always_comb foo[0] = ...
+         always_comb foo[3:1] = foo_flopped;
 
    Or, this may also avoid the error:
 
@@ -296,8 +354,8 @@ List Of Warnings
    Unique case statements that select on an enumerated variable, where all
    of the enumerated values are covered by case items, are considered
    complete even if the case statement does not cover illegal
-   non-enumerated values (IEEE 1800-2023 12.5.3).  To check that illegal
-   values are not hit, use :vlopt:`--assert`.
+   non-enumerated values (IEEE 1800-2023 12.5.3).  Verilator checks that
+   illegal values are not hit, unless :vlopt:`--no-assert-case` was used.
 
    Ignoring this warning will only suppress the lint check; it will
    simulate correctly.
@@ -335,8 +393,8 @@ List Of Warnings
 
    Warns that it is better style to use casez, and "?" in place of
    "x"'s.  See
-   `http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase_rev1_1.pdf
-   <http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase_rev1_1.pdf>`_
+   `http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase.pdf
+   <http://www.sunburst-design.com/papers/CummingsSNUG1999Boston_FullParallelCase.pdf>`_
 
    Ignoring this warning will only suppress the lint check; it will
    simulate correctly.
@@ -410,8 +468,8 @@ List Of Warnings
    is suppressed, Verilator, like synthesis, will convert this to a
    non-delayed assignment, which may result in logic races or other
    nasties.  See
-   `http://www.sunburst-design.com/papers/CummingsSNUG2000SJ_NBA_rev1_2.pdf
-   <http://www.sunburst-design.com/papers/CummingsSNUG2000SJ_NBA_rev1_2.pdf>`_
+   `http://www.sunburst-design.com/papers/CummingsSNUG2000SJ_NBA.pdf
+   <http://www.sunburst-design.com/papers/CummingsSNUG2000SJ_NBA.pdf>`_
 
    Ignoring this warning may make Verilator simulations differ from other
    simulators.
@@ -421,7 +479,7 @@ List Of Warnings
 
    Warns that Verilator does not support certain forms of
    :code:`constraint`, :code:`constraint_mode`, or :code:`rand_mode`, and
-   the construct was are ignored.
+   the construct was ignored.
 
    Ignoring this warning may make Verilator randomize() simulations differ
    from other simulators.
@@ -449,7 +507,7 @@ List Of Warnings
 
    Warns that Verilator does not support certain forms of
    :code:`covergroup`, :code:`coverpoint`, and coverage options, and the
-   construct was are ignored.
+   construct was ignored.
 
    Disabling the :option:`UNSUPPORTED` error also disables this warning.
 
@@ -472,6 +530,32 @@ List Of Warnings
    correctly.
 
 
+.. option:: DEFOVERRIDE
+
+   Warns that a macro definition within the code is being overridden by a
+   command line directive:
+
+   For example, running Verilator with :code:`<+define+\<DUP\>=\<def2\>>` and
+
+   .. code-block:: sv
+      :linenos:
+      :emphasize-lines: 1
+
+         `define DUP def2 //<--- Warning
+
+   Results in:
+
+   .. code-block::
+
+         %Warning-DEFOVERRIDE: example.v1:20: Overriding define: 'DEF' with value: 'def2' to existing command line define value: 'def1'
+                      ... Location of previous definition, with value: '50'
+
+   While not explicitly stated in the IEEE 1800-2023 standard, this warning
+   tracks with the other simulators' behavior of overriding macro
+   definitions within code files with the definition passed in through
+   the command line.
+
+
 .. option:: DEFPARAM
 
    Warns that the :code:`defparam` statement was deprecated in IEEE 1364-2001,
@@ -646,6 +730,28 @@ List Of Warnings
    missing."
 
 
+.. option:: ENUMITEMWIDTH
+
+   An error that an enum item value is being assigned from a value which
+   would be truncated (similar to :option:`WIDTHTRUNC`), or from a sized
+   literal constant with a different bit width (similar to
+   :option:`WIDTHTRUNC` or :option:`WIDTHEXPAND`).  IEEE requires this
+   error, but it may be disabled.
+
+   Faulty example:
+
+   .. code-block:: sv
+      :linenos:
+      :emphasize-lines: 2
+
+         typedef enum [3:0] {
+            WRONG_WIDTH = 33'h3  //<--- Warning
+         } enum_t;
+
+   To repair, correct the size of the item's value directly, or use a cast,
+   so the resulting width matches the enum's width.
+
+
 .. option:: ENUMVALUE
 
    An error that an enum data type value is being assigned from another data
@@ -1054,8 +1160,6 @@ List Of Warnings
 
 .. option:: LITENDIAN
 
-   .. TODO better example
-
    The naming of this warning is in contradiction with the common
    interpretation of little endian. It was therefore renamed to
    :option:`ASCRANGE`. While :option:`LITENDIAN` remains for
@@ -1131,6 +1235,19 @@ List Of Warnings
    discarded.
 
 
+.. option:: MODMISSING
+
+   .. TODO better example
+
+   Error that a module, typically referenced by a cell, was not found.
+   This is typically fatal, but may be suppressed in some linting
+   situations with missing libraries.
+
+   Ignoring this error will cause the cell definition to be discarded.
+   Simulation results will likely be wrong, so typically used only with
+   lint-only.
+
+
 .. option:: MULTIDRIVEN
 
    Warns that the specified signal comes from multiple :code:`always`
@@ -1187,6 +1304,8 @@ List Of Warnings
    modules' signals seem identical, e.g., multiple modules with a "clk"
    input.
 
+   Ignoring this warning will make multiple tops, as described in (3) above.
+
 
 .. option:: NEEDTIMINGOPT
 
@@ -1210,6 +1329,21 @@ List Of Warnings
    simulate correctly.
 
 
+.. option:: NOEFFECT
+
+   Warns that the statement will have no effect and is roughly equivalent
+   to not being present.  This is only issued when it is "non-obvious",
+   e.g. a :code:`if (0)` will not result in this warning.
+
+   Faulty example:
+
+   .. code-block:: sv
+
+         foreach (array[]) begin ... end  //<--- Warning
+
+   For a fix, remove the statement.
+
+
 .. option:: NOLATCH
 
    .. TODO better example
@@ -1222,13 +1356,6 @@ List Of Warnings
    simulate correctly.
 
 
-.. option:: NOTIMING
-
-   Error when a timing-related construct that requires :vlopt:`--timing` has
-   been encountered. Issued only if Verilator is run with the
-   :vlopt:`--no-timing` option.
-
-
 .. option:: NONSTD
 
    Warns when a non-standard language feature is used that has a standard
@@ -1236,6 +1363,16 @@ List Of Warnings
    :code:`$psprintf` system function is replaced by its standard equivalent
    :code:`$sformatf`.
 
+   Ignoring this warning will only suppress the lint check; it will
+   simulate correctly.
+
+
+.. option:: NOTIMING
+
+   Error when a timing-related construct that requires :vlopt:`--timing` has
+   been encountered. Issued only if Verilator is run with the
+   :vlopt:`--no-timing` option.
+
 
 .. option:: NULLPORT
 
@@ -1261,6 +1398,28 @@ List Of Warnings
    Ignoring this warning will only suppress the lint check; it will
    simulate correctly.
 
+
+.. option:: PARAMNODEFAULT
+
+   An error that a parameter is being declared that has no default value,
+   and this is being done in a non-ANSI block while this is only legal in
+   ANSI-style `#(...)` declarations.  IEEE 1800-2023 6.20.1 requires this
+   error, but some simulators accept this syntax.
+
+   Faulty example:
+
+   .. include:: ../../docs/gen/ex_PARAMNODEFAULT_faulty.rst
+
+   Results in:
+
+   .. include:: ../../docs/gen/ex_PARAMNODEFAULT_msg.rst
+
+   To fix the issue, move to an ANSI-style declaration.
+
+   Suppressing this error will only suppress the IEEE-required check; it
+   will simulate correctly.
+
+
 .. option:: PINCONNECTEMPTY
 
    .. TODO better example
@@ -1287,11 +1446,11 @@ List Of Warnings
 
    Faulty example:
 
-   .. include:: ../../docs/gen/ex_PKGNODECL_faulty.rst
+   .. include:: ../../docs/gen/ex_PINMISSING_faulty.rst
 
    Results in:
 
-   .. include:: ../../docs/gen/ex_PKGNODECL_msg.rst
+   .. include:: ../../docs/gen/ex_PINMISSING_msg.rst
 
    Repaired example:
 
@@ -1349,6 +1508,15 @@ List Of Warnings
    This error may be disabled with a lint_off PINNOTFOUND metacomment.
 
 
+.. option:: PKGNODECL
+
+   Never issued since version 5.038.  Historically an error that a
+   package/class appears to have been referenced that has not yet been
+   declared.  According to IEEE 1800-2023 26.3, all packages must be
+   declared before being used. However, several standard libraries
+   including UVM violate this, and other tools do not warn.
+
+
 .. option:: PORTSHORT
 
    Warns that an output port is connected to a constant.
@@ -1372,26 +1540,6 @@ List Of Warnings
    This error may be disabled with a lint_off PORTSHORT metacomment.
 
 
-.. option:: PKGNODECL
-
-   An error that a package/class appears to have been referenced that has
-   not yet been declared.  According to IEEE 1800-2023 26.3, all packages
-   must be declared before being used.
-
-   Faulty example:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_faulty.rst
-
-   Results in:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_msg.rst
-
-   Often the package is declared in its own header file.  In this case add
-   an include of that package header file to the referencing file.  (And
-   make sure you have header guards in the package's header file to prevent
-   multiple declarations of the package.)
-
-
 .. option:: PREPROCZERO
 
    Warns that a preprocessor \`ifdef/\`ifndef expression (added in IEEE
@@ -1416,6 +1564,40 @@ List Of Warnings
    The portable way to suppress this warning is to use a define value other
    than zero, when it is to be used in a preprocessor expression.
 
+   Ignoring this warning will only suppress the lint check; it will
+   simulate correctly.
+
+
+.. option:: PROCASSINIT
+
+   Warns that the specified signal is given an initial value where it is
+   declared, and is also driven in an always process.  Typically such
+   initial values should instead be set using a reset signal inside the
+   process, to match requirements of ASIC synthesis tools.  However,
+   declaration initializers are a valid FPGA design idiom and therefore,
+   FPGA users may want to disable this warning.
+
+   Faulty example:
+
+   .. include:: ../../docs/gen/ex_PROCASSINIT_faulty.rst
+
+   Results in:
+
+   .. include:: ../../docs/gen/ex_PROCASSINIT_msg.rst
+
+   One possible fix, adding a reset to the always:
+
+   .. include:: ../../docs/gen/ex_PROCASSINIT_fixed.rst
+
+   Alternatively, use an initial block for the initialization:
+
+   .. code-block:: sv
+
+      initial flop_out = 1;  // <--- Fixed
+
+   Disabled by default as this is a code-style warning; it will simulate
+   correctly.
+
 
 .. option:: PROCASSWIRE
 
@@ -1447,10 +1629,23 @@ List Of Warnings
    inside the protected region will be partly checked for correctness but is
    otherwise ignored.
 
-   Suppressing the warning may make Verilator differ from a simulator that
+   Ignoring the warning may make Verilator differ from a simulator that
    accepts the protected code.
 
 
+.. option:: PROTOTYPEMIS
+
+   Error that a function prototype does not match in some respects the
+   out-of-block declaration of that function. IEEE requires this error.
+
+   The typical solution is to fix the prototype to match the declaration
+   exactly, including in number of arguments, name of arguments, argument
+   data types, and return data type (for functions).
+
+   Disabling this error will cause Verilator to ignore the prototype and
+   may make the code illegal in other tools.
+
+
 .. option:: RANDC
 
    Historical, never issued since version 5.018, when :code:`randc` became
@@ -1465,6 +1660,9 @@ List Of Warnings
    Warns that a real number is being implicitly rounded to an integer, with
    possible loss of precision.
 
+   Ignoring this warning will only suppress the lint check; it will
+   simulate correctly.
+
    Faulty example:
 
    .. code-block:: sv
@@ -1494,8 +1692,12 @@ List Of Warnings
 
 .. option:: REDEFMACRO
 
-   Warns that the code has redefined the same macro with a different value,
-   for example:
+   Warns that the code has redefined the same macro with a different value.
+
+   Ignoring this warning will only suppress the lint check; it will
+   simulate correctly.
+
+   For example:
 
    .. code-block:: sv
       :linenos:
@@ -1632,6 +1834,18 @@ List Of Warnings
    simulators.
 
 
+.. option:: SPECIFYIGN
+
+   Warns that Verilator does not support certain constructs in
+   :code:`specify` blocks, nor :code:`$sdf_annotate`, and the construct was
+   ignored.
+
+   Disabling the :option:`UNSUPPORTED` error also disables this warning.
+
+   Ignoring this warning may make Verilator ignore lint checking on the
+   construct, and get different results from other simulators.
+
+
 .. option:: SPLITVAR
 
    Warns that a variable with a :option:`/*verilator&32;split_var*/`
@@ -2118,7 +2332,7 @@ List Of Warnings
 
    .. include:: ../../docs/gen/ex_VARHIDDEN_msg.rst
 
-   To resolve this, rename the variable to an unique name.
+   To resolve this, rename the inner or outer variable to an unique name.
 
 
 .. option:: WAITCONST
@@ -2181,21 +2395,6 @@ List Of Warnings
    .. include:: ../../docs/gen/ex_WIDTHEXPAND_1_fixed.rst
 
 
-.. option:: WIDTHTRUNC
-
-   A more granular :option:`WIDTH` warning, for when a value is
-   truncated. See :option:`WIDTH`.
-
-.. option:: WIDTHEXPAND
-
-   A more granular :option:`WIDTH` warning, for when a value is zero
-   expanded. See :option:`WIDTH`.
-
-.. option:: WIDTHXZEXPAND
-
-   A more granular :option:`WIDTH` warning, for when a value is X/Z
-   expanded. See :option:`WIDTH`.
-
 .. option:: WIDTHCONCAT
 
    Warns that based on the width rules of Verilog, a concatenate, or
@@ -2221,6 +2420,21 @@ List Of Warnings
    width to the parameter usage (:code:`{PAR[31:0], PAR[31:0]}`).
 
 
+.. option:: WIDTHEXPAND
+
+   A more granular :option:`WIDTH` warning, for when a value is zero
+   expanded. See :option:`WIDTH`.
+
+.. option:: WIDTHTRUNC
+
+   A more granular :option:`WIDTH` warning, for when a value is
+   truncated. See :option:`WIDTH`.
+
+.. option:: WIDTHXZEXPAND
+
+   A more granular :option:`WIDTH` warning, for when a value is X/Z
+   expanded. See :option:`WIDTH`.
+
 .. option:: ZERODLY
 
    Warns that `#0` delays do not schedule the process to be resumed in the

docs/internals.rst

@@ -450,7 +450,7 @@ as defined in the standard:
 - All other logic is assigned to the 'nba' region.
 
 For completeness, note that a subset of the 'act' region logic, specifically,
-the logic related to the pre-assignments of NBA updates (i.e., AstAssignPre
+the logic related to the pre-assignments of NBA updates (i.e., AstAlwaysPre
 nodes), is handled separately, but is executed as part of the 'act' region.
 
 Also note that all logic representing the committing of an NBA (i.e., Ast*Post)
@@ -1131,7 +1131,7 @@ Indentation and Naming Style
 ----------------------------
 
 We will work with contributors to fix up indentation style issues, but it
-is appreciated if you could match our style:
+is appreciated if you could match our style for C/C++:
 
 - Use "mixedCapsSymbols" instead of "underlined_symbols".
 
@@ -1143,9 +1143,8 @@ is appreciated if you could match our style:
   calls. (This convention has not been applied retroactively.)
 
 C and Python indentation is automatically maintained with "make format"
-using clang-format version 10.0.0, and yapf for python, and is
-automatically corrected in the CI actions. For those manually formatting C
-code:
+using clang-format version 18, and yapf for Python, and is automatically
+corrected in the CI actions. For those manually formatting C code:
 
 - Use four spaces per level, and no tabs.
 
@@ -1157,6 +1156,58 @@ code:
 - No spaces before semicolons, nor between a function's name and open
   parenthesis (only applies to functions; if/else has a following space).
 
+Verilog indentation is not yet automatically maintained, but:
+
+- Use two spaces per level, and no tabs.
+
+- Place `begin` on the same line as the earlier starting statement
+  e.g. `if`, and place the `end` on a separate line indented the same as
+  the starting statement.
+
+
+Commit messages
+---------------
+
+Pull requests do not typically edit ``Changes`` in order to reduce
+potential merge conflicts.  Instead, contributors should use an appropriate
+first line of the git commit message.  Maintainers periodically run
+``nodist/log_changes`` which analyzes the commit messages to suggest edits
+to the ``Changes`` file.
+
+The format of a commit message should be typically of the forms below.  The
+github issue number, and github pull number if different should be
+included.
+
+"Add <some feature> (#1234)"
+   For adding a new feature.
+"Fix <some item> (#1234)"
+   For a bug fix.
+"Improve <some item> (#1234)"
+   For improving something that previously existed.
+"Optimize <some item> (#1234)"
+   For improving performance.
+"Support <some feature> (#1234)"
+   For features that are described by IEEE were previously not supported.
+"Commentary"
+   For a super-trivial change to e.g. documentation.
+   These will typically not get described in the Changes file.
+"CI: <Add/Improve/etc as above> (#1234)"
+   For changes that only concern github actions.
+   These will typically not get described in the Changes file.
+"Tests: <Add/Improve/etc as above> (#1234)"
+   For changes that only concern tests.
+   These will typically not get described in the Changes file.
+"Internals: <Add/Improve/etc as above> (#1234)"
+   For changes that only concern developers, e.g. code cleanups.
+   These will typically not get described in the Changes file.
+
+The line's grammar should match the phrasing used in the Changes file.
+
+If the change does not affect user-visible function, also add "No
+functional change." if it's 99% certain not to change behavior, or "No
+functional change expected." if no change was expected but there may be
+uncertainty.
+
 
 The ``astgen`` Script
 ---------------------
@@ -1164,7 +1215,7 @@ The ``astgen`` Script
 The ``astgen`` script is used to generate some of the repetitive C++ code
 related to the ``AstNode`` type hierarchy. An example is the abstract ``visit``
 methods in ``VNVisitor``. There are other uses; please see the ``*__gen*``
-files in the bulid directories and the ``astgen`` script for details.  A
+files in the build directories and the ``astgen`` script for details.  A
 description of the more advanced features of ``astgen`` are provided here.
 
 
@@ -1470,7 +1521,7 @@ Preparing to Run Tests
 
 For all tests to pass, you must install the following packages:
 
--  SystemC to compile the SystemC outputs, see http://systemc.org
+-  SystemC to compile the SystemC outputs, see https://systemc.org
 
 -  vcddiff to find differences in VCD outputs. See the readme at
    https://github.com/veripool/vcddiff
@@ -1569,6 +1620,41 @@ environment can check their branches too by enabling the build workflow:
 
 -  Click Enable workflow.
 
+Benchmarking
+------------
+
+For benchmarking the effects of changes (simulation speed, memory consumption,
+Verilation time, etc.), you can use `RTLMeter
+<https://github.com/verilator/rtlmeter>`__, a benchmark suite designed for this
+purpose. The scripts provided with RTLMeter have many capabilities. For full
+details, see the `documentation of RTLMeter
+<https://verilator.github.io/rtlmeter>`__ itself.
+
+For a quick check, you an run the following after putting ``verilator`` on your
+``PATH``:
+
+.. code:: shell
+
+  ./rtlmeter run --cases "+standard" --workRoot work-a
+  ./rtlmeter report work-a
+
+To compare against an alternate version, again put that alternate ``verilator``
+on your ``PATH`` then run:
+
+.. code:: shell
+
+  ./rtlmeter run --cases "+standard" --workRoot work-b
+  ./rtlmeter compare work-a work-b
+
+The continuous integration system in GitHub Actions runs this benchmark suite
+nightly on the master branch. The performance numbers from these nightly runs
+can be viewed via the `RTLMeter results dashboard
+<https://verilator.github.io/verilator-rtlmeter-results>`__. Note that these
+results are collected on GitHub hosted runners. These are virtual machines
+operating in a potentially noisy environment, so time measurements can have
+significant variance. Experience shows that a ~20% time difference can be
+reliably measured on GitHub hosted runners, and smaller differences are
+noticeable over a few days of reruns as trends emerge from the noise.
 
 Fuzzing
 -------
@@ -1633,7 +1719,7 @@ scaled so it can be more useful with large graphs.
 
 For interactive graph viewing consider `xdot
 <https://github.com/jrfonseca/xdot.py>`__ or `ZGRViewer
-<http://zvtm.sourceforge.net/zgrviewer.html>`__. If you know of better
+<https://zvtm.sourceforge.net/zgrviewer.html>`__. If you know of better
 viewers (especially for large graphs) please let us know.
 
 
@@ -1903,7 +1989,7 @@ find what made a <e#*#*> line in the tree dumps):
 
 ::
 
-   watch AstNode::s_editCntGbl==####
+   watch AstNode::s_editCntGbl=####
 
 Then, when the watch fires, to break at every following change to that
 node:
@@ -1960,10 +2046,8 @@ Generally, what would you do to add a new feature?
 
 2. Make a testcase in the test_regress/t/t_EXAMPLE format, see `Testing`.
 
-3. If grammar changes are needed, look at the git version of VerilogPerl's
-   src/VParseGrammar.y, as this grammar supports the full SystemVerilog
-   language and has a lot of back-and-forth with Verilator's grammar. Copy
-   the appropriate rules to src/verilog.y and modify the productions.
+3. If grammar changes are needed, look at the IEEE 1800-2023 Appendix A, as
+   src/verilog.y generally follows the same rule layout.
 
 4. If a new Ast type is needed, add it to the appropriate V3AstNode*.h.
    Follow the convention described above about the AstNode type hierarchy.
@@ -2030,6 +2114,14 @@ the regression tests with OBJCACHE enabled and in parallel on a machine
 with many cores.  See the -j option and OBJCACHE environment variable.
 
 
+driver.py Pass-Thru Arguments
+-----------------------------
+
+Arguments not understood by `driver.py` which begin with `+verilator+` are
+passed through as Verilated executable arguments. Other not-understood
+arguments are passed as Verilator arguments.
+
+
 driver.py Non-Scenario Arguments
 --------------------------------
 
@@ -2046,6 +2138,11 @@ driver.py Non-Scenario Arguments
   Same as ``verilator --debugi level``: Set Verilator internal debugging
   level globally to the specified debug level (1-10).
 
+--driver-clean
+  After a test passes, remove the generated objects.  Reduces storage
+  requirements, but may result in longer runtime if the tests are run
+  again.
+
 --dump-tree
   Same as ``verilator --dump-tree``: Enable Verilator writing .tree debug
   files with dumping level 3, which dumps the standard critical stages.
@@ -2077,7 +2174,10 @@ driver.py Non-Scenario Arguments
 
 --j #
   Run number of parallel tests, or 0 to determine the count based on the
-  number of cores installed.  Requires Perl's Parallel::Forker package.
+  number of cores installed.
+
+--obj-suffix <name>
+  Append the argument to the name of the ``test_regress/obj_`` directories.
 
 --quiet
   Suppress all output except for failures and progress messages every 15

docs/security.rst

@@ -0,0 +1,41 @@
+.. for github, vim: syntax=reStructuredText
+
+Security Policy
+===============
+
+If you believe you have found a security issue in any Verilator-owned
+repository, create a `GitHub repository security advisory
+<https://docs.github.com/en/code-security/security-advisories/working-with-repository-security-advisories/creating-a-repository-security-advisory>`__.
+We request that you please not publicly disclose the issue until it has
+been addressed by us.
+
+SystemVerilog Security
+----------------------
+
+The SystemVerilog language includes `$system`, etc. operating system calls,
+and as such executables created by Verilator should be considered insecure.
+In contrast, it is a security issue if a Verilator-created data file, such
+as a coverage data file, when read with `verilator_coverage`, allows
+arbitrary code execution.
+
+Bug bounties
+------------
+
+While we encourage reports of suspected security problems, we are an open
+source project, and do not run any bug bounty programs.
+
+Preferred Languages
+-------------------
+
+We prefer all communications to be in English.
+
+Policy
+------
+
+We follow the principle of `Coordinated Vulnerability Disclosure
+<https://en.wikipedia.org/wiki/Coordinated_vulnerability_disclosure>`__.
+
+Distribution
+------------
+
+SPDX-License-Identifier: CC0-1.0

docs/spelling.txt

@@ -19,6 +19,7 @@ Asciidoc
 Ashutosh
 Ast
 Atmel
+Augustin
 Aurelien
 Badáň
 Bagri
@@ -109,6 +110,7 @@ Embecosm
 Engstrom
 Enzo
 Eugen
+Fabre
 Fabrizio
 Faucher
 Faure
@@ -142,6 +144,7 @@ Gileadi
 Giri
 Gisselquist
 Gladkikh
+GmbH
 Goessling
 Gonnen
 Goorah
@@ -244,10 +247,12 @@ Lesik
 Libenzi
 Licker
 Liland
+LinkDot
 Liu
 Liwei
 Lockhart
 Longo
+LteS
 Luca
 Luiza
 Lussier
@@ -271,6 +276,7 @@ Mednick
 Mei
 Melo
 Menküc
+Menon
 Michail
 Michiels
 Microsystems
@@ -301,12 +307,14 @@ Nauticus
 Newgard
 Nigam
 Nikana
+Niraj
 Niranjan
 Nitza
 Noack
 Nodine
 Ober
 Oleg
+Oler
 Olof
 Olofsson
 Oron
@@ -327,6 +335,7 @@ Prabhat
 Prabhu
 Prateek
 Pre
+Precompiling
 Preprocess
 Pretet
 Pretl
@@ -400,6 +409,7 @@ Stroebel
 Strouble
 Stucki
 Su
+Subst
 Suguimoto
 Sundararajan
 Sunderland
@@ -435,6 +445,7 @@ UNOPTFLAT
 Ubixum
 Ueno
 Uints
+Undefine
 Undefines
 Unsized
 Urbach
@@ -460,6 +471,7 @@ Verilog
 Vighnesh
 Viktor
 Vilp
+VlWide
 Vlip
 Vm
 Vukobratovic
@@ -471,6 +483,7 @@ Wfuture
 Whatson
 Wildman
 Wim
+Wipfli
 Wmisleading
 Wno
 Wojciech
@@ -501,6 +514,7 @@ Zhang
 abirkmanis
 accessor
 accessors
+acyclic
 adrienlemasle
 agrobman
 ahouska
@@ -531,10 +545,12 @@ basename
 bbox
 benchmarking
 biguint
+binToOneHot
 bindir
 biops
 bisonpre
 bitOpTree
+bitaggregat
 bitop
 bitstoreal
 blackbox
@@ -573,19 +589,24 @@ combinational
 combinatorial
 commandArgsPlusMatch
 compilable
+computable
 concat
+concatenatable
 concats
 conf
 config
 const
 constexpr
+constification
 constpool
+contify
 coredump
 coroutine
 coroutines
 countbits
 countones
 cout
+covergroup
 cpp
 cppstyle
 cpu
@@ -610,9 +631,13 @@ defparam
 demangling
 dep
 deparametrized
+deque
 der
 dereference
+dereferenced
+dereferencing
 desassign
+deserialize
 destructor
 desynchronization
 detections
@@ -620,6 +645,7 @@ dev
 devcontainer
 devel
 dir
+disambiguates
 displayb
 distcc
 doxygen
@@ -648,8 +674,10 @@ elab
 eliasphanna
 elike
 elsif
+enablement
 endcase
 endcelldefine
+endclass
 endfunction
 endgenerate
 endian
@@ -739,6 +767,8 @@ hierCMakeArgs
 hierMkArgs
 hierParameters
 hierVer
+html
+https
 hx
 hyperthreading
 hyperthreads
@@ -787,6 +817,7 @@ libtcmalloc
 libverilated
 linkers
 linter
+linters
 linux
 liu
 livelock
@@ -836,6 +867,7 @@ multithread
 multithreaded
 multithreading
 musl
+mutex
 mutexes
 mux
 muzafferkal
@@ -860,10 +892,12 @@ noprivate
 noreturn
 notif
 nullptr
+numactl
 onehot
 ooo
 oprofile
 ortegon
+oversized
 oversubscription
 parallelized
 param
@@ -900,6 +934,7 @@ pre
 precisions
 precompiled
 predefines
+prefetch
 prepareClone
 prepend
 prepended
@@ -945,6 +980,8 @@ realtime
 realtobits
 recoding
 recrem
+recurse
+recurses
 redeclaring
 regs
 reloop
@@ -960,6 +997,8 @@ runtime
 runtimes
 rw
 sVerilator
+saif
+sarif
 sawatzke
 sc
 scalared
@@ -1018,6 +1057,8 @@ swrite
 synthesizeable
 sys
 systemc
+taskify
+tcmalloc
 tenghtt
 testbench
 threadsafe
@@ -1054,6 +1095,7 @@ typename
 uint
 un
 unbased
+uncomment
 undef
 undefineall
 undriven
@@ -1071,6 +1113,7 @@ unroller
 unsized
 unsup
 untyped
+upcasting
 urandom
 uselib
 utimes
@@ -1093,7 +1136,9 @@ verilator
 verilog
 verilogmod
 verimake
+veriuser
 vl
+vlSelf
 vlopt
 vlt
 vltstd
@@ -1113,6 +1158,7 @@ vpiUndefined
 vpm
 vpp
 warmup
+wavealloca
 waveforms
 whitespace
 widthed

examples/cmake_hello_c/Makefile

@@ -20,26 +20,28 @@
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 ######################################################################
 
 # Check if CMake is installed and of correct version
 ifeq ($(shell which cmake),)
-TARGET := nocmake
+  TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
-CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
-CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
-CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
-ifeq ($(CMAKE_GT_3_8),true)
-TARGET := run
-else
-TARGET := oldcmake
-endif
+  CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+  CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
+  CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
+  CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
+  ifeq ($(CMAKE_GT_3_8),true)
+    TARGET := run
+  else
+    TARGET := oldcmake
+  endif
 endif
 
 default: $(TARGET)

examples/cmake_hello_sc/Makefile

@@ -20,44 +20,44 @@
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 ######################################################################
 
 # Check if CMake is installed and of correct version
 ifeq ($(shell which cmake),)
-	TARGET := nocmake
-else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
-CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
-CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
-CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
-ifneq ($(CMAKE_GT_3_8),true)
-TARGET := oldcmake
+  TARGET := nocmake
 else
+  CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+  CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
+  CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
+  CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
+  ifneq ($(CMAKE_GT_3_8),true)
+    TARGET := oldcmake
+  else
+    # Check if SC exists via a verilator call (empty if not)
+    SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
 
-# Check if SC exists via a verilator call (empty if not)
-SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
+    # Test whether SystemC is installed with CMake support
+    # This will print a CMake error about processing arguments that can (currently) be ignored.
+    ifneq (,$(SYSTEMC_EXISTS))
+      FINDSC := $(shell mkdir -p build && cd build && cmake --find-package -DNAME=SystemCLanguage -DCMAKE_USE_PTHREADS_INIT=ON -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST -DThreads_FOUND=ON)
+      ifneq (,$(findstring SystemCLanguage found,$(FINDSC)))
+        SYSTEMC_SET := true
+      endif
+    endif
 
-# Test whether SystemC is installed with CMake support
-# This will print a CMake error about processing arguments that can (currently) be ignored.
-ifneq (,$(SYSTEMC_EXISTS))
-FINDSC := $(shell mkdir -p build && cd build && cmake --find-package -DNAME=SystemCLanguage -DCMAKE_USE_PTHREADS_INIT=ON -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST -DThreads_FOUND=ON)
-ifneq (,$(findstring SystemCLanguage found,$(FINDSC)))
-SYSTEMC_SET := true
-endif
-endif
-
-ifeq ($(SYSTEMC_SET), true)
-TARGET := run
-else
-TARGET := nosc
-endif
-
-endif
+    ifeq ($(SYSTEMC_SET), true)
+      TARGET := run
+    else
+      TARGET := nosc
+    endif
+  endif
 endif
 
 default: $(TARGET)

examples/cmake_protect_lib/Makefile

@@ -20,26 +20,28 @@
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 ######################################################################
 
 # Check if CMake is installed and of correct version
 ifeq ($(shell which cmake),)
-TARGET := nocmake
+  TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
-CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
-CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
-CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
-ifeq ($(CMAKE_GT_3_8),true)
-TARGET := run
-else
-TARGET := oldcmake
-endif
+  CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+  CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
+  CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
+  CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
+  ifeq ($(CMAKE_GT_3_8),true)
+    TARGET := run
+  else
+    TARGET := oldcmake
+  endif
 endif
 
 default: $(TARGET)

examples/cmake_tracing_c/CMakeLists.txt

@@ -36,7 +36,7 @@ add_executable(example ../make_tracing_c/sim_main.cpp)
 target_compile_features(example PUBLIC cxx_std_14)
 
 # Add the Verilated circuit to the target
-verilate(example COVERAGE TRACE
+verilate(example COVERAGE TRACE_VCD
   INCLUDE_DIRS "../make_tracing_c"
   VERILATOR_ARGS -f ../make_tracing_c/input.vc -x-assign fast
   SOURCES ../make_tracing_c/top.v

examples/cmake_tracing_c/Makefile

@@ -20,26 +20,28 @@
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 ######################################################################
 
 # Check if CMake is installed and of correct version
 ifeq ($(shell which cmake),)
-TARGET := nocmake
+  TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
-CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
-CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
-CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
-ifeq ($(CMAKE_GT_3_8),true)
-TARGET := run
-else
-TARGET := oldcmake
-endif
+  CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+  CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
+  CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
+  CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
+  ifeq ($(CMAKE_GT_3_8),true)
+    TARGET := run
+  else
+    TARGET := oldcmake
+  endif
 endif
 
 default: $(TARGET)
@@ -59,7 +61,7 @@ run:
 	@echo
 	@echo "-- RUN ---------------------"
 	@mkdir -p logs
-	build/example +trace
+	build/example +trace_vcd
 
 	@echo
 	@echo "-- COVERAGE ----------------"

examples/cmake_tracing_sc/CMakeLists.txt

@@ -46,7 +46,7 @@ target_compile_features(example PUBLIC cxx_std_14)
 set_property(TARGET example PROPERTY CXX_STANDARD ${SystemC_CXX_STANDARD})
 
 # Add the Verilated circuit to the target
-verilate(example SYSTEMC COVERAGE TRACE
+verilate(example COVERAGE SYSTEMC TRACE_VCD
   INCLUDE_DIRS "../make_tracing_sc"
   VERILATOR_ARGS -f ../make_tracing_sc/input.vc -x-assign fast
   SOURCES ../make_tracing_sc/top.v

examples/cmake_tracing_sc/Makefile

@@ -20,44 +20,44 @@
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 ######################################################################
 
 # Check if CMake is installed and of correct version
 ifeq ($(shell which cmake),)
-	TARGET := nocmake
-else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
-CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
-CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
-CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
-ifneq ($(CMAKE_GT_3_8),true)
-TARGET := oldcmake
+  TARGET := nocmake
 else
+  CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+  CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
+  CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
+  CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
+  ifneq ($(CMAKE_GT_3_8),true)
+    TARGET := oldcmake
+  else
+    # Check if SC exists via a verilator call (empty if not)
+    SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
 
-# Check if SC exists via a verilator call (empty if not)
-SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
+    # Test whether SystemC is installed with CMake support
+    # This will print a CMake error about processing arguments that can (currently) be ignored.
+    ifneq (,$(SYSTEMC_EXISTS))
+      FINDSC := $(shell mkdir -p build && cd build && cmake --find-package -DNAME=SystemCLanguage -DCMAKE_USE_PTHREADS_INIT=ON -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST -DThreads_FOUND=ON)
+      ifneq (,$(findstring SystemCLanguage found,$(FINDSC)))
+        SYSTEMC_SET := true
+      endif
+    endif
 
-# Test whether SystemC is installed with CMake support
-# This will print a CMake error about processing arguments that can (currently) be ignored.
-ifneq (,$(SYSTEMC_EXISTS))
-FINDSC := $(shell mkdir -p build && cd build && cmake --find-package -DNAME=SystemCLanguage -DCMAKE_USE_PTHREADS_INIT=ON -DCOMPILER_ID=GNU -DLANGUAGE=CXX -DMODE=EXIST -DThreads_FOUND=ON)
-ifneq (,$(findstring SystemCLanguage found,$(FINDSC)))
-SYSTEMC_SET := true
-endif
-endif
-
-ifeq ($(SYSTEMC_SET), true)
-TARGET := run
-else
-TARGET := nosc
-endif
-
-endif
+    ifeq ($(SYSTEMC_SET), true)
+      TARGET := run
+    else
+      TARGET := nosc
+    endif
+  endif
 endif
 
 default: $(TARGET)
@@ -77,7 +77,7 @@ run:
 	@echo
 	@echo "-- RUN ---------------------"
 	@mkdir -p logs
-	build/example +trace
+	build/example +trace_vcd
 
 	@echo
 	@echo "-- COVERAGE ----------------"

examples/json_py/Makefile

@@ -15,10 +15,10 @@
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
+  VERILATOR = verilator
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif
 
 DOT = dot
@@ -31,17 +31,15 @@ PYTHON_VERSION_MINOR := $(word 2,${PYTHON_VERSION_FULL})
 PYTHON_GE_3_5 := $(shell [ ${PYTHON_VERSION_MAJOR} -eq 3 -a ${PYTHON_VERSION_MINOR} -ge 5 ] && echo true)
 
 ifeq (${PYTHON_GE_3_5},true)
-default: test
+  default: test
 else
-default: python_message
+  default: python_message
 endif
 
 python_message:
 	@echo "Found Python version ${PYTHON_VERSION}, but require >= 3.5"
 
-test: \
-	test-vl_file_copy \
-	test-vl_hier_graph \
+test: test-vl_file_copy test-vl_hier_graph
 
 test-vl_file_copy:
 	@echo "-- vl_file_copy example"

examples/json_py/sub.v

@@ -7,12 +7,12 @@
 
 module sub
   #(parameter type TYPE_t = logic)
-   (
-    input  TYPE_t in,
-    output TYPE_t out
-    );
+  (
+   input  TYPE_t in,
+   output TYPE_t out
+   );
 
-   // Some simple logic
-   always_comb out = ~in;
+  // Some simple logic
+  always_comb out = ~in;
 
 endmodule

examples/json_py/vl_hier_graph

@@ -58,11 +58,11 @@ class VlHierGraph:
                     top_module = False
                 fh.write("];\n")
 
-                cells = self.flatten(mod, lambda n: n['type'] == "CELL")
-                for cell in cells:
-                    def_number = self.addr_to_vertex_number(cell['modp'])
+                instances = self.flatten(mod, lambda n: n['type'] == "CELL")
+                for inst in instances:
+                    def_number = self.addr_to_vertex_number(inst['modp'])
                     fh.write("  n%d->n%d [label=\"%s\"];\n" %
-                             (mod_number, def_number, cell['name']))
+                             (mod_number, def_number, inst['name']))
 
             fh.write("}\n")
 

examples/make_hello_binary/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -26,10 +26,10 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
+  VERILATOR = verilator
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif
 
 default:

examples/make_hello_binary/top.v

@@ -7,8 +7,8 @@
 // See also https://verilator.org/guide/latest/examples.html"
 
 module top;
-   initial begin
-      $display("Hello World!");
-      $finish;
-   end
+  initial begin
+    $display("Hello World!");
+    $finish;
+  end
 endmodule

examples/make_hello_c/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -26,10 +26,10 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
+  VERILATOR = verilator
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif
 
 default:

examples/make_hello_c/top.v

@@ -7,8 +7,8 @@
 // See also https://verilator.org/guide/latest/examples.html"
 
 module top;
-   initial begin
-      $display("Hello World!");
-      $finish;
-   end
+  initial begin
+    $display("Hello World!");
+    $finish;
+  end
 endmodule

examples/make_hello_sc/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -26,19 +26,19 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
+  VERILATOR = verilator
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif
 
 # Check if SC exists via a verilator call (empty if not)
 SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
 
 ifneq ($(SYSTEMC_EXISTS),)
-default: run
+  default: run
 else
-default: nosc
+  default: nosc
 endif
 
 run:

examples/make_hello_sc/top.v

@@ -7,8 +7,8 @@
 // See also https://verilator.org/guide/latest/examples.html"
 
 module top;
-   initial begin
-      $display("Hello World!");
-      $finish;
-   end
+  initial begin
+    $display("Hello World!");
+    $finish;
+  end
 endmodule

examples/make_protect_lib/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -23,10 +23,10 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
+  VERILATOR = verilator
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
 endif
 
 VERILATOR_FLAGS =
@@ -43,7 +43,7 @@ VERILATOR_FLAGS += -Wall
 VERILATOR_FLAGS += -CFLAGS -DVL_TIME_CONTEXT
 
 # Make waveforms
-TOP_VERILATOR_FLAGS = $(VERILATOR_FLAGS) --trace
+TOP_VERILATOR_FLAGS = $(VERILATOR_FLAGS) --trace-vcd
 
 ######################################################################
 default: run
@@ -90,7 +90,6 @@ run:
 	@echo "To see waveforms, open logs/vlt_dump.vcd in a waveform viewer"
 	@echo
 
-
 ######################################################################
 # Other targets
 

examples/make_protect_lib/secret_impl.v

@@ -9,22 +9,29 @@
 
 module secret_impl
   (
-   input [31:0]        a,
-   input [31:0]        b,
+   input [31:0]      a,
+   input [31:0]      b,
    output logic [31:0] x,
-   input               clk);
+   input          clk,
+   input          reset_l);
 
-   logic [31:0]        accum_q = 0;
-   logic [31:0]        secret_value = 9;
+  logic [31:0] accum_q;
+  logic [31:0] secret_value;
 
-   initial $display("[%0t] %m: initialized", $time);
+  initial $display("[%0t] %m: initialized", $time);
 
-   always @(posedge clk) begin
+  always @(posedge clk) begin
+    if (!reset_l) begin
+      accum_q <= 0;
+      secret_value <= 9;
+    end
+    else begin
       accum_q <= accum_q + a;
       if (accum_q > 10)
         x <= b;
       else
         x <= a + b + secret_value;
-   end
+    end
+  end
 
 endmodule

examples/make_protect_lib/top.v

@@ -8,29 +8,39 @@
 
 module top (input clk);
 
-   integer cyc = 0;
-   logic [31:0] a = 0;
-   logic [31:0] b = 0;
-   logic [31:0] x;
+  int cyc;
+  logic reset_l;
+  logic [31:0] a;
+  logic [31:0] b;
+  logic [31:0] x;
 
-   verilated_secret secret (.a, .b, .x, .clk);
+  verilated_secret secret (.a, .b, .x, .clk, .reset_l);
 
-   always @(posedge clk) begin
-      $display("[%0t] cyc=%0d a=%0d b=%0d x=%0d", $time, cyc, a, b, x);
-      cyc <= cyc + 1;
-      if (cyc == 0) begin
-         a <= 5;
-         b <= 7;
-      end else if (cyc == 1) begin
-         a <= 6;
-         b <= 2;
-      end else if (cyc == 2) begin
-         a <= 1;
-         b <= 9;
-      end else if (cyc > 3) begin
-         $display("Done");
-         $finish;
-      end
-   end
+  always @(posedge clk) begin
+    $display("[%0t] cyc=%0d a=%0d b=%0d x=%0d", $time, cyc, a, b, x);
+    cyc <= cyc + 1;
+    if (cyc == 0) begin
+      reset_l <= 0;
+      a <= 0;
+      b <= 0;
+    end
+    else if (cyc == 1) begin
+      reset_l <= 1;
+      a <= 5;
+      b <= 7;
+    end
+    else if (cyc == 2) begin
+      a <= 6;
+      b <= 2;
+    end
+    else if (cyc == 3) begin
+      a <= 1;
+      b <= 9;
+    end
+    else if (cyc > 4) begin
+      $display("Done");
+      $finish;
+    end
+  end
 
 endmodule

examples/make_tracing_c/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -23,12 +23,12 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 
 # Generate C++ in executable form
@@ -40,7 +40,7 @@ VERILATOR_FLAGS += -x-assign fast
 # Warn abount lint issues; may not want this on less solid designs
 VERILATOR_FLAGS += -Wall
 # Make waveforms
-VERILATOR_FLAGS += --trace
+VERILATOR_FLAGS += --trace-vcd
 # Check SystemVerilog assertions
 VERILATOR_FLAGS += --assert
 # Generate coverage analysis
@@ -89,7 +89,6 @@ run:
 	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
 	@echo
 
-
 ######################################################################
 # Other targets
 

examples/make_tracing_c/Makefile_obj

@@ -32,7 +32,7 @@ CPPFLAGS += -DVL_DEBUG=1
 # For testing inside Verilator, "configure --enable-ccwarn" will do this
 # automatically; otherwise you may want this unconditionally enabled
 ifeq ($(CFG_WITH_CCWARN),yes)  # Local... Else don't burden users
-USER_CPPFLAGS_WALL += -W -Werror -Wall
+  USER_CPPFLAGS_WALL += -W -Werror -Wall
 endif
 
 # See the benchmarking section of bin/verilator.
@@ -51,5 +51,5 @@ OPT_FAST = -Os -fstrict-aliasing
 
 DEPS := $(wildcard *.d)
 ifneq ($(DEPS),)
-include $(DEPS)
+  include $(DEPS)
 endif

examples/make_tracing_c/sub.v

@@ -11,32 +11,32 @@ module sub
    input reset_l
    );
 
-   // Example counter/flop
-   reg [31:0] count_c;
-   always_ff @(posedge clk) begin
-      if (!reset_l) begin
-         /*AUTORESET*/
-         // Beginning of autoreset for uninitialized flops
-         count_c <= 32'h0;
-         // End of automatics
+  // Example counter/flop
+  reg [31:0] count_c;
+  always_ff @(posedge clk) begin
+    if (!reset_l) begin
+      /*AUTORESET*/
+      // Beginning of autoreset for uninitialized flops
+      count_c <= 32'h0;
+      // End of automatics
+    end
+    else begin
+      count_c <= count_c + 1;
+      if (count_c >= 3) begin
+        // This write is a magic value the Makefile uses to make sure the
+        // test completes successfully.
+        $write("*-* All Finished *-*\n");
+        $finish;
       end
-      else begin
-         count_c <= count_c + 1;
-         if (count_c >= 3) begin
-            // This write is a magic value the Makefile uses to make sure the
-            // test completes successfully.
-            $write("*-* All Finished *-*\n");
-            $finish;
-         end
-      end
-   end
+    end
+  end
 
-   // An example assertion
-   always_ff @(posedge clk) begin
-      AssertionExample : assert (!reset_l || count_c < 100);
-   end
+  // An example assertion
+  always_ff @(posedge clk) begin
+    AssertionExample : assert (!reset_l || count_c < 100);
+  end
 
-   // And example coverage analysis
-   cover property (@(posedge clk) count_c == 3);
+  // And example coverage analysis
+  cover property (@(posedge clk) count_c == 3);
 
 endmodule

examples/make_tracing_c/top.v

@@ -11,36 +11,36 @@
 module top
   (
    // Declare some signals so we can see how I/O works
-   input              clk,
-   input              reset_l,
+   input          clk,
+   input          reset_l,
 
    output wire [1:0]  out_small,
    output wire [39:0] out_quad,
    output wire [69:0] out_wide,
-   input [1:0]        in_small,
-   input [39:0]       in_quad,
-   input [69:0]       in_wide
+   input [1:0]      in_small,
+   input [39:0]     in_quad,
+   input [69:0]     in_wide
    );
 
-   // Connect up the outputs, using some trivial logic
-   assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
-   assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
-   assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+  // Connect up the outputs, using some trivial logic
+  assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
+  assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+  assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
 
-   // And an example sub module. The submodule will print stuff.
-   sub sub (/*AUTOINST*/
-            // Inputs
-            .clk                        (clk),
-            .reset_l                    (reset_l));
+  // And an example sub module. The submodule will print stuff.
+  sub sub (/*AUTOINST*/
+           // Inputs
+           .clk                         (clk),
+           .reset_l                     (reset_l));
 
-   // Print some stuff as an example
-   initial begin
-      if ($test$plusargs("trace") != 0) begin
-         $display("[%0t] Tracing to logs/vlt_dump.vcd...\n", $time);
-         $dumpfile("logs/vlt_dump.vcd");
-         $dumpvars();
-      end
-      $display("[%0t] Model running...\n", $time);
-   end
+  // Print some stuff as an example
+  initial begin
+    if ($test$plusargs("trace") != 0) begin
+      $display("[%0t] Tracing to logs/vlt_dump.vcd...\n", $time);
+      $dumpfile("logs/vlt_dump.vcd");
+      $dumpvars();
+    end
+    $display("[%0t] Model running...\n", $time);
+  end
 
 endmodule

examples/make_tracing_sc/Makefile

@@ -13,7 +13,7 @@
 # Check for sanity to avoid later confusion
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -23,12 +23,12 @@ endif
 # package install, and verilator is in your path. Otherwise find the
 # binary relative to $VERILATOR_ROOT (such as when inside the git sources).
 ifeq ($(VERILATOR_ROOT),)
-VERILATOR = verilator
-VERILATOR_COVERAGE = verilator_coverage
+  VERILATOR = verilator
+  VERILATOR_COVERAGE = verilator_coverage
 else
-export VERILATOR_ROOT
-VERILATOR = $(VERILATOR_ROOT)/bin/verilator
-VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
+  export VERILATOR_ROOT
+  VERILATOR = $(VERILATOR_ROOT)/bin/verilator
+  VERILATOR_COVERAGE = $(VERILATOR_ROOT)/bin/verilator_coverage
 endif
 
 VERILATOR_FLAGS =
@@ -41,7 +41,7 @@ VERILATOR_FLAGS += -x-assign fast
 # Warn abount lint issues; may not want this on less solid designs
 VERILATOR_FLAGS += -Wall
 # Make waveforms
-VERILATOR_FLAGS += --trace
+VERILATOR_FLAGS += --trace-vcd
 # Check SystemVerilog assertions
 VERILATOR_FLAGS += --assert
 # Generate coverage analysis
@@ -60,9 +60,9 @@ SYSTEMC_EXISTS := $(shell $(VERILATOR) --get-supported SYSTEMC)
 ######################################################################
 
 ifneq ($(SYSTEMC_EXISTS),)
-default: run
+  default: run
 else
-default: nosc
+  default: nosc
 endif
 
 run:
@@ -98,7 +98,6 @@ run:
 	@echo "To see waveforms, open vlt_dump.vcd in a waveform viewer"
 	@echo
 
-
 ######################################################################
 # Other targets
 

examples/make_tracing_sc/Makefile_obj

@@ -31,7 +31,7 @@ CPPFLAGS += -Wno-deprecated
 # For testing inside Verilator, "configure --enable-ccwarn" will do this
 # automatically; otherwise you may want this unconditionally enabled
 ifeq ($(CFG_WITH_CCWARN),yes)  # Local... Else don't burden users
-USER_CPPFLAGS_WALL += -W -Werror -Wall
+  USER_CPPFLAGS_WALL += -W -Werror -Wall
 endif
 
 # If you build your own rules from scratch, note you need to include
@@ -61,5 +61,5 @@ sim_main.o: sim_main.cpp $(VM_PREFIX).h
 
 DEPS := $(wildcard *.d)
 ifneq ($(DEPS),)
-include $(DEPS)
+  include $(DEPS)
 endif

examples/make_tracing_sc/sub.v

@@ -12,47 +12,47 @@ module sub
    input reset_l
    );
 
-   // Example counter/flop
-   reg [31:0] count_f;
-   always_ff @(posedge fastclk) begin
-      if (!reset_l) begin
-         /*AUTORESET*/
-         // Beginning of autoreset for uninitialized flops
-         count_f <= 32'h0;
-         // End of automatics
-      end
-      else begin
-         count_f <= count_f + 1;
-      end
-   end
+  // Example counter/flop
+  reg [31:0] count_f;
+  always_ff @(posedge fastclk) begin
+    if (!reset_l) begin
+      /*AUTORESET*/
+      // Beginning of autoreset for uninitialized flops
+      count_f <= 32'h0;
+      // End of automatics
+    end
+    else begin
+      count_f <= count_f + 1;
+    end
+  end
 
-   // Another example flop
-   reg [31:0] count_c;
-   always_ff @(posedge clk) begin
-      if (!reset_l) begin
-         /*AUTORESET*/
-         // Beginning of autoreset for uninitialized flops
-         count_c <= 32'h0;
-         // End of automatics
+  // Another example flop
+  reg [31:0] count_c;
+  always_ff @(posedge clk) begin
+    if (!reset_l) begin
+      /*AUTORESET*/
+      // Beginning of autoreset for uninitialized flops
+      count_c <= 32'h0;
+      // End of automatics
+    end
+    else begin
+      count_c <= count_c + 1;
+      if (count_c >= 3) begin
+        $display("[%0t] fastclk is %0d times faster than clk\n", $time, count_f / count_c);
+        // This write is a magic value the Makefile uses to make sure the
+        // test completes successfully.
+        $write("*-* All Finished *-*\n");
+        $finish;
       end
-      else begin
-         count_c <= count_c + 1;
-         if (count_c >= 3) begin
-            $display("[%0t] fastclk is %0d times faster than clk\n", $time, count_f / count_c);
-            // This write is a magic value the Makefile uses to make sure the
-            // test completes successfully.
-            $write("*-* All Finished *-*\n");
-            $finish;
-         end
-      end
-   end
+    end
+  end
 
-   // An example assertion
-   always_ff @(posedge clk) begin
-      AssertionExample : assert (!reset_l || count_c < 100);
-   end
+  // An example assertion
+  always_ff @(posedge clk) begin
+    AssertionExample : assert (!reset_l || count_c < 100);
+  end
 
-   // And example coverage analysis
-   cover property (@(posedge clk) count_c == 3);
+  // And example coverage analysis
+  cover property (@(posedge clk) count_c == 3);
 
 endmodule

examples/make_tracing_sc/top.v

@@ -23,21 +23,21 @@ module top
    input [69:0]       in_wide
    );
 
-   // Connect up the outputs, using some trivial logic
-   assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
-   assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
-   assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
+  // Connect up the outputs, using some trivial logic
+  assign out_small = ~reset_l ? '0 : (in_small + 2'b1);
+  assign out_quad  = ~reset_l ? '0 : (in_quad + 40'b1);
+  assign out_wide  = ~reset_l ? '0 : (in_wide + 70'b1);
 
-   // And an example sub module. The submodule will print stuff.
-   sub sub (/*AUTOINST*/
-            // Inputs
-            .clk                        (clk),
-            .fastclk                    (fastclk),
-            .reset_l                    (reset_l));
+  // And an example sub module. The submodule will print stuff.
+  sub sub (/*AUTOINST*/
+           // Inputs
+           .clk                         (clk),
+           .fastclk                     (fastclk),
+           .reset_l                     (reset_l));
 
-   // Print some stuff as an example
-   initial begin
-      $display("[%0t] Model running...\n", $time);
-   end
+  // Print some stuff as an example
+  initial begin
+    $display("[%0t] Model running...\n", $time);
+  end
 
 endmodule

include/gtkwave/fstapi.h

@@ -26,7 +26,8 @@
 #define FST_API_H
 
 #ifdef __cplusplus
-extern "C" {
+extern "C"
+{
 #endif
 
 #include <stdio.h>
@@ -36,428 +37,508 @@ extern "C" {
 #include <zlib.h>
 #include <inttypes.h>
 #if defined(_MSC_VER)
-    #include "fst_win_unistd.h"
+#include "fst_win_unistd.h"
 #else
-    #include <unistd.h>
+#include <unistd.h>
 #endif
 #include <time.h>
 
-#define FST_RDLOAD "FSTLOAD | "
-
 typedef uint32_t fstHandle;
 typedef uint32_t fstEnumHandle;
 
-enum fstWriterPackType {
-    FST_WR_PT_ZLIB             = 0,
-    FST_WR_PT_FASTLZ           = 1,
-    FST_WR_PT_LZ4              = 2
+enum fstWriterPackType
+{
+    FST_WR_PT_ZLIB = 0,
+    FST_WR_PT_FASTLZ = 1,
+    FST_WR_PT_LZ4 = 2
 };
 
-enum fstFileType {
-    FST_FT_MIN                 = 0,
+enum fstFileType
+{
+    FST_FT_MIN = 0,
 
-    FST_FT_VERILOG             = 0,
-    FST_FT_VHDL                = 1,
-    FST_FT_VERILOG_VHDL        = 2,
+    FST_FT_VERILOG = 0,
+    FST_FT_VHDL = 1,
+    FST_FT_VERILOG_VHDL = 2,
 
-    FST_FT_MAX                 = 2
+    FST_FT_MAX = 2
 };
 
-enum fstBlockType {
-    FST_BL_HDR                 = 0,
-    FST_BL_VCDATA              = 1,
-    FST_BL_BLACKOUT            = 2,
-    FST_BL_GEOM                = 3,
-    FST_BL_HIER                = 4,
-    FST_BL_VCDATA_DYN_ALIAS    = 5,
-    FST_BL_HIER_LZ4            = 6,
-    FST_BL_HIER_LZ4DUO         = 7,
-    FST_BL_VCDATA_DYN_ALIAS2   = 8,
+enum fstBlockType
+{
+    FST_BL_HDR = 0,
+    FST_BL_VCDATA = 1,
+    FST_BL_BLACKOUT = 2,
+    FST_BL_GEOM = 3,
+    FST_BL_HIER = 4,
+    FST_BL_VCDATA_DYN_ALIAS = 5,
+    FST_BL_HIER_LZ4 = 6,
+    FST_BL_HIER_LZ4DUO = 7,
+    FST_BL_VCDATA_DYN_ALIAS2 = 8,
 
-    FST_BL_ZWRAPPER            = 254,   /* indicates that whole trace is gz wrapped */
-    FST_BL_SKIP                = 255    /* used while block is being written */
+    FST_BL_ZWRAPPER = 254, /* indicates that whole trace is gz wrapped */
+    FST_BL_SKIP = 255 /* used while block is being written */
 };
 
-enum fstScopeType {
-    FST_ST_MIN                 = 0,
+enum fstScopeType
+{
+    FST_ST_MIN = 0,
 
-    FST_ST_VCD_MODULE          = 0,
-    FST_ST_VCD_TASK            = 1,
-    FST_ST_VCD_FUNCTION        = 2,
-    FST_ST_VCD_BEGIN           = 3,
-    FST_ST_VCD_FORK            = 4,
-    FST_ST_VCD_GENERATE        = 5,
-    FST_ST_VCD_STRUCT          = 6,
-    FST_ST_VCD_UNION           = 7,
-    FST_ST_VCD_CLASS           = 8,
-    FST_ST_VCD_INTERFACE       = 9,
-    FST_ST_VCD_PACKAGE         = 10,
-    FST_ST_VCD_PROGRAM         = 11,
+    FST_ST_VCD_MODULE = 0,
+    FST_ST_VCD_TASK = 1,
+    FST_ST_VCD_FUNCTION = 2,
+    FST_ST_VCD_BEGIN = 3,
+    FST_ST_VCD_FORK = 4,
+    FST_ST_VCD_GENERATE = 5,
+    FST_ST_VCD_STRUCT = 6,
+    FST_ST_VCD_UNION = 7,
+    FST_ST_VCD_CLASS = 8,
+    FST_ST_VCD_INTERFACE = 9,
+    FST_ST_VCD_PACKAGE = 10,
+    FST_ST_VCD_PROGRAM = 11,
 
-    FST_ST_VHDL_ARCHITECTURE   = 12,
-    FST_ST_VHDL_PROCEDURE      = 13,
-    FST_ST_VHDL_FUNCTION       = 14,
-    FST_ST_VHDL_RECORD         = 15,
-    FST_ST_VHDL_PROCESS        = 16,
-    FST_ST_VHDL_BLOCK          = 17,
-    FST_ST_VHDL_FOR_GENERATE   = 18,
-    FST_ST_VHDL_IF_GENERATE    = 19,
-    FST_ST_VHDL_GENERATE       = 20,
-    FST_ST_VHDL_PACKAGE        = 21,
+    FST_ST_VHDL_ARCHITECTURE = 12,
+    FST_ST_VHDL_PROCEDURE = 13,
+    FST_ST_VHDL_FUNCTION = 14,
+    FST_ST_VHDL_RECORD = 15,
+    FST_ST_VHDL_PROCESS = 16,
+    FST_ST_VHDL_BLOCK = 17,
+    FST_ST_VHDL_FOR_GENERATE = 18,
+    FST_ST_VHDL_IF_GENERATE = 19,
+    FST_ST_VHDL_GENERATE = 20,
+    FST_ST_VHDL_PACKAGE = 21,
 
-    FST_ST_MAX                 = 21,
+    FST_ST_MAX = 21,
 
-    FST_ST_GEN_ATTRBEGIN       = 252,
-    FST_ST_GEN_ATTREND         = 253,
+    FST_ST_GEN_ATTRBEGIN = 252,
+    FST_ST_GEN_ATTREND = 253,
 
-    FST_ST_VCD_SCOPE           = 254,
-    FST_ST_VCD_UPSCOPE         = 255
+    FST_ST_VCD_SCOPE = 254,
+    FST_ST_VCD_UPSCOPE = 255
 };
 
-enum fstVarType {
-    FST_VT_MIN                 = 0,     /* start of vartypes */
+enum fstVarType
+{
+    FST_VT_MIN = 0, /* start of vartypes */
 
-    FST_VT_VCD_EVENT           = 0,
-    FST_VT_VCD_INTEGER         = 1,
-    FST_VT_VCD_PARAMETER       = 2,
-    FST_VT_VCD_REAL            = 3,
-    FST_VT_VCD_REAL_PARAMETER  = 4,
-    FST_VT_VCD_REG             = 5,
-    FST_VT_VCD_SUPPLY0         = 6,
-    FST_VT_VCD_SUPPLY1         = 7,
-    FST_VT_VCD_TIME            = 8,
-    FST_VT_VCD_TRI             = 9,
-    FST_VT_VCD_TRIAND          = 10,
-    FST_VT_VCD_TRIOR           = 11,
-    FST_VT_VCD_TRIREG          = 12,
-    FST_VT_VCD_TRI0            = 13,
-    FST_VT_VCD_TRI1            = 14,
-    FST_VT_VCD_WAND            = 15,
-    FST_VT_VCD_WIRE            = 16,
-    FST_VT_VCD_WOR             = 17,
-    FST_VT_VCD_PORT            = 18,
-    FST_VT_VCD_SPARRAY         = 19,    /* used to define the rownum (index) port for a sparse array */
-    FST_VT_VCD_REALTIME        = 20,
+    FST_VT_VCD_EVENT = 0,
+    FST_VT_VCD_INTEGER = 1,
+    FST_VT_VCD_PARAMETER = 2,
+    FST_VT_VCD_REAL = 3,
+    FST_VT_VCD_REAL_PARAMETER = 4,
+    FST_VT_VCD_REG = 5,
+    FST_VT_VCD_SUPPLY0 = 6,
+    FST_VT_VCD_SUPPLY1 = 7,
+    FST_VT_VCD_TIME = 8,
+    FST_VT_VCD_TRI = 9,
+    FST_VT_VCD_TRIAND = 10,
+    FST_VT_VCD_TRIOR = 11,
+    FST_VT_VCD_TRIREG = 12,
+    FST_VT_VCD_TRI0 = 13,
+    FST_VT_VCD_TRI1 = 14,
+    FST_VT_VCD_WAND = 15,
+    FST_VT_VCD_WIRE = 16,
+    FST_VT_VCD_WOR = 17,
+    FST_VT_VCD_PORT = 18,
+    FST_VT_VCD_SPARRAY = 19, /* used to define the rownum (index) port for a sparse array */
+    FST_VT_VCD_REALTIME = 20,
 
-    FST_VT_GEN_STRING          = 21,    /* generic string type   (max len is defined dynamically via fstWriterEmitVariableLengthValueChange) */
+    FST_VT_GEN_STRING = 21, /* generic string type   (max len is defined dynamically via
+                                fstWriterEmitVariableLengthValueChange) */
 
-    FST_VT_SV_BIT              = 22,
-    FST_VT_SV_LOGIC            = 23,
-    FST_VT_SV_INT              = 24,    /* declare as size = 32 */
-    FST_VT_SV_SHORTINT         = 25,    /* declare as size = 16 */
-    FST_VT_SV_LONGINT          = 26,    /* declare as size = 64 */
-    FST_VT_SV_BYTE             = 27,    /* declare as size = 8  */
-    FST_VT_SV_ENUM             = 28,    /* declare as appropriate type range */
-    FST_VT_SV_SHORTREAL        = 29,    /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted as double, not a float) */
+    FST_VT_SV_BIT = 22,
+    FST_VT_SV_LOGIC = 23,
+    FST_VT_SV_INT = 24, /* declare as size = 32 */
+    FST_VT_SV_SHORTINT = 25, /* declare as size = 16 */
+    FST_VT_SV_LONGINT = 26, /* declare as size = 64 */
+    FST_VT_SV_BYTE = 27, /* declare as size = 8  */
+    FST_VT_SV_ENUM = 28, /* declare as appropriate type range */
+    FST_VT_SV_SHORTREAL = 29, /* declare and emit same as FST_VT_VCD_REAL (needs to be emitted
+                                    as double, not a float) */
 
-    FST_VT_MAX                 = 29     /* end of vartypes */
+    FST_VT_MAX = 29 /* end of vartypes */
 };
 
-enum fstVarDir {
-    FST_VD_MIN         = 0,
+enum fstVarDir
+{
+    FST_VD_MIN = 0,
 
-    FST_VD_IMPLICIT    = 0,
-    FST_VD_INPUT       = 1,
-    FST_VD_OUTPUT      = 2,
-    FST_VD_INOUT       = 3,
-    FST_VD_BUFFER      = 4,
-    FST_VD_LINKAGE     = 5,
+    FST_VD_IMPLICIT = 0,
+    FST_VD_INPUT = 1,
+    FST_VD_OUTPUT = 2,
+    FST_VD_INOUT = 3,
+    FST_VD_BUFFER = 4,
+    FST_VD_LINKAGE = 5,
 
-    FST_VD_MAX         = 5
+    FST_VD_MAX = 5
 };
 
-enum fstHierType {
-    FST_HT_MIN         = 0,
+enum fstHierType
+{
+    FST_HT_MIN = 0,
 
-    FST_HT_SCOPE       = 0,
-    FST_HT_UPSCOPE     = 1,
-    FST_HT_VAR         = 2,
-    FST_HT_ATTRBEGIN   = 3,
-    FST_HT_ATTREND     = 4,
+    FST_HT_SCOPE = 0,
+    FST_HT_UPSCOPE = 1,
+    FST_HT_VAR = 2,
+    FST_HT_ATTRBEGIN = 3,
+    FST_HT_ATTREND = 4,
 
-    /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when fstHier bridges other formats */
-    FST_HT_TREEBEGIN   = 5,
-    FST_HT_TREEEND     = 6,
+    /* FST_HT_TREEBEGIN and FST_HT_TREEEND are not yet used by FST but are currently used when
+        fstHier bridges other formats */
+    FST_HT_TREEBEGIN = 5,
+    FST_HT_TREEEND = 6,
 
-    FST_HT_MAX         = 6
+    FST_HT_MAX = 6
 };
 
-enum fstAttrType {
-    FST_AT_MIN         = 0,
+enum fstAttrType
+{
+    FST_AT_MIN = 0,
 
-    FST_AT_MISC        = 0,     /* self-contained: does not need matching FST_HT_ATTREND */
-    FST_AT_ARRAY       = 1,
-    FST_AT_ENUM        = 2,
-    FST_AT_PACK        = 3,
+    FST_AT_MISC = 0, /* self-contained: does not need matching FST_HT_ATTREND */
+    FST_AT_ARRAY = 1,
+    FST_AT_ENUM = 2,
+    FST_AT_PACK = 3,
 
-    FST_AT_MAX         = 3
+    FST_AT_MAX = 3
 };
 
-enum fstMiscType {
-    FST_MT_MIN         = 0,
+enum fstMiscType
+{
+    FST_MT_MIN = 0,
 
-    FST_MT_COMMENT     = 0,     /* use fstWriterSetComment() to emit */
-    FST_MT_ENVVAR      = 1,     /* use fstWriterSetEnvVar() to emit */
-    FST_MT_SUPVAR      = 2,     /* use fstWriterCreateVar2() to emit */
-    FST_MT_PATHNAME    = 3,     /* reserved for fstWriterSetSourceStem() string -> number management */
-    FST_MT_SOURCESTEM  = 4,     /* use fstWriterSetSourceStem() to emit */
-    FST_MT_SOURCEISTEM = 5,     /* use fstWriterSetSourceInstantiationStem() to emit */
-    FST_MT_VALUELIST   = 6,	/* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */
-    FST_MT_ENUMTABLE   = 7,	/* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */
-    FST_MT_UNKNOWN     = 8,
+    FST_MT_COMMENT = 0, /* use fstWriterSetComment() to emit */
+    FST_MT_ENVVAR = 1, /* use fstWriterSetEnvVar() to emit */
+    FST_MT_SUPVAR = 2, /* use fstWriterCreateVar2() to emit */
+    FST_MT_PATHNAME = 3, /* reserved for fstWriterSetSourceStem() string -> number management */
+    FST_MT_SOURCESTEM = 4, /* use fstWriterSetSourceStem() to emit */
+    FST_MT_SOURCEISTEM = 5, /* use fstWriterSetSourceInstantiationStem() to emit */
+    FST_MT_VALUELIST =
+        6, /* use fstWriterSetValueList() to emit, followed by fstWriterCreateVar*() */
+    FST_MT_ENUMTABLE =
+        7, /* use fstWriterCreateEnumTable() and fstWriterEmitEnumTableRef() to emit */
+    FST_MT_UNKNOWN = 8,
 
-    FST_MT_MAX         = 8
+    FST_MT_MAX = 8
 };
 
-enum fstArrayType {
-    FST_AR_MIN         = 0,
+enum fstArrayType
+{
+    FST_AR_MIN = 0,
 
-    FST_AR_NONE        = 0,
-    FST_AR_UNPACKED    = 1,
-    FST_AR_PACKED      = 2,
-    FST_AR_SPARSE      = 3,
+    FST_AR_NONE = 0,
+    FST_AR_UNPACKED = 1,
+    FST_AR_PACKED = 2,
+    FST_AR_SPARSE = 3,
 
-    FST_AR_MAX         = 3
+    FST_AR_MAX = 3
 };
 
-enum fstEnumValueType {
-    FST_EV_SV_INTEGER           = 0,
-    FST_EV_SV_BIT               = 1,
-    FST_EV_SV_LOGIC             = 2,
-    FST_EV_SV_INT               = 3,
-    FST_EV_SV_SHORTINT          = 4,
-    FST_EV_SV_LONGINT           = 5,
-    FST_EV_SV_BYTE              = 6,
-    FST_EV_SV_UNSIGNED_INTEGER  = 7,
-    FST_EV_SV_UNSIGNED_BIT      = 8,
-    FST_EV_SV_UNSIGNED_LOGIC    = 9,
-    FST_EV_SV_UNSIGNED_INT      = 10,
+enum fstEnumValueType
+{
+    FST_EV_SV_INTEGER = 0,
+    FST_EV_SV_BIT = 1,
+    FST_EV_SV_LOGIC = 2,
+    FST_EV_SV_INT = 3,
+    FST_EV_SV_SHORTINT = 4,
+    FST_EV_SV_LONGINT = 5,
+    FST_EV_SV_BYTE = 6,
+    FST_EV_SV_UNSIGNED_INTEGER = 7,
+    FST_EV_SV_UNSIGNED_BIT = 8,
+    FST_EV_SV_UNSIGNED_LOGIC = 9,
+    FST_EV_SV_UNSIGNED_INT = 10,
     FST_EV_SV_UNSIGNED_SHORTINT = 11,
-    FST_EV_SV_UNSIGNED_LONGINT  = 12,
-    FST_EV_SV_UNSIGNED_BYTE     = 13,
+    FST_EV_SV_UNSIGNED_LONGINT = 12,
+    FST_EV_SV_UNSIGNED_BYTE = 13,
 
-    FST_EV_REG			= 14,
-    FST_EV_TIME			= 15,
+    FST_EV_REG = 14,
+    FST_EV_TIME = 15,
 
-    FST_EV_MAX                  = 15
+    FST_EV_MAX = 15
 };
 
-enum fstPackType {
-    FST_PT_NONE          = 0,
-    FST_PT_UNPACKED      = 1,
-    FST_PT_PACKED        = 2,
+enum fstPackType
+{
+    FST_PT_NONE = 0,
+    FST_PT_UNPACKED = 1,
+    FST_PT_PACKED = 2,
     FST_PT_TAGGED_PACKED = 3,
 
-    FST_PT_MAX           = 3
+    FST_PT_MAX = 3
 };
 
-enum fstSupplementalVarType {
-    FST_SVT_MIN                    = 0,
+enum fstSupplementalVarType
+{
+    FST_SVT_MIN = 0,
 
-    FST_SVT_NONE                   = 0,
+    FST_SVT_NONE = 0,
 
-    FST_SVT_VHDL_SIGNAL            = 1,
-    FST_SVT_VHDL_VARIABLE          = 2,
-    FST_SVT_VHDL_CONSTANT          = 3,
-    FST_SVT_VHDL_FILE              = 4,
-    FST_SVT_VHDL_MEMORY            = 5,
+    FST_SVT_VHDL_SIGNAL = 1,
+    FST_SVT_VHDL_VARIABLE = 2,
+    FST_SVT_VHDL_CONSTANT = 3,
+    FST_SVT_VHDL_FILE = 4,
+    FST_SVT_VHDL_MEMORY = 5,
 
-    FST_SVT_MAX                    = 5
+    FST_SVT_MAX = 5
 };
 
-enum fstSupplementalDataType {
-    FST_SDT_MIN                    = 0,
+enum fstSupplementalDataType
+{
+    FST_SDT_MIN = 0,
 
-    FST_SDT_NONE                   = 0,
+    FST_SDT_NONE = 0,
 
-    FST_SDT_VHDL_BOOLEAN           = 1,
-    FST_SDT_VHDL_BIT               = 2,
-    FST_SDT_VHDL_BIT_VECTOR        = 3,
-    FST_SDT_VHDL_STD_ULOGIC        = 4,
+    FST_SDT_VHDL_BOOLEAN = 1,
+    FST_SDT_VHDL_BIT = 2,
+    FST_SDT_VHDL_BIT_VECTOR = 3,
+    FST_SDT_VHDL_STD_ULOGIC = 4,
     FST_SDT_VHDL_STD_ULOGIC_VECTOR = 5,
-    FST_SDT_VHDL_STD_LOGIC         = 6,
-    FST_SDT_VHDL_STD_LOGIC_VECTOR  = 7,
-    FST_SDT_VHDL_UNSIGNED          = 8,
-    FST_SDT_VHDL_SIGNED            = 9,
-    FST_SDT_VHDL_INTEGER           = 10,
-    FST_SDT_VHDL_REAL              = 11,
-    FST_SDT_VHDL_NATURAL           = 12,
-    FST_SDT_VHDL_POSITIVE          = 13,
-    FST_SDT_VHDL_TIME              = 14,
-    FST_SDT_VHDL_CHARACTER         = 15,
-    FST_SDT_VHDL_STRING            = 16,
+    FST_SDT_VHDL_STD_LOGIC = 6,
+    FST_SDT_VHDL_STD_LOGIC_VECTOR = 7,
+    FST_SDT_VHDL_UNSIGNED = 8,
+    FST_SDT_VHDL_SIGNED = 9,
+    FST_SDT_VHDL_INTEGER = 10,
+    FST_SDT_VHDL_REAL = 11,
+    FST_SDT_VHDL_NATURAL = 12,
+    FST_SDT_VHDL_POSITIVE = 13,
+    FST_SDT_VHDL_TIME = 14,
+    FST_SDT_VHDL_CHARACTER = 15,
+    FST_SDT_VHDL_STRING = 16,
 
-    FST_SDT_MAX                    = 16,
+    FST_SDT_MAX = 16,
 
-    FST_SDT_SVT_SHIFT_COUNT        = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left after shifting FST_SDT_SVT_SHIFT_COUNT */
-    FST_SDT_ABS_MAX                = ((1<<(FST_SDT_SVT_SHIFT_COUNT))-1)
+    FST_SDT_SVT_SHIFT_COUNT = 10, /* FST_SVT_* is ORed in by fstWriterCreateVar2() to the left
+                                        after shifting FST_SDT_SVT_SHIFT_COUNT */
+    FST_SDT_ABS_MAX = ((1 << (FST_SDT_SVT_SHIFT_COUNT)) - 1)
 };
 
-
 struct fstHier
 {
-unsigned char htyp;
+    unsigned char htyp;
 
-union {
+    union
+    {
         /* if htyp == FST_HT_SCOPE */
-        struct fstHierScope {
-                unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */
-                const char *name;
-                const char *component;
-                uint32_t name_length;           /* strlen(u.scope.name) */
-                uint32_t component_length;      /* strlen(u.scope.component) */
-                } scope;
+        struct fstHierScope
+        {
+            unsigned char typ; /* FST_ST_MIN ... FST_ST_MAX */
+            const char *name;
+            const char *component;
+            uint32_t name_length; /* strlen(u.scope.name) */
+            uint32_t component_length; /* strlen(u.scope.component) */
+        } scope;
 
         /* if htyp == FST_HT_VAR */
-        struct fstHierVar {
-                unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */
-                unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */
-                unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */
-                unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */
-                unsigned int  sxt_workspace; /* zeroed out by FST reader, for client code use */
-                const char *name;
-                uint32_t length;
-                fstHandle handle;
-                uint32_t name_length; /* strlen(u.var.name) */
-                unsigned is_alias : 1;
-                } var;
+        struct fstHierVar
+        {
+            unsigned char typ; /* FST_VT_MIN ... FST_VT_MAX */
+            unsigned char direction; /* FST_VD_MIN ... FST_VD_MAX */
+            unsigned char svt_workspace; /* zeroed out by FST reader, for client code use */
+            unsigned char sdt_workspace; /* zeroed out by FST reader, for client code use */
+            unsigned int sxt_workspace; /* zeroed out by FST reader, for client code use */
+            const char *name;
+            uint32_t length;
+            fstHandle handle;
+            uint32_t name_length; /* strlen(u.var.name) */
+            unsigned is_alias : 1;
+        } var;
 
         /* if htyp == FST_HT_ATTRBEGIN */
-        struct fstHierAttr {
-                unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */
-                unsigned char subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */
-                const char *name;
-                uint64_t arg; /* number of array elements, struct members, or some other payload (possibly ignored) */
-                uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer (FST_AT_MISC + FST_MT_SOURCESTEM) */
-                uint32_t name_length; /* strlen(u.attr.name) */
-                } attr;
-        } u;
+        struct fstHierAttr
+        {
+            unsigned char typ; /* FST_AT_MIN ... FST_AT_MAX */
+            unsigned char
+                subtype; /* from fstMiscType, fstArrayType, fstEnumValueType, fstPackType */
+            const char *name;
+            uint64_t arg; /* number of array elements, struct members, or some other payload
+                                (possibly ignored) */
+            uint64_t arg_from_name; /* for when name is overloaded as a variable-length integer
+                                        (FST_AT_MISC + FST_MT_SOURCESTEM) */
+            uint32_t name_length; /* strlen(u.attr.name) */
+        } attr;
+    } u;
 };
 
-
 struct fstETab
 {
-char *name;
-uint32_t elem_count;
-char **literal_arr;
-char **val_arr;
+    char *name;
+    uint32_t elem_count;
+    char **literal_arr;
+    char **val_arr;
 };
 
-
 /*
  * writer functions
  */
-void            fstWriterClose(void *ctx);
-void *          fstWriterCreate(const char *nam, int use_compressed_hier);
-fstEnumHandle   fstWriterCreateEnumTable(void *ctx, const char *name, uint32_t elem_count, unsigned int min_valbits, const char **literal_arr, const char **val_arr);
-                /* used for Verilog/SV */
-fstHandle       fstWriterCreateVar(void *ctx, enum fstVarType vt, enum fstVarDir vd,
-                        uint32_t len, const char *nam, fstHandle aliasHandle);
-                /* future expansion for VHDL and other languages.  The variable type, data type, etc map onto
-                   the current Verilog/SV one.  The "type" string is optional for a more verbose or custom description */
-fstHandle       fstWriterCreateVar2(void *ctx, enum fstVarType vt, enum fstVarDir vd,
-                        uint32_t len, const char *nam, fstHandle aliasHandle,
-                        const char *type, enum fstSupplementalVarType svt, enum fstSupplementalDataType sdt);
-void            fstWriterEmitDumpActive(void *ctx, int enable);
-void 		fstWriterEmitEnumTableRef(void *ctx, fstEnumHandle handle);
-void            fstWriterEmitValueChange(void *ctx, fstHandle handle, const void *val);
-void            fstWriterEmitValueChange32(void *ctx, fstHandle handle,
-                        uint32_t bits, uint32_t val);
-void            fstWriterEmitValueChange64(void *ctx, fstHandle handle,
-                        uint32_t bits, uint64_t val);
-void            fstWriterEmitValueChangeVec32(void *ctx, fstHandle handle,
-                        uint32_t bits, const uint32_t *val);
-void            fstWriterEmitValueChangeVec64(void *ctx, fstHandle handle,
-                        uint32_t bits, const uint64_t *val);
-void            fstWriterEmitVariableLengthValueChange(void *ctx, fstHandle handle, const void *val, uint32_t len);
-void            fstWriterEmitTimeChange(void *ctx, uint64_t tim);
-void            fstWriterFlushContext(void *ctx);
-int             fstWriterGetDumpSizeLimitReached(void *ctx);
-int             fstWriterGetFseekFailed(void *ctx);
-void            fstWriterSetAttrBegin(void *ctx, enum fstAttrType attrtype, int subtype,
-                        const char *attrname, uint64_t arg);
-void            fstWriterSetAttrEnd(void *ctx);
-void            fstWriterSetComment(void *ctx, const char *comm);
-void            fstWriterSetDate(void *ctx, const char *dat);
-void            fstWriterSetDumpSizeLimit(void *ctx, uint64_t numbytes);
-void            fstWriterSetEnvVar(void *ctx, const char *envvar);
-void            fstWriterSetFileType(void *ctx, enum fstFileType filetype);
-void            fstWriterSetPackType(void *ctx, enum fstWriterPackType typ);
-void            fstWriterSetParallelMode(void *ctx, int enable);
-void            fstWriterSetRepackOnClose(void *ctx, int enable);       /* type = 0 (none), 1 (libz) */
-void            fstWriterSetScope(void *ctx, enum fstScopeType scopetype,
-                        const char *scopename, const char *scopecomp);
-void            fstWriterSetSourceInstantiationStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
-void            fstWriterSetSourceStem(void *ctx, const char *path, unsigned int line, unsigned int use_realpath);
-void            fstWriterSetTimescale(void *ctx, int ts);
-void            fstWriterSetTimescaleFromString(void *ctx, const char *s);
-void            fstWriterSetTimezero(void *ctx, int64_t tim);
-void            fstWriterSetUpscope(void *ctx);
-void		fstWriterSetValueList(void *ctx, const char *vl);
-void            fstWriterSetVersion(void *ctx, const char *vers);
 
+typedef struct fstWriterContext fstWriterContext;
+
+void fstWriterClose(fstWriterContext *ctx);
+fstWriterContext *fstWriterCreate(const char *nam, int use_compressed_hier);
+fstEnumHandle fstWriterCreateEnumTable(fstWriterContext *ctx,
+                                        const char *name,
+                                        uint32_t elem_count,
+                                        unsigned int min_valbits,
+                                        const char **literal_arr,
+                                        const char **val_arr);
+/* used for Verilog/SV */
+fstHandle fstWriterCreateVar(fstWriterContext *ctx,
+                                enum fstVarType vt,
+                                enum fstVarDir vd,
+                                uint32_t len,
+                                const char *nam,
+                                fstHandle aliasHandle);
+/* future expansion for VHDL and other languages.  The variable type, data type, etc map onto
+    the current Verilog/SV one.  The "type" string is optional for a more verbose or custom
+    description */
+fstHandle fstWriterCreateVar2(fstWriterContext *ctx,
+                                enum fstVarType vt,
+                                enum fstVarDir vd,
+                                uint32_t len,
+                                const char *nam,
+                                fstHandle aliasHandle,
+                                const char *type,
+                                enum fstSupplementalVarType svt,
+                                enum fstSupplementalDataType sdt);
+void fstWriterEmitDumpActive(fstWriterContext *ctx, int enable);
+void fstWriterEmitEnumTableRef(fstWriterContext *ctx, fstEnumHandle handle);
+void fstWriterEmitValueChange(fstWriterContext *ctx, fstHandle handle, const void *val);
+void fstWriterEmitValueChange32(fstWriterContext *ctx,
+                                fstHandle handle,
+                                uint32_t bits,
+                                uint32_t val);
+void fstWriterEmitValueChange64(fstWriterContext *ctx,
+                                fstHandle handle,
+                                uint32_t bits,
+                                uint64_t val);
+void fstWriterEmitValueChangeVec32(fstWriterContext *ctx,
+                                    fstHandle handle,
+                                    uint32_t bits,
+                                    const uint32_t *val);
+void fstWriterEmitValueChangeVec64(fstWriterContext *ctx,
+                                    fstHandle handle,
+                                    uint32_t bits,
+                                    const uint64_t *val);
+void fstWriterEmitVariableLengthValueChange(fstWriterContext *ctx,
+                                            fstHandle handle,
+                                            const void *val,
+                                            uint32_t len);
+void fstWriterEmitTimeChange(fstWriterContext *ctx, uint64_t tim);
+void fstWriterFlushContext(fstWriterContext *ctx);
+int fstWriterGetDumpSizeLimitReached(fstWriterContext *ctx);
+int fstWriterGetFseekFailed(fstWriterContext *ctx);
+int fstWriterGetFlushContextPending(fstWriterContext *ctx);
+void fstWriterSetAttrBegin(fstWriterContext *ctx,
+                            enum fstAttrType attrtype,
+                            int subtype,
+                            const char *attrname,
+                            uint64_t arg);
+void fstWriterSetAttrEnd(fstWriterContext *ctx);
+void fstWriterSetComment(fstWriterContext *ctx, const char *comm);
+void fstWriterSetDate(fstWriterContext *ctx, const char *dat);
+void fstWriterSetDumpSizeLimit(fstWriterContext *ctx, uint64_t numbytes);
+void fstWriterSetEnvVar(fstWriterContext *ctx, const char *envvar);
+void fstWriterSetFileType(fstWriterContext *ctx, enum fstFileType filetype);
+void fstWriterSetPackType(fstWriterContext *ctx, enum fstWriterPackType typ);
+void fstWriterSetParallelMode(fstWriterContext *ctx, int enable);
+void fstWriterSetRepackOnClose(fstWriterContext *ctx,
+                                int enable); /* type = 0 (none), 1 (libz) */
+void fstWriterSetScope(fstWriterContext *ctx,
+                        enum fstScopeType scopetype,
+                        const char *scopename,
+                        const char *scopecomp);
+void fstWriterSetSourceInstantiationStem(fstWriterContext *ctx,
+                                            const char *path,
+                                            unsigned int line,
+                                            unsigned int use_realpath);
+void fstWriterSetSourceStem(fstWriterContext *ctx,
+                            const char *path,
+                            unsigned int line,
+                            unsigned int use_realpath);
+void fstWriterSetTimescale(fstWriterContext *ctx, int ts);
+void fstWriterSetTimescaleFromString(fstWriterContext *ctx, const char *s);
+void fstWriterSetTimezero(fstWriterContext *ctx, int64_t tim);
+void fstWriterSetUpscope(fstWriterContext *ctx);
+void fstWriterSetValueList(fstWriterContext *ctx, const char *vl);
+void fstWriterSetVersion(fstWriterContext *ctx, const char *vers);
 
 /*
  * reader functions
  */
-void            fstReaderClose(void *ctx);
-void            fstReaderClrFacProcessMask(void *ctx, fstHandle facidx);
-void            fstReaderClrFacProcessMaskAll(void *ctx);
-uint64_t        fstReaderGetAliasCount(void *ctx);
-const char *    fstReaderGetCurrentFlatScope(void *ctx);
-void *          fstReaderGetCurrentScopeUserInfo(void *ctx);
-int             fstReaderGetCurrentScopeLen(void *ctx);
-const char *    fstReaderGetDateString(void *ctx);
-int             fstReaderGetDoubleEndianMatchState(void *ctx);
-uint64_t        fstReaderGetDumpActivityChangeTime(void *ctx, uint32_t idx);
-unsigned char   fstReaderGetDumpActivityChangeValue(void *ctx, uint32_t idx);
-uint64_t        fstReaderGetEndTime(void *ctx);
-int             fstReaderGetFacProcessMask(void *ctx, fstHandle facidx);
-int             fstReaderGetFileType(void *ctx);
-int             fstReaderGetFseekFailed(void *ctx);
-fstHandle       fstReaderGetMaxHandle(void *ctx);
-uint64_t        fstReaderGetMemoryUsedByWriter(void *ctx);
-uint32_t        fstReaderGetNumberDumpActivityChanges(void *ctx);
-uint64_t        fstReaderGetScopeCount(void *ctx);
-uint64_t        fstReaderGetStartTime(void *ctx);
-signed char     fstReaderGetTimescale(void *ctx);
-int64_t         fstReaderGetTimezero(void *ctx);
-uint64_t        fstReaderGetValueChangeSectionCount(void *ctx);
-char *          fstReaderGetValueFromHandleAtTime(void *ctx, uint64_t tim, fstHandle facidx, char *buf);
-uint64_t        fstReaderGetVarCount(void *ctx);
-const char *    fstReaderGetVersionString(void *ctx);
-struct fstHier *fstReaderIterateHier(void *ctx);
-int             fstReaderIterateHierRewind(void *ctx);
-int             fstReaderIterBlocks(void *ctx,
-                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
-                        void *user_callback_data_pointer, FILE *vcdhandle);
-int             fstReaderIterBlocks2(void *ctx,
-                        void (*value_change_callback)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value),
-                        void (*value_change_callback_varlen)(void *user_callback_data_pointer, uint64_t time, fstHandle facidx, const unsigned char *value, uint32_t len),
-                        void *user_callback_data_pointer, FILE *vcdhandle);
-void            fstReaderIterBlocksSetNativeDoublesOnCallback(void *ctx, int enable);
-void *          fstReaderOpen(const char *nam);
-void *          fstReaderOpenForUtilitiesOnly(void);
-const char *    fstReaderPopScope(void *ctx);
-int             fstReaderProcessHier(void *ctx, FILE *vcdhandle);
-const char *    fstReaderPushScope(void *ctx, const char *nam, void *user_info);
-void            fstReaderResetScope(void *ctx);
-void            fstReaderSetFacProcessMask(void *ctx, fstHandle facidx);
-void            fstReaderSetFacProcessMaskAll(void *ctx);
-void            fstReaderSetLimitTimeRange(void *ctx, uint64_t start_time, uint64_t end_time);
-void            fstReaderSetUnlimitedTimeRange(void *ctx);
-void            fstReaderSetVcdExtensions(void *ctx, int enable);
 
+typedef struct fstReaderContext fstReaderContext;
+
+void fstReaderClose(fstReaderContext *ctx);
+void fstReaderClrFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
+void fstReaderClrFacProcessMaskAll(fstReaderContext *ctx);
+uint64_t fstReaderGetAliasCount(fstReaderContext *ctx);
+const char *fstReaderGetCurrentFlatScope(fstReaderContext *ctx);
+void *fstReaderGetCurrentScopeUserInfo(fstReaderContext *ctx);
+int fstReaderGetCurrentScopeLen(fstReaderContext *ctx);
+const char *fstReaderGetDateString(fstReaderContext *ctx);
+int fstReaderGetDoubleEndianMatchState(fstReaderContext *ctx);
+uint64_t fstReaderGetDumpActivityChangeTime(fstReaderContext *ctx, uint32_t idx);
+unsigned char fstReaderGetDumpActivityChangeValue(fstReaderContext *ctx, uint32_t idx);
+uint64_t fstReaderGetEndTime(fstReaderContext *ctx);
+int fstReaderGetFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
+int fstReaderGetFileType(fstReaderContext *ctx);
+int fstReaderGetFseekFailed(fstReaderContext *ctx);
+fstHandle fstReaderGetMaxHandle(fstReaderContext *ctx);
+uint64_t fstReaderGetMemoryUsedByWriter(fstReaderContext *ctx);
+uint32_t fstReaderGetNumberDumpActivityChanges(fstReaderContext *ctx);
+uint64_t fstReaderGetScopeCount(fstReaderContext *ctx);
+uint64_t fstReaderGetStartTime(fstReaderContext *ctx);
+signed char fstReaderGetTimescale(fstReaderContext *ctx);
+int64_t fstReaderGetTimezero(fstReaderContext *ctx);
+uint64_t fstReaderGetValueChangeSectionCount(fstReaderContext *ctx);
+char *fstReaderGetValueFromHandleAtTime(fstReaderContext *ctx,
+                                        uint64_t tim,
+                                        fstHandle facidx,
+                                        char *buf);
+uint64_t fstReaderGetVarCount(fstReaderContext *ctx);
+const char *fstReaderGetVersionString(fstReaderContext *ctx);
+struct fstHier *fstReaderIterateHier(fstReaderContext *ctx);
+int fstReaderIterateHierRewind(fstReaderContext *ctx);
+int fstReaderIterBlocks(fstReaderContext *ctx,
+                        void (*value_change_callback)(void *user_callback_data_pointer,
+                                                      uint64_t time,
+                                                      fstHandle facidx,
+                                                      const unsigned char *value),
+                        void *user_callback_data_pointer,
+                        FILE *vcdhandle);
+int fstReaderIterBlocks2(fstReaderContext *ctx,
+                         void (*value_change_callback)(void *user_callback_data_pointer,
+                                                       uint64_t time,
+                                                       fstHandle facidx,
+                                                       const unsigned char *value),
+                         void (*value_change_callback_varlen)(void *user_callback_data_pointer,
+                                                              uint64_t time,
+                                                              fstHandle facidx,
+                                                              const unsigned char *value,
+                                                              uint32_t len),
+                         void *user_callback_data_pointer,
+                         FILE *vcdhandle);
+void fstReaderIterBlocksSetNativeDoublesOnCallback(fstReaderContext *ctx, int enable);
+fstReaderContext *fstReaderOpen(const char *nam);
+fstReaderContext *fstReaderOpenForUtilitiesOnly(void);
+const char *fstReaderPopScope(fstReaderContext *ctx);
+int fstReaderProcessHier(fstReaderContext *ctx, FILE *vcdhandle);
+const char *fstReaderPushScope(fstReaderContext *ctx, const char *nam, void *user_info);
+void fstReaderResetScope(fstReaderContext *ctx);
+void fstReaderSetFacProcessMask(fstReaderContext *ctx, fstHandle facidx);
+void fstReaderSetFacProcessMaskAll(fstReaderContext *ctx);
+void fstReaderSetLimitTimeRange(fstReaderContext *ctx, uint64_t start_time, uint64_t end_time);
+void fstReaderSetUnlimitedTimeRange(fstReaderContext *ctx);
+void fstReaderSetVcdExtensions(fstReaderContext *ctx, int enable);
 
 /*
  * utility functions
  */
-int             fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */
-int             fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len);
-int             fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len);
+int fstUtilityBinToEscConvertedLen(const unsigned char *s, int len); /* used for mallocs for fstUtilityBinToEsc() */
+int fstUtilityBinToEsc(unsigned char *d, const unsigned char *s, int len);
+int fstUtilityEscToBin(unsigned char *d, unsigned char *s, int len);
 struct fstETab *fstUtilityExtractEnumTableFromString(const char *s);
-void 		fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */
-
+void fstUtilityFreeEnumTable(struct fstETab *etab); /* must use to free fstETab properly */
 
 #ifdef __cplusplus
 }

include/gtkwave/wavealloca.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 1999 Tony Bybell.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * SPDX-License-Identifier: MIT
- */
-
-#ifndef WAVE_ALLOCA_H
-#define WAVE_ALLOCA_H
-#include <stdlib.h>
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#elif defined(__GNUC__)
-#ifndef __MINGW32__
-#ifndef alloca
-#define alloca __builtin_alloca
-#endif
-#else
-#include <malloc.h>
-#endif
-#endif
-#define wave_alloca alloca
-#endif
-

include/verilated.cpp

@@ -56,6 +56,7 @@
 #include <cctype>
 #include <cerrno>
 #include <cstdlib>
+#include <iostream>
 #include <limits>
 #include <list>
 #include <sstream>
@@ -71,7 +72,7 @@
 # include <execinfo.h>
 # define _VL_HAVE_STACKTRACE
 #endif
-#if defined(__linux) || (defined(__APPLE__) && defined(__MACH__))
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 # include <sys/time.h>
 # include <sys/resource.h>
 # define _VL_HAVE_GETRLIMIT
@@ -167,7 +168,12 @@ void vl_fatal(const char* filename, int linenum, const char* hier, const char* m
 
     // Callbacks prior to termination
     Verilated::runExitCallbacks();
-    std::abort();
+
+    if (Verilated::debug()) {
+        std::abort();
+    } else {
+        std::exit(1);
+    }
 }
 #endif
 
@@ -405,6 +411,58 @@ IData VL_URANDOM_SEEDED_II(IData seed) VL_MT_SAFE {
     Verilated::threadContextp()->randSeed(static_cast<int>(seed));
     return VL_RANDOM_I();
 }
+
+IData VL_SCOPED_RAND_RESET_I(int obits, uint64_t scopeHash, uint64_t salt) VL_MT_UNSAFE {
+    if (Verilated::threadContextp()->randReset() == 0) return 0;
+    IData data = ~0;
+    if (Verilated::threadContextp()->randReset() != 1) {  // if 2, randomize
+        VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+        data = rng.rand64();
+    }
+    data &= VL_MASK_I(obits);
+    return data;
+}
+
+QData VL_SCOPED_RAND_RESET_Q(int obits, uint64_t scopeHash, uint64_t salt) VL_MT_UNSAFE {
+    if (Verilated::threadContextp()->randReset() == 0) return 0;
+    QData data = ~0ULL;
+    if (Verilated::threadContextp()->randReset() != 1) {  // if 2, randomize
+        VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+        data = rng.rand64();
+    }
+    data &= VL_MASK_Q(obits);
+    return data;
+}
+
+WDataOutP VL_SCOPED_RAND_RESET_W(int obits, WDataOutP outwp, uint64_t scopeHash,
+                                 uint64_t salt) VL_MT_UNSAFE {
+    if (Verilated::threadContextp()->randReset() != 2) { return VL_RAND_RESET_W(obits, outwp); }
+    VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+    for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = rng.rand64();
+    outwp[VL_WORDS_I(obits) - 1] = rng.rand64() & VL_MASK_E(obits);
+    return outwp;
+}
+
+IData VL_SCOPED_RAND_RESET_ASSIGN_I(int obits, uint64_t scopeHash, uint64_t salt) VL_MT_UNSAFE {
+    VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+    const IData data = rng.rand64() & VL_MASK_I(obits);
+    return data;
+}
+
+QData VL_SCOPED_RAND_RESET_ASSIGN_Q(int obits, uint64_t scopeHash, uint64_t salt) VL_MT_UNSAFE {
+    VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+    const QData data = rng.rand64() & VL_MASK_Q(obits);
+    return data;
+}
+
+WDataOutP VL_SCOPED_RAND_RESET_ASSIGN_W(int obits, WDataOutP outwp, uint64_t scopeHash,
+                                        uint64_t salt) VL_MT_UNSAFE {
+    VlRNG rng{Verilated::threadContextp()->randSeed() ^ scopeHash ^ salt};
+    for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = rng.rand64();
+    outwp[VL_WORDS_I(obits) - 1] = rng.rand64() & VL_MASK_E(obits);
+    return outwp;
+}
+
 IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
     if (Verilated::threadContextp()->randReset() == 0) return 0;
     IData data = ~0;
@@ -414,7 +472,6 @@ IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
     data &= VL_MASK_I(obits);
     return data;
 }
-IData VL_RAND_RESET_ASSIGN_I(int obits) VL_MT_SAFE { return VL_RANDOM_I() & VL_MASK_I(obits); }
 
 QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
     if (Verilated::threadContextp()->randReset() == 0) return 0;
@@ -426,18 +483,11 @@ QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
     return data;
 }
 
-QData VL_RAND_RESET_ASSIGN_Q(int obits) VL_MT_SAFE { return VL_RANDOM_Q() & VL_MASK_Q(obits); }
-
 WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE {
     for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = VL_RAND_RESET_I(32);
     outwp[VL_WORDS_I(obits) - 1] = VL_RAND_RESET_I(32) & VL_MASK_E(obits);
     return outwp;
 }
-WDataOutP VL_RAND_RESET_ASSIGN_W(int obits, WDataOutP outwp) VL_MT_SAFE {
-    for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = VL_RAND_RESET_ASSIGN_I(32);
-    outwp[VL_WORDS_I(obits) - 1] = VL_RAND_RESET_ASSIGN_I(32) & VL_MASK_E(obits);
-    return outwp;
-}
 WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE {
     // Not inlined to speed up compilation of slowpath code
     return VL_ZERO_W(obits, outwp);
@@ -576,14 +626,12 @@ WDataOutP VL_POW_WWW(int obits, int, int rbits, WDataOutP owp, const WDataInP lw
     const int owords = VL_WORDS_I(obits);
     VL_DEBUG_IFDEF(assert(owords <= VL_MULS_MAX_WORDS););
     owp[0] = 1;
-    for (int i = 1; i < VL_WORDS_I(obits); i++) owp[i] = 0;
-    // cppcheck-has-bug-suppress variableScope
+    for (int i = 1; i < VL_WORDS_I(obits); ++i) owp[i] = 0;
     VlWide<VL_MULS_MAX_WORDS> powstore;  // Fixed size, as MSVC++ doesn't allow [words] here
     VlWide<VL_MULS_MAX_WORDS> lastpowstore;  // Fixed size, as MSVC++ doesn't allow [words] here
     VlWide<VL_MULS_MAX_WORDS> lastoutstore;  // Fixed size, as MSVC++ doesn't allow [words] here
-    // cppcheck-has-bug-suppress variableScope
     VL_ASSIGN_W(obits, powstore, lwp);
-    for (int bit = 0; bit < rbits; bit++) {
+    for (int bit = 0; bit < rbits; ++bit) {
         if (bit > 0) {  // power = power*power
             VL_ASSIGN_W(obits, lastpowstore, powstore);
             VL_MUL_W(owords, powstore, lastpowstore, lastpowstore);
@@ -916,6 +964,21 @@ void _vl_vsformat(std::string& output, const std::string& format, va_list ap) VL
                 }
                 break;
             }
+            case 'p': {  // 'x' but parameter is string
+                const int lbits = va_arg(ap, int);
+                (void)lbits;
+                const std::string* const cstr = va_arg(ap, const std::string*);
+                std::ostringstream oss;
+                for (unsigned char c : *cstr) oss << std::hex << static_cast<int>(c);
+                std::string hex_str = oss.str();
+                if (width > 0 && widthSet) {
+                    hex_str = hex_str.size() > width
+                                  ? hex_str.substr(0, width)
+                                  : std::string(width - hex_str.size(), '0') + hex_str;
+                    output += hex_str;
+                }
+                break;
+            }
             default: {
                 // Deal with all read-and-print somethings
                 const int lbits = va_arg(ap, int);
@@ -1234,9 +1297,9 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
     bool inPct = false;
     bool inIgnore = false;
     std::string::const_iterator pos = format.cbegin();
-    for (; pos != format.cend() && !_vl_vsss_eof(fp, floc); ++pos) {
-        // VL_DBG_MSGF("_vlscan fmt='"<<pos[0]<<"' floc="<<floc<<" file='"<<_vl_vsss_peek(fp, floc,
-        // fromp, fstr)<<"'\n");
+    for (; pos != format.cend(); ++pos) {
+        // VL_DBG_MSGF("_vlscan fmt='%c' floc=%d file='%c'\n", pos[0], floc,
+        // _vl_vsss_peek(fp, floc, fromp, fstr));
         if (!inPct && pos[0] == '%') {
             inPct = true;
             inIgnore = false;
@@ -1319,7 +1382,6 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
                     _vl_vsss_skipspace(fp, floc, fromp, fstr);
                     _vl_vsss_read_str(fp, floc, fromp, fstr, t_tmp, "+-.0123456789eE");
                     if (!t_tmp[0]) goto done;
-                    // cppcheck-has-bug-suppress unusedStructMember, unreadVariable
                     union {
                         double r;
                         int64_t ld;
@@ -1420,7 +1482,12 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
             }  // switch
         }
     }
+    // Processed all arguments
+    return got;
+
 done:
+    // Scan stopped early, return parsed or EOF
+    if (_vl_vsss_eof(fp, floc)) return -1;
     return got;
 }
 
@@ -1679,6 +1746,48 @@ IData VL_SSCANF_INNX(int, const std::string& ld, const std::string& format, int
     return got;
 }
 
+// MurmurHash64A
+uint64_t VL_MURMUR64_HASH(const char* key) VL_PURE {
+    const size_t len = strlen(key);
+    const uint64_t seed = 0;
+    const uint64_t m = 0xc6a4a7935bd1e995ULL;
+    const int r = 47;
+
+    uint64_t h = seed ^ (len * m);
+
+    const uint64_t* data = reinterpret_cast<const uint64_t*>(key);
+    const uint64_t* end = data + (len / 8);
+
+    while (data != end) {
+        uint64_t k = *data++;
+
+        k *= m;
+        k ^= k >> r;
+        k *= m;
+
+        h ^= k;
+        h *= m;
+    }
+
+    const unsigned char* data2 = reinterpret_cast<const unsigned char*>(data);
+
+    switch (len & 7) {
+    case 7: h ^= uint64_t(data2[6]) << 48; /* fallthrough */
+    case 6: h ^= uint64_t(data2[5]) << 40; /* fallthrough */
+    case 5: h ^= uint64_t(data2[4]) << 32; /* fallthrough */
+    case 4: h ^= uint64_t(data2[3]) << 24; /* fallthrough */
+    case 3: h ^= uint64_t(data2[2]) << 16; /* fallthrough */
+    case 2: h ^= uint64_t(data2[1]) << 8; /* fallthrough */
+    case 1: h ^= uint64_t(data2[0]); h *= m; /* fallthrough */
+    };
+
+    h ^= h >> r;
+    h *= m;
+    h ^= h >> r;
+
+    return h;
+}
+
 IData VL_FREAD_I(int width, int array_lsb, int array_size, void* memp, IData fpi, IData start,
                  IData count) VL_MT_SAFE {
     // While threadsafe, each thread can only access different file handles
@@ -1749,7 +1858,7 @@ std::string VL_STACKTRACE_N() VL_MT_SAFE {
     if (!strings) return "Unable to backtrace\n";
 
     std::string result = "Backtrace:\n";
-    for (int j = 0; j < nptrs; j++) result += std::string{strings[j]} + "\n"s;
+    for (int j = 0; j < nptrs; ++j) result += std::string{strings[j]} + "\n"s;
     free(strings);
     return result;
 }
@@ -2021,7 +2130,7 @@ static const char* formatBinary(int nBits, uint32_t bits) {
     assert((nBits >= 1) && (nBits <= 32));
 
     static thread_local char t_buf[64];
-    for (int i = 0; i < nBits; i++) {
+    for (int i = 0; i < nBits; ++i) {
         const bool isOne = bits & (1 << (nBits - 1 - i));
         t_buf[i] = (isOne ? '1' : '0');
     }
@@ -2039,7 +2148,6 @@ VlReadMem::VlReadMem(bool hex, int bits, const std::string& filename, QData star
     if (VL_UNLIKELY(!m_fp)) {
         // We don't report the Verilog source filename as it slow to have to pass it down
         VL_WARN_MT(filename.c_str(), 0, "", "$readmem file not found");
-        // cppcheck-has-bug-suppress resourceLeak  // m_fp is nullptr
         return;
     }
 }
@@ -2179,7 +2287,6 @@ VlWriteMem::VlWriteMem(bool hex, int bits, const std::string& filename, QData st
     m_fp = std::fopen(filename.c_str(), "w");
     if (VL_UNLIKELY(!m_fp)) {
         VL_FATAL_MT(filename.c_str(), 0, "", "$writemem file not found");
-        // cppcheck-has-bug-suppress resourceLeak  // m_fp is nullptr
         return;
     }
 }
@@ -2363,7 +2470,6 @@ static const char* vl_time_str(int scale) VL_PURE {
 double vl_time_multiplier(int scale) VL_PURE {
     // Return timescale multiplier -18 to +18
     // For speed, this does not check for illegal values
-    // cppcheck-has-bug-suppress arrayIndexOutOfBoundsCond
     if (scale < 0) {
         static const double neg10[] = {1.0,
                                        0.1,
@@ -2384,7 +2490,6 @@ double vl_time_multiplier(int scale) VL_PURE {
                                        0.0000000000000001,
                                        0.00000000000000001,
                                        0.000000000000000001};
-        // cppcheck-has-bug-suppress arrayIndexOutOfBoundsCond
         return neg10[-scale];
     } else {
         static const double pow10[] = {1.0,
@@ -2406,7 +2511,6 @@ double vl_time_multiplier(int scale) VL_PURE {
                                        10000000000000000.0,
                                        100000000000000000.0,
                                        1000000000000000000.0};
-        // cppcheck-has-bug-suppress arrayIndexOutOfBoundsCond
         return pow10[scale];
     }
 }
@@ -2456,12 +2560,13 @@ void VL_PRINTTIMESCALE(const char* namep, const char* timeunitp,
     VL_PRINTF_MT("Time scale of %s is %s / %s\n", namep, timeunitp,
                  contextp->timeprecisionString());
 }
-void VL_TIMEFORMAT_IINI(int units, int precision, const std::string& suffix, int width,
+void VL_TIMEFORMAT_IINI(bool hasUnits, int units, bool hasPrecision, int precision, bool hasSuffix,
+                        const std::string& suffix, bool hasWidth, int width,
                         VerilatedContext* contextp) VL_MT_SAFE {
-    contextp->impp()->timeFormatUnits(units);
-    contextp->impp()->timeFormatPrecision(precision);
-    contextp->impp()->timeFormatSuffix(suffix);
-    contextp->impp()->timeFormatWidth(width);
+    if (hasUnits) contextp->impp()->timeFormatUnits(units);
+    if (hasPrecision) contextp->impp()->timeFormatPrecision(precision);
+    if (hasSuffix) contextp->impp()->timeFormatSuffix(suffix);
+    if (hasWidth) contextp->impp()->timeFormatWidth(width);
 }
 
 //======================================================================
@@ -2701,7 +2806,7 @@ void VerilatedContext::internalsDump() const VL_MT_SAFE {
     VerilatedImp::userDump();
 }
 
-void VerilatedContext::addModel(VerilatedModel* modelp) {
+void VerilatedContext::addModel(const VerilatedModel* modelp) {
     if (!quiet()) {
         // CPU time isn't read as starting point until model creation, so that quiet() is set
         // Thus if quiet(), avoids slow OS read affecting some usages that make many models
@@ -2739,7 +2844,7 @@ VerilatedVirtualBase* VerilatedContext::threadPoolp() {
 void VerilatedContext::prepareClone() { delete m_threadPool.release(); }
 
 VerilatedVirtualBase* VerilatedContext::threadPoolpOnClone() {
-    if (VL_UNLIKELY(m_threadPool)) m_threadPool.release();
+    if (VL_UNLIKELY(m_threadPool)) (void)m_threadPool.release();
     m_threadPool = std::unique_ptr<VlThreadPool>(new VlThreadPool{this, m_threads - 1});
     return m_threadPool.get();
 }
@@ -2953,7 +3058,9 @@ void VerilatedContext::statsPrintSummary() VL_MT_UNSAFE {
         = vl_timescaled_double((cputime != 0.0) ? (simtimeInUnits / cputime) : 0, "%0.3f %s");
     VL_PRINTF("- Verilator: %s at %s; walltime %0.3f s; speed %s/s\n", endwhy.c_str(),
               simtime.c_str(), walltime, simtimePerf.c_str());
-    const double modelMB = VlOs::memUsageBytes() / 1024.0 / 1024.0;
+    uint64_t memPeak, memCurrent;
+    VlOs::memUsageBytes(memPeak /*ref*/, memCurrent /*ref*/);
+    const double modelMB = memPeak / 1024.0 / 1024.0;
     VL_PRINTF("- Verilator: cpu %0.3f s on %u threads; alloced %0.0f MB\n", cputime,
               threadsInModels(), modelMB);
 }
@@ -3017,8 +3124,8 @@ void VerilatedContext::trace(VerilatedTraceBaseC* tfp, int levels, int options)
     if (m_ns.m_traceBaseModelCbs.empty())
         VL_FATAL_MT("", 0, "",
                     "Testbench C call to 'VerilatedContext::trace()' requires model(s) Verilated"
-                    " with --trace or --trace-vcd option");
-    for (auto& cbr : m_ns.m_traceBaseModelCbs) cbr(tfp, levels, options);
+                    " with --trace-fst or --trace-vcd option");
+    for (const auto& cbr : m_ns.m_traceBaseModelCbs) cbr(tfp, levels, options);
 }
 void VerilatedContext::traceBaseModelCbAdd(traceBaseModelCb_t cb) VL_MT_SAFE {
     // Model creation registering a callback for when Verilated::trace() called
@@ -3033,7 +3140,6 @@ VerilatedSyms::VerilatedSyms(VerilatedContext* contextp)
     : _vm_contextp__(contextp ? contextp : Verilated::threadContextp()) {
     VerilatedContext::checkMagic(_vm_contextp__);
     Verilated::threadContextp(_vm_contextp__);
-    // cppcheck-has-bug-suppress noCopyConstructor
     __Vm_evalMsgQp = new VerilatedEvalMsgQueue;
 }
 
@@ -3273,7 +3379,7 @@ VerilatedModule::VerilatedModule(const char* namep)
 
 VerilatedModule::~VerilatedModule() {
     // Memory cleanup - not called during normal operation
-    // NOLINTNEXTLINE(google-readability-casting)
+    // cppcheck-suppress cstyleCast  // NOLINTNEXTLINE(google-readability-casting)
     if (m_namep) VL_DO_CLEAR(free((void*)(m_namep)), m_namep = nullptr);
 }
 
@@ -3435,16 +3541,16 @@ void VerilatedScope::scopeDump() const {
                          VerilatedImp::exportName(i));
         }
     }
-    if (const VerilatedVarNameMap* const varsp = this->varsp()) {
-        for (const auto& i : *varsp) VL_PRINTF_MT("       VAR %p: %s\n", &(i.second), i.first);
+    if (const VerilatedVarNameMap* const ivarsp = this->varsp()) {
+        for (const auto& i : *ivarsp) VL_PRINTF_MT("       VAR %p: %s\n", &(i.second), i.first);
     }
 }
 
-void VerilatedHierarchy::add(VerilatedScope* fromp, VerilatedScope* top) {
+void VerilatedHierarchy::add(const VerilatedScope* fromp, const VerilatedScope* top) {
     VerilatedImp::hierarchyAdd(fromp, top);
 }
 
-void VerilatedHierarchy::remove(VerilatedScope* fromp, VerilatedScope* top) {
+void VerilatedHierarchy::remove(const VerilatedScope* fromp, const VerilatedScope* top) {
     VerilatedImp::hierarchyRemove(fromp, top);
 }
 
@@ -3455,7 +3561,7 @@ void VerilatedHierarchy::remove(VerilatedScope* fromp, VerilatedScope* top) {
 void VerilatedAssertOneThread::fatal_different() VL_MT_SAFE {
     VL_FATAL_MT(__FILE__, __LINE__, "",
                 "Routine called that is single threaded, but called from"
-                " a different thread then the expected constructing thread");
+                " a different thread than the expected constructing thread");
 }
 #endif
 

include/verilated.h

@@ -39,8 +39,8 @@
 #endif
 
 // clang-format off
-#include "verilatedos.h"
 #include "verilated_config.h"
+#include "verilatedos.h"
 #if VM_SC
 # include "verilated_sc.h"  // Get SYSTEMC_VERSION and time declarations
 #endif
@@ -113,6 +113,7 @@ class VerilatedVcdSc;
 //=========================================================================
 // Basic types
 
+// Type letters
 // clang-format off
 //    P                     // Packed data of bit type (C/S/I/Q/W)
 using CData = uint8_t;    ///< Data representing 'bit' of 1-8 packed bits
@@ -124,6 +125,8 @@ using WData = EData;        ///< Data representing >64 packed bits (used as poin
 //    F     = float;        // No typedef needed; Verilator uses float
 //    D     = double;       // No typedef needed; Verilator uses double
 //    N     = std::string;  // No typedef needed; Verilator uses string
+//    U     = VlUnpacked;
+//    R     = VlQueue;
 // clang-format on
 
 using WDataInP = const WData*;  ///< 'bit' of >64 packed bits as array input to a function
@@ -175,9 +178,14 @@ enum class VerilatedAssertDirectiveType : uint8_t {
 using VerilatedAssertType_t = std::underlying_type<VerilatedAssertType>::type;
 using VerilatedAssertDirectiveType_t = std::underlying_type<VerilatedAssertDirectiveType>::type;
 
-// Type trait for custom struct
+// Type trait: whether T is a user-defined custom struct
 template <typename>
 struct VlIsCustomStruct : public std::false_type {};
+
+// Type trait: used to detect if array element is a custom struct (e.g. for struct arrays)
+template <typename T>
+struct VlContainsCustomStruct : VlIsCustomStruct<T> {};
+
 //=============================================================================
 // Utility functions
 
@@ -636,7 +644,7 @@ public:
     }
 
     // Internal: Model and thread setup
-    void addModel(VerilatedModel*);
+    void addModel(const VerilatedModel* modelp);
     VerilatedVirtualBase* threadPoolp();
     void prepareClone();
     VerilatedVirtualBase* threadPoolpOnClone();
@@ -755,8 +763,8 @@ public:  // But internals only - called from VerilatedModule's
 
 class VerilatedHierarchy final {
 public:
-    static void add(VerilatedScope* fromp, VerilatedScope* top);
-    static void remove(VerilatedScope* fromp, VerilatedScope* top);
+    static void add(const VerilatedScope* fromp, const VerilatedScope* top);
+    static void remove(const VerilatedScope* fromp, const VerilatedScope* top);
 };
 
 //===========================================================================

include/verilated.mk.in

@@ -69,7 +69,7 @@ export CCACHE_SLOPPINESS
 # Make checks
 
 ifneq ($(words $(CURDIR)),1)
- $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
+  $(error Unsupported: GNU Make cannot build in directories containing spaces, build elsewhere: '$(CURDIR)')
 endif
 
 ######################################################################
@@ -81,19 +81,21 @@ UNAME_S := $(shell uname -s)
 
 # Add -MMD -MP if you're using a recent version of GCC.
 VK_CPPFLAGS_ALWAYS += \
-		-MMD \
-		-I$(VERILATOR_ROOT)/include \
-		-I$(VERILATOR_ROOT)/include/vltstd \
-		-DVM_COVERAGE=$(VM_COVERAGE) \
-		-DVM_SC=$(VM_SC) \
-		-DVM_TIMING=$(VM_TIMING) \
-		-DVM_TRACE=$(VM_TRACE) \
-		-DVM_TRACE_FST=$(VM_TRACE_FST) \
-		-DVM_TRACE_VCD=$(VM_TRACE_VCD) \
-		$(CFG_CXXFLAGS_NO_UNUSED) \
+  -MMD \
+  -I$(VERILATOR_ROOT)/include \
+  -I$(VERILATOR_ROOT)/include/vltstd \
+  -DVERILATOR=1 \
+  -DVM_COVERAGE=$(VM_COVERAGE) \
+  -DVM_SC=$(VM_SC) \
+  -DVM_TIMING=$(VM_TIMING) \
+  -DVM_TRACE=$(VM_TRACE) \
+  -DVM_TRACE_FST=$(VM_TRACE_FST) \
+  -DVM_TRACE_VCD=$(VM_TRACE_VCD) \
+  -DVM_TRACE_SAIF=$(VM_TRACE_SAIF) \
+  $(CFG_CXXFLAGS_NO_UNUSED) \
 
 ifeq ($(CFG_WITH_CCWARN),yes)  # Local... Else don't burden users
-VK_CPPFLAGS_WALL += -Wall $(CFG_CXXFLAGS_WEXTRA) -Werror
+  VK_CPPFLAGS_WALL += -Wall $(CFG_CXXFLAGS_WEXTRA) -Werror
 endif
 
 CPPFLAGS += -I. $(VK_CPPFLAGS_WALL) $(VK_CPPFLAGS_ALWAYS)
@@ -102,7 +104,7 @@ VPATH += ..
 VPATH += $(VERILATOR_ROOT)/include
 VPATH += $(VERILATOR_ROOT)/include/vltstd
 
-LDFLAGS  += $(CFG_LDFLAGS_VERILATED)
+LDFLAGS += $(CFG_LDFLAGS_VERILATED)
 
 #OPT = -ggdb -DPRINTINITSTR -DDETECTCHANGE
 #OPT = -ggdb -DPRINTINITSTR
@@ -111,19 +113,19 @@ CPPFLAGS += $(OPT)
 # On macOS, specify all weak symbols as dynamic_lookup.
 # Otherwise, you get undefined symbol errors.
 ifeq ($(UNAME_S),Darwin)
-	LDFLAGS += -Wl,-U,__Z15vl_time_stamp64v,-U,__Z13sc_time_stampv
+  LDFLAGS += -Wl,-U,__Z15vl_time_stamp64v,-U,__Z13sc_time_stampv
 endif
 
 # Allow upper level user makefiles to specify flags they want.
 # These aren't ever set by Verilator, so users are free to override them.
 CPPFLAGS += $(USER_CPPFLAGS)
-LDFLAGS  += $(USER_LDFLAGS)
-LDLIBS   += $(USER_LDLIBS)
+LDFLAGS += $(USER_LDFLAGS)
+LDLIBS += $(USER_LDLIBS)
 
 # Add flags from -CFLAGS and -LDFLAGS on Verilator command line
 CPPFLAGS += $(VM_USER_CFLAGS)
-LDFLAGS  += $(VM_USER_LDFLAGS)
-LDLIBS   += $(VM_USER_LDLIBS)
+LDFLAGS += $(VM_USER_LDFLAGS)
+LDLIBS += $(VM_USER_LDLIBS)
 
 ######################################################################
 # Optimization control.
@@ -147,7 +149,7 @@ OPT_GLOBAL = -Os
 
 ifeq ($(VM_PROFC),1)
   CPPFLAGS += $(CFG_CXXFLAGS_PROFILE)
-  LDFLAGS  += $(CFG_CXXFLAGS_PROFILE)
+  LDFLAGS += $(CFG_CXXFLAGS_PROFILE)
 endif
 
 #######################################################################
@@ -155,12 +157,12 @@ endif
 
 ifeq ($(VM_SC),1)
   CPPFLAGS += $(SYSTEMC_CXX_FLAGS) $(addprefix -I, $(SYSTEMC_INCLUDE))
-  LDFLAGS  += $(SYSTEMC_CXX_FLAGS) $(addprefix -L, $(SYSTEMC_LIBDIR))
-  SC_LIBS   = -lsystemc
- ifneq ($(wildcard $(SYSTEMC_LIBDIR)/*numeric_bit*),)
-  # SystemC 1.2.1beta
-  SC_LIBS   += -lnumeric_bit -lqt
- endif
+  LDFLAGS += $(SYSTEMC_CXX_FLAGS) $(addprefix -L, $(SYSTEMC_LIBDIR))
+  SC_LIBS = -lsystemc
+  ifneq ($(wildcard $(SYSTEMC_LIBDIR)/*numeric_bit*),)
+    # SystemC 1.2.1beta
+    SC_LIBS += -lnumeric_bit -lqt
+  endif
 endif
 
 #######################################################################
@@ -170,12 +172,11 @@ CPPFLAGS += $(CFG_CXXFLAGS_STD)
 LDLIBS += $(CFG_LDLIBS_THREADS)
 
 ifneq ($(VM_TIMING),0)
- ifneq ($(VM_TIMING),)
-  CPPFLAGS += $(CFG_CXXFLAGS_COROUTINES)
- endif
+  ifneq ($(VM_TIMING),)
+    CPPFLAGS += $(CFG_CXXFLAGS_COROUTINES)
+  endif
 endif
 
-
 #######################################################################
 ### Aggregates
 
@@ -257,7 +258,6 @@ endif
 
 $(VM_PREFIX)__ALL.a: $(VK_OBJS) $(VM_HIER_LIBS)
 
-
 ######################################################################
 ### Compile rules
 
@@ -268,24 +268,24 @@ ifneq ($(VM_DEFAULT_RULES),0)
 #
 # These rules put OPT_FAST/OPT_SLOW/OPT_GLOBAL before the other flags to
 # allow USER_CPPFLAGS to override them
-%.o: %.cpp
+  %.o: %.cpp
 	$(OBJCACHE) $(CXX) $(OPT_FAST) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
 
-$(VK_OBJS_FAST): %.o: %.cpp $(VK_PCH_H).fast.gch
+  $(VK_OBJS_FAST): %.o: %.cpp $(VK_PCH_H).fast.gch
 	$(OBJCACHE) $(CXX) $(OPT_FAST) $(CXXFLAGS) $(CPPFLAGS) $(VK_PCH_I_FAST) -c -o $@ $<
 
-$(VK_OBJS_SLOW): %.o: %.cpp $(VK_PCH_H).slow.gch
+  $(VK_OBJS_SLOW): %.o: %.cpp $(VK_PCH_H).slow.gch
 	$(OBJCACHE) $(CXX) $(OPT_SLOW) $(CXXFLAGS) $(CPPFLAGS) $(VK_PCH_I_SLOW) -c -o $@ $<
 
-$(VK_GLOBAL_OBJS): %.o: %.cpp
+  $(VK_GLOBAL_OBJS): %.o: %.cpp
 	$(OBJCACHE) $(CXX) $(OPT_GLOBAL) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
 
 # Precompile a header file
 # PCH's compiler flags must match exactly the rules' above FAST/SLOW
 # arguments used for the .cpp files, or the PCH file won't be used.
-%.fast.gch: %
+  %.fast.gch: %
 	$(OBJCACHE) $(CXX) $(OPT_FAST) $(CXXFLAGS) $(CPPFLAGS) $(CFG_CXXFLAGS_PCH) $< -o $@
-%.slow.gch: %
+  %.slow.gch: %
 	$(OBJCACHE) $(CXX) $(OPT_SLOW) $(CXXFLAGS) $(CPPFLAGS) $(CFG_CXXFLAGS_PCH) $< -o $@
 
 endif
@@ -312,22 +312,22 @@ ifneq ($(findstring ccache-report,$(MAKECMDGOALS)),)
   # Remove previous logfiles and report
   $(shell rm -rf $(VK_CCACHE_LOGDIR) $(VK_CCACHE_REPORT))
 
-$(VK_CCACHE_LOGDIR):
+  $(VK_CCACHE_LOGDIR):
 	mkdir -p $@
 
-$(VK_OBJS): | $(VK_CCACHE_LOGDIR)
+  $(VK_OBJS): | $(VK_CCACHE_LOGDIR)
 
-$(VK_OBJS): export CCACHE_LOGFILE=$(VK_CCACHE_LOGDIR)/[email protected]
+  $(VK_OBJS): export CCACHE_LOGFILE=$(VK_CCACHE_LOGDIR)/[email protected]
 
-$(VK_CCACHE_REPORT): $(VK_OBJS)
+  $(VK_CCACHE_REPORT): $(VK_OBJS)
 	$(VERILATOR_CCACHE_REPORT) -o $@ $(VK_CCACHE_LOGDIR)
 
-.PHONY: ccache-report
-ccache-report: $(VK_CCACHE_REPORT)
+  .PHONY: ccache-report
+  ccache-report: $(VK_CCACHE_REPORT)
 	@cat $<
 
 # ccache-report runs last
-ccache-report: $(VK_OTHER_GOALS)
+  ccache-report: $(VK_OTHER_GOALS)
 endif
 
 ######################################################################
@@ -357,5 +357,5 @@ debug-make::
 
 DEPS := $(wildcard *.d)
 ifneq ($(DEPS),)
-include $(DEPS)
+  include $(DEPS)
 endif

include/verilated_cov.cpp

@@ -255,17 +255,21 @@ private:
 
 public:
     // PUBLIC METHODS
+    // cppcheck-suppress duplInheritedMember
     std::string defaultFilename() VL_MT_SAFE { return m_contextp->coverageFilename(); }
+    // cppcheck-suppress duplInheritedMember
     void forcePerInstance(const bool flag) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock{m_mutex};
         m_forcePerInstance = flag;
     }
+    // cppcheck-suppress duplInheritedMember
     void clear() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock{m_mutex};
         clearGuts();
     }
+    // cppcheck-suppress duplInheritedMember
     void clearNonMatch(const char* const matchp) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock{m_mutex};
@@ -281,10 +285,11 @@ public:
             m_items = newlist;
         }
     }
+    // cppcheck-suppress duplInheritedMember
     void zero() VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock{m_mutex};
-        for (const auto& itemp : m_items) itemp->zero();
+        for (const VerilatedCovImpItem* const itemp : m_items) itemp->zero();
     }
 
     // We assume there's always call to i/f/p in that order
@@ -307,15 +312,17 @@ public:
         valps[0] = m_insertFilenamep;
         const std::string linestr = std::to_string(m_insertLineno);
         ckeyps[1] = "lineno";
+        // cppcheck-suppress autoVariables  // Used only below for insert
         valps[1] = linestr.c_str();
         // Default page if not specified
         const char* fnstartp = m_insertFilenamep;
         while (const char* foundp = std::strchr(fnstartp, '/')) fnstartp = foundp + 1;
         const char* fnendp = fnstartp;
-        for (; *fnendp && *fnendp != '.'; fnendp++) {}
+        for (; *fnendp && *fnendp != '.'; ++fnendp) {}
         const size_t page_len = fnendp - fnstartp;
         const std::string page_default = "sp_user/" + std::string{fnstartp, page_len};
         ckeyps[2] = "page";
+        // cppcheck-suppress autoVariables  // Used only below for insert
         valps[2] = page_default.c_str();
 
         // Keys -> strings
@@ -357,6 +364,7 @@ public:
         m_insertp = nullptr;
     }
 
+    // cppcheck-suppress duplInheritedMember
     void write(const std::string& filename) VL_MT_SAFE_EXCLUDES(m_mutex) {
         Verilated::quiesce();
         const VerilatedLockGuard lock{m_mutex};
@@ -390,6 +398,10 @@ public:
                         hier = val;
                     } else {
                         // Print it
+                        if (key == "page") {
+                            const std::string type = val.substr(2, val.find('/') - 2);
+                            name += keyValueFormatter(VL_CIK_TYPE, type);
+                        }
                         name += keyValueFormatter(key, val);
                     }
                 }

include/verilated_cov.h

@@ -75,6 +75,70 @@ class VerilatedCovImp;
         ccontextp->_insertp("hier", name, __VA_ARGS__); \
     } while (false)
 
+static inline void VL_COV_TOGGLE_CHG_ST_I(const int width, uint32_t* covp, const IData newData,
+                                          const IData oldData) {
+    const IData chgData = newData ^ oldData;
+    for (int i = 0; i < width; ++i) {
+        *(covp + 2 * i + ((newData >> i) & 1)) += (chgData >> i) & 1;
+    }
+}
+
+static inline void VL_COV_TOGGLE_CHG_ST_Q(const int width, uint32_t* covp, const QData newData,
+                                          const QData oldData) {
+    const QData chgData = newData ^ oldData;
+    for (int i = 0; i < width; ++i) {
+        *(covp + 2 * i + ((newData >> i) & 1)) += (chgData >> i) & 1;
+    }
+}
+
+static inline void VL_COV_TOGGLE_CHG_ST_W(const int width, uint32_t* covp, WDataInP newData,
+                                          WDataInP oldData) {
+    for (int i = 0; i < VL_WORDS_I(width); ++i) {
+        const EData chgData = newData[i] ^ oldData[i];
+        if (chgData) {
+            for (int j = 0; j < width - i * VL_EDATASIZE; ++j) {
+                *(covp + (i * VL_EDATASIZE + j) * 2 + ((newData[i] >> j) & 1))
+                    += (chgData >> j) & 1;
+            }
+        }
+    }
+}
+
+static inline void VL_COV_TOGGLE_CHG_MT_I(const int width, std::atomic<uint32_t>* covp,
+                                          const IData newData, const IData oldData) VL_MT_SAFE {
+    const IData chgData = newData ^ oldData;
+    for (int i = 0; i < width; ++i) {
+        if (VL_BITISSET_I(chgData, i)) {
+            (covp + 2 * i + ((newData >> i) & 1))->fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+}
+
+static inline void VL_COV_TOGGLE_CHG_MT_Q(const int width, std::atomic<uint32_t>* covp,
+                                          const QData newData, const QData oldData) VL_MT_SAFE {
+    const QData chgData = newData ^ oldData;
+    for (int i = 0; i < width; ++i) {
+        if (VL_BITISSET_Q(chgData, i)) {
+            (covp + 2 * i + ((newData >> i) & 1))->fetch_add(1, std::memory_order_relaxed);
+        }
+    }
+}
+
+static inline void VL_COV_TOGGLE_CHG_MT_W(const int width, std::atomic<uint32_t>* covp,
+                                          WDataInP newData, WDataInP oldData) VL_MT_SAFE {
+    for (int i = 0; i < VL_WORDS_I(width); ++i) {
+        const EData chgData = newData[i] ^ oldData[i];
+        if (chgData) {
+            for (int j = 0; j < width - i * VL_EDATASIZE; ++j) {
+                if (VL_BITISSET_E(chgData, j)) {
+                    (covp + (i * VL_EDATASIZE + j) * 2 + ((newData[i] >> j) & 1))
+                        ->fetch_add(1, std::memory_order_relaxed);
+                }
+            }
+        }
+    }
+}
+
 //=============================================================================
 //  VerilatedCov
 /// Per-VerilatedContext coverage data class.